win-Debug/gen/services/viz/public/interfaces/compositing/compositor_frame_sink.mojom-blink.h

// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef SERVICES_VIZ_PUBLIC_INTERFACES_COMPOSITING_COMPOSITOR_FRAME_SINK_MOJOM_BLINK_H_
#define SERVICES_VIZ_PUBLIC_INTERFACES_COMPOSITING_COMPOSITOR_FRAME_SINK_MOJOM_BLINK_H_

#include <stdint.h>

#include <limits>
#include <type_traits>
#include <utility>

#include "base/callback.h"
#include "base/macros.h"
#include "base/optional.h"

#include "mojo/public/cpp/bindings/mojo_buildflags.h"
#if BUILDFLAG(MOJO_TRACE_ENABLED)
#include "base/trace_event/trace_event.h"
#endif
#include "mojo/public/cpp/bindings/clone_traits.h"
#include "mojo/public/cpp/bindings/equals_traits.h"
#include "mojo/public/cpp/bindings/lib/serialization.h"
#include "mojo/public/cpp/bindings/struct_ptr.h"
#include "mojo/public/cpp/bindings/struct_traits.h"
#include "mojo/public/cpp/bindings/union_traits.h"
#include "services/viz/public/interfaces/compositing/compositor_frame_sink.mojom-shared.h"
#include "services/viz/public/interfaces/compositing/compositor_frame_sink.mojom-blink-forward.h"
#include "mojo/public/mojom/base/time.mojom-blink-forward.h"
#include "mojo/public/mojom/base/shared_memory.mojom-blink-forward.h"
#include "services/viz/public/interfaces/compositing/begin_frame_args.mojom-blink-forward.h"
#include "services/viz/public/interfaces/compositing/compositor_frame.mojom-blink-forward.h"
#include "services/viz/public/interfaces/compositing/local_surface_id.mojom-blink-forward.h"
#include "services/viz/public/interfaces/compositing/frame_timing_details.mojom-blink-forward.h"
#include "services/viz/public/interfaces/compositing/returned_resource.mojom-blink-forward.h"
#include "services/viz/public/interfaces/hit_test/hit_test_region_list.mojom-blink-forward.h"
#include "ui/gfx/geometry/mojo/geometry.mojom-blink-forward.h"
#include "gpu/ipc/common/mailbox.mojom-blink-forward.h"

#include "mojo/public/cpp/bindings/lib/wtf_clone_equals_util.h"
#include "mojo/public/cpp/bindings/lib/wtf_hash_util.h"
#include "third_party/blink/renderer/platform/wtf/hash_functions.h"
#include "third_party/blink/renderer/platform/wtf/text/wtf_string.h"

#include "mojo/public/cpp/bindings/associated_interface_ptr.h"
#include "mojo/public/cpp/bindings/associated_interface_ptr_info.h"
#include "mojo/public/cpp/bindings/associated_interface_request.h"
#include "mojo/public/cpp/bindings/interface_ptr.h"
#include "mojo/public/cpp/bindings/interface_request.h"
#include "mojo/public/cpp/bindings/lib/control_message_handler.h"
#include "mojo/public/cpp/bindings/raw_ptr_impl_ref_traits.h"
#include "mojo/public/cpp/bindings/thread_safe_interface_ptr.h"


#include "mojo/public/cpp/bindings/lib/native_enum_serialization.h"
#include "mojo/public/cpp/bindings/lib/native_struct_serialization.h"

#ifdef KYTHE_IS_RUNNING
#pragma kythe_inline_metadata "Metadata comment"
#endif


namespace viz {
namespace mojom {
namespace blink {

class CompositorFrameSinkProxy;

template <typename ImplRefTraits>
class CompositorFrameSinkStub;

class CompositorFrameSinkRequestValidator;
class CompositorFrameSinkResponseValidator;


// @generated_from: viz.mojom.CompositorFrameSink
class  CompositorFrameSink
    : public CompositorFrameSinkInterfaceBase {
 public:
  static const char Name_[];
  static constexpr uint32_t Version_ = 0;
  static constexpr bool PassesAssociatedKinds_ = false;
  static constexpr bool HasSyncMethods_ = true;

  using Base_ = CompositorFrameSinkInterfaceBase;
  using Proxy_ = CompositorFrameSinkProxy;

  template <typename ImplRefTraits>
  using Stub_ = CompositorFrameSinkStub<ImplRefTraits>;

  using RequestValidator_ = CompositorFrameSinkRequestValidator;
  using ResponseValidator_ = CompositorFrameSinkResponseValidator;
  enum MethodMinVersions : uint32_t {
    kSetNeedsBeginFrameMinVersion = 0,
    kSetWantsAnimateOnlyBeginFramesMinVersion = 0,
    kSubmitCompositorFrameMinVersion = 0,
    kSubmitCompositorFrameSyncMinVersion = 0,
    kDidNotProduceFrameMinVersion = 0,
    kDidAllocateSharedBitmapMinVersion = 0,
    kDidDeleteSharedBitmapMinVersion = 0,
  };
  virtual ~CompositorFrameSink() {}

  
// @generated_from: viz.mojom.CompositorFrameSink.SetNeedsBeginFrame
  virtual void SetNeedsBeginFrame(bool needs_begin_frame) = 0;

  
// @generated_from: viz.mojom.CompositorFrameSink.SetWantsAnimateOnlyBeginFrames
  virtual void SetWantsAnimateOnlyBeginFrames() = 0;

  
// @generated_from: viz.mojom.CompositorFrameSink.SubmitCompositorFrame
  virtual void SubmitCompositorFrame(const viz::LocalSurfaceId& local_surface_id, viz::CompositorFrame frame, ::viz::mojom::blink::HitTestRegionListPtr hit_test_region_list, uint64_t submit_time) = 0;

  // Sync method. This signature is used by the client side; the service side
  // should implement the signature with callback below.
  
// @generated_from: viz.mojom.CompositorFrameSink.SubmitCompositorFrameSync
  virtual bool SubmitCompositorFrameSync(const viz::LocalSurfaceId& local_surface_id, viz::CompositorFrame frame, ::viz::mojom::blink::HitTestRegionListPtr hit_test_region_list, uint64_t submit_time, WTF::Vector<viz::ReturnedResource>* out_resources);

  using SubmitCompositorFrameSyncCallback = base::OnceCallback<void(const WTF::Vector<viz::ReturnedResource>&)>;
  
// @generated_from: viz.mojom.CompositorFrameSink.SubmitCompositorFrameSync
  virtual void SubmitCompositorFrameSync(const viz::LocalSurfaceId& local_surface_id, viz::CompositorFrame frame, ::viz::mojom::blink::HitTestRegionListPtr hit_test_region_list, uint64_t submit_time, SubmitCompositorFrameSyncCallback callback) = 0;

  
// @generated_from: viz.mojom.CompositorFrameSink.DidNotProduceFrame
  virtual void DidNotProduceFrame(const viz::BeginFrameAck& ack) = 0;

  
// @generated_from: viz.mojom.CompositorFrameSink.DidAllocateSharedBitmap
  virtual void DidAllocateSharedBitmap(base::ReadOnlySharedMemoryRegion region, ::gpu::mojom::blink::MailboxPtr id) = 0;

  
// @generated_from: viz.mojom.CompositorFrameSink.DidDeleteSharedBitmap
  virtual void DidDeleteSharedBitmap(::gpu::mojom::blink::MailboxPtr id) = 0;
};

class CompositorFrameSinkClientProxy;

template <typename ImplRefTraits>
class CompositorFrameSinkClientStub;

class CompositorFrameSinkClientRequestValidator;


// @generated_from: viz.mojom.CompositorFrameSinkClient
class  CompositorFrameSinkClient
    : public CompositorFrameSinkClientInterfaceBase {
 public:
  static const char Name_[];
  static constexpr uint32_t Version_ = 0;
  static constexpr bool PassesAssociatedKinds_ = false;
  static constexpr bool HasSyncMethods_ = false;

  using Base_ = CompositorFrameSinkClientInterfaceBase;
  using Proxy_ = CompositorFrameSinkClientProxy;

  template <typename ImplRefTraits>
  using Stub_ = CompositorFrameSinkClientStub<ImplRefTraits>;

  using RequestValidator_ = CompositorFrameSinkClientRequestValidator;
  using ResponseValidator_ = mojo::PassThroughFilter;
  enum MethodMinVersions : uint32_t {
    kDidReceiveCompositorFrameAckMinVersion = 0,
    kOnBeginFrameMinVersion = 0,
    kOnBeginFramePausedChangedMinVersion = 0,
    kReclaimResourcesMinVersion = 0,
  };
  virtual ~CompositorFrameSinkClient() {}

  
// @generated_from: viz.mojom.CompositorFrameSinkClient.DidReceiveCompositorFrameAck
  virtual void DidReceiveCompositorFrameAck(const WTF::Vector<viz::ReturnedResource>& resources) = 0;

  
// @generated_from: viz.mojom.CompositorFrameSinkClient.OnBeginFrame
  virtual void OnBeginFrame(const viz::BeginFrameArgs& args, WTF::HashMap<uint32_t, ::viz::mojom::blink::FrameTimingDetailsPtr> details) = 0;

  
// @generated_from: viz.mojom.CompositorFrameSinkClient.OnBeginFramePausedChanged
  virtual void OnBeginFramePausedChanged(bool paused) = 0;

  
// @generated_from: viz.mojom.CompositorFrameSinkClient.ReclaimResources
  virtual void ReclaimResources(const WTF::Vector<viz::ReturnedResource>& resources) = 0;
};

class  CompositorFrameSinkProxy
    : public CompositorFrameSink {
 public:
  using InterfaceType = CompositorFrameSink;

  explicit CompositorFrameSinkProxy(mojo::MessageReceiverWithResponder* receiver);
  void SetNeedsBeginFrame(bool needs_begin_frame) final;
  void SetWantsAnimateOnlyBeginFrames() final;
  void SubmitCompositorFrame(const viz::LocalSurfaceId& local_surface_id, viz::CompositorFrame frame, ::viz::mojom::blink::HitTestRegionListPtr hit_test_region_list, uint64_t submit_time) final;
  bool SubmitCompositorFrameSync(const viz::LocalSurfaceId& local_surface_id, viz::CompositorFrame frame, ::viz::mojom::blink::HitTestRegionListPtr hit_test_region_list, uint64_t submit_time, WTF::Vector<viz::ReturnedResource>* out_resources) final;
  void SubmitCompositorFrameSync(const viz::LocalSurfaceId& local_surface_id, viz::CompositorFrame frame, ::viz::mojom::blink::HitTestRegionListPtr hit_test_region_list, uint64_t submit_time, SubmitCompositorFrameSyncCallback callback) final;
  void DidNotProduceFrame(const viz::BeginFrameAck& ack) final;
  void DidAllocateSharedBitmap(base::ReadOnlySharedMemoryRegion region, ::gpu::mojom::blink::MailboxPtr id) final;
  void DidDeleteSharedBitmap(::gpu::mojom::blink::MailboxPtr id) final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};

class  CompositorFrameSinkClientProxy
    : public CompositorFrameSinkClient {
 public:
  using InterfaceType = CompositorFrameSinkClient;

  explicit CompositorFrameSinkClientProxy(mojo::MessageReceiverWithResponder* receiver);
  void DidReceiveCompositorFrameAck(const WTF::Vector<viz::ReturnedResource>& resources) final;
  void OnBeginFrame(const viz::BeginFrameArgs& args, WTF::HashMap<uint32_t, ::viz::mojom::blink::FrameTimingDetailsPtr> details) final;
  void OnBeginFramePausedChanged(bool paused) final;
  void ReclaimResources(const WTF::Vector<viz::ReturnedResource>& resources) final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};
class  CompositorFrameSinkStubDispatch {
 public:
  static bool Accept(CompositorFrameSink* impl, mojo::Message* message);
  static bool AcceptWithResponder(
      CompositorFrameSink* impl,
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder);
};

template <typename ImplRefTraits =
              mojo::RawPtrImplRefTraits<CompositorFrameSink>>
class CompositorFrameSinkStub
    : public mojo::MessageReceiverWithResponderStatus {
 public:
  using ImplPointerType = typename ImplRefTraits::PointerType;

  CompositorFrameSinkStub() {}
  ~CompositorFrameSinkStub() override {}

  void set_sink(ImplPointerType sink) { sink_ = std::move(sink); }
  ImplPointerType& sink() { return sink_; }

  bool Accept(mojo::Message* message) override {
    if (ImplRefTraits::IsNull(sink_))
      return false;
    return CompositorFrameSinkStubDispatch::Accept(
        ImplRefTraits::GetRawPointer(&sink_), message);
  }

  bool AcceptWithResponder(
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override {
    if (ImplRefTraits::IsNull(sink_))
      return false;
    return CompositorFrameSinkStubDispatch::AcceptWithResponder(
        ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder));
  }

 private:
  ImplPointerType sink_;
};
class  CompositorFrameSinkClientStubDispatch {
 public:
  static bool Accept(CompositorFrameSinkClient* impl, mojo::Message* message);
  static bool AcceptWithResponder(
      CompositorFrameSinkClient* impl,
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder);
};

template <typename ImplRefTraits =
              mojo::RawPtrImplRefTraits<CompositorFrameSinkClient>>
class CompositorFrameSinkClientStub
    : public mojo::MessageReceiverWithResponderStatus {
 public:
  using ImplPointerType = typename ImplRefTraits::PointerType;

  CompositorFrameSinkClientStub() {}
  ~CompositorFrameSinkClientStub() override {}

  void set_sink(ImplPointerType sink) { sink_ = std::move(sink); }
  ImplPointerType& sink() { return sink_; }

  bool Accept(mojo::Message* message) override {
    if (ImplRefTraits::IsNull(sink_))
      return false;
    return CompositorFrameSinkClientStubDispatch::Accept(
        ImplRefTraits::GetRawPointer(&sink_), message);
  }

  bool AcceptWithResponder(
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override {
    if (ImplRefTraits::IsNull(sink_))
      return false;
    return CompositorFrameSinkClientStubDispatch::AcceptWithResponder(
        ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder));
  }

 private:
  ImplPointerType sink_;
};
class  CompositorFrameSinkRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  CompositorFrameSinkClientRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  CompositorFrameSinkResponseValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};





}  // namespace blink
}  // namespace mojom
}  // namespace viz

namespace mojo {

}  // namespace mojo

#endif  // SERVICES_VIZ_PUBLIC_INTERFACES_COMPOSITING_COMPOSITOR_FRAME_SINK_MOJOM_BLINK_H_
/* Metadata comment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==
*/