Sample code: IPC Transport object for GPU

content/common/gpu/client/ipc/chrome/chrome_gpu_video_encode_accelerator_host_ipc_transport.cc

Index: content/common/gpu/client/ipc/chrome/chrome_gpu_video_encode_accelerator_host_ipc_transport.cc
diff --git a/content/common/gpu/client/ipc/chrome/chrome_gpu_video_encode_accelerator_host_ipc_transport.cc b/content/common/gpu/client/ipc/chrome/chrome_gpu_video_encode_accelerator_host_ipc_transport.cc
new file mode 100644
index 0000000000000000000000000000000000000000..10a49f34cd8c625e0def369f475e16e4923b7ae4
--- /dev/null
+++ b/content/common/gpu/client/ipc/chrome/chrome_gpu_video_encode_accelerator_host_ipc_transport.cc
@@ -0,0 +1,170 @@
+// Copyright 2016 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.
+
+#include "content/common/gpu/client/ipc/chrome/chrome_gpu_video_encode_accelerator_host_ipc_transport.h"
+
+#include "content/common/gpu/client/ipc/chrome/chrome_gpu_channel_host_ipc_transport.h"
+#include "content/common/gpu/gpu_messages.h"
+
+namespace content {
+
+// static
+scoped_ptr<GpuVideoEncodeAcceleratorHostIPCTransport>
+ChromeGpuVideoEncodeAcceleratorHostIPCTransport::Create() {
+  return make_scoped_ptr<GpuVideoEncodeAcceleratorHostIPCTransport>(
+      new ChromeGpuVideoEncodeAcceleratorHostIPCTransport());
+}
+
+ChromeGpuVideoEncodeAcceleratorHostIPCTransport::
+    ~ChromeGpuVideoEncodeAcceleratorHostIPCTransport() {}
+
+void ChromeGpuVideoEncodeAcceleratorHostIPCTransport::BindToService(
+    ChromeGpuChannelHostIPCTransport* channel_transport) {
+  channel_transport_ = channel_transport;
+  if (channel_transport_) {
+    route_id_ = channel_transport_->GenerateRouteID();
+  } else {
+    route_id_ = MSG_ROUTING_NONE;
+  }
+}
+
+base::WeakPtr<ChromeGpuVideoEncodeAcceleratorHostIPCTransport>
+ChromeGpuVideoEncodeAcceleratorHostIPCTransport::AsWeakPtr() {
+  return weak_factory_.GetWeakPtr();
+}
+
+ChromeGpuVideoEncodeAcceleratorHostIPCTransport::
+    ChromeGpuVideoEncodeAcceleratorHostIPCTransport()
+    : channel_transport_(nullptr),
+      route_id_(MSG_ROUTING_NONE),
+      client_(nullptr),
+      weak_factory_(this) {}
+
+bool ChromeGpuVideoEncodeAcceleratorHostIPCTransport::OnMessageReceived(
+    const IPC::Message& msg) {
+  if (!client_)
+    return false;
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(ChromeGpuVideoEncodeAcceleratorHostIPCTransport, msg)
+    IPC_MESSAGE_HANDLER(AcceleratedVideoEncoderHostMsg_RequireBitstreamBuffers,
+                        OnRequireBitstreamBuffers)
+    IPC_MESSAGE_HANDLER(AcceleratedVideoEncoderHostMsg_NotifyInputDone,
+                        OnNotifyInputDone)
+    IPC_MESSAGE_HANDLER(AcceleratedVideoEncoderHostMsg_BitstreamBufferReady,
+                        OnBitstreamBufferReady)
+    IPC_MESSAGE_HANDLER(AcceleratedVideoEncoderHostMsg_NotifyError,
+                        OnNotifyError)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  DCHECK(handled);
+  // See OnNotifyError for why |this| mustn't be used after OnNotifyError might
+  // have been called above.
+  return handled;
+}
+
+void ChromeGpuVideoEncodeAcceleratorHostIPCTransport::OnChannelError() {
+  if (channel_transport_) {
+    if (route_id_ != MSG_ROUTING_NONE)
+      channel_transport_->RemoveRoute(route_id_);
+    channel_transport_ = nullptr;
+  }
+  DLOG(ERROR) << "OnChannelError()";
+  PostNotifyError(media::VideoEncodeAccelerator::kPlatformFailureError);
+}
+
+bool ChromeGpuVideoEncodeAcceleratorHostIPCTransport::Send(
+    IPC::Message* message) {
+  DCHECK(channel_transport_);
+  if (channel_transport_) {
+    if (channel_transport_->Send(message)) {
+      return true;
+    } else {
+      uint32_t message_type = message->type();
+      DLOG(ERROR) << "Send(" << message_type << ") failed";
+      PostNotifyError(media::VideoEncodeAccelerator::kPlatformFailureError);
+      return false;
+    }
+  }
+  // Callee takes ownership of message, regardless of whether Send is
+  // successful. See IPC::Sender.
+  delete message;
+  return false;
+}
+
+void ChromeGpuVideoEncodeAcceleratorHostIPCTransport::PostNotifyError(
+    media::VideoEncodeAccelerator::Error error) {
+  DVLOG(2) << "PostNotifyError(): error=" << error;
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE,
+      base::Bind(
+          &ChromeGpuVideoEncodeAcceleratorHostIPCTransport::OnNotifyError,
+          weak_factory_.GetWeakPtr(), error));
+}
+
+bool ChromeGpuVideoEncodeAcceleratorHostIPCTransport::Destroy() {
+  return Send(new AcceleratedVideoEncoderMsg_Destroy(route_id_));
+}
+
+bool ChromeGpuVideoEncodeAcceleratorHostIPCTransport::Encode(
+    const content::VideoEncodeParams& params) {
+  return Send(new AcceleratedVideoEncoderMsg_Encode(route_id_, params));
+}
+
+bool ChromeGpuVideoEncodeAcceleratorHostIPCTransport::Encode2(
+    const content::VideoEncodeParams2& params) {
+  return Send(new AcceleratedVideoEncoderMsg_Encode2(route_id_, params));
+}
+
+bool ChromeGpuVideoEncodeAcceleratorHostIPCTransport::
+    RequestEncodingParametersChange(uint32_t bitrate, uint32_t framerate) {
+  return Send(new AcceleratedVideoEncoderMsg_RequestEncodingParametersChange(
+      route_id_, bitrate, framerate));
+}
+
+void ChromeGpuVideoEncodeAcceleratorHostIPCTransport::SetClient(
+    GpuVideoEncodeAcceleratorHostIPCTransport::Client* client) {
+  client_ = client;
+}
+
+bool ChromeGpuVideoEncodeAcceleratorHostIPCTransport::UseOutputBitstreamBuffer(
+    int32_t buffer_id,
+    const base::SharedMemoryHandle& buffer_handle,
+    uint32_t buffer_size) {
+  return Send(new AcceleratedVideoEncoderMsg_UseOutputBitstreamBuffer(
+      route_id_, buffer_id, buffer_handle, buffer_size));
+}
+
+void ChromeGpuVideoEncodeAcceleratorHostIPCTransport::OnRequireBitstreamBuffers(
+    uint32_t input_count,
+    const gfx::Size& input_coded_size,
+    uint32_t output_buffer_size) {
+  if (client_) {
+    client_->OnRequireBitstreamBuffers(input_count, input_coded_size,
+                                       output_buffer_size);
+  }
+}
+
+void ChromeGpuVideoEncodeAcceleratorHostIPCTransport::OnNotifyInputDone(
+    int32_t frame_id) {
+  if (client_)
+    client_->OnNotifyInputDone(frame_id);
+}
+
+void ChromeGpuVideoEncodeAcceleratorHostIPCTransport::OnBitstreamBufferReady(
+    int32_t bitstream_buffer_id,
+    uint32_t payload_size,
+    bool key_frame) {
+  if (client_) {
+    client_->OnBitstreamBufferReady(bitstream_buffer_id, payload_size,
+                                    key_frame);
+  }
+}
+
+void ChromeGpuVideoEncodeAcceleratorHostIPCTransport::OnNotifyError(
+    media::VideoEncodeAccelerator::Error error) {
+  if (client_)
+    client_->OnNotifyError(error);
+}
+
+}  // namespace content