[NotForReview] Convert accelerated JPEG Decoder IPC to Mojo

media/gpu/ipc/client/gpu_jpeg_decode_accelerator_host.cc

 // Copyright 2015 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 "media/gpu/ipc/client/gpu_jpeg_decode_accelerator_host.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/shared_memory_handle.h"
-#include "base/memory/weak_ptr.h"
-#include "base/synchronization/waitable_event.h"
 #include "build/build_config.h"
-#include "gpu/ipc/client/gpu_channel_host.h"
-#include "ipc/ipc_listener.h"
-#include "ipc/ipc_message_macros.h"
-#include "ipc/ipc_message_utils.h"
-#include "media/gpu/ipc/common/media_messages.h"
+#include "content/public/browser/gpu_service_registry.h"
+#include "mojo/public/cpp/system/platform_handle.h"
+
+namespace {
+
+void ConnectToGpuJpegDecodeAccelerator(
+    media::mojom::GpuJpegDecodeAcceleratorRequest request) {
+  content::BindInterfaceInGpuProcess(std::move(request));
+}
+
+}  // namespace
 
 namespace media {
 
-// Class to receive AcceleratedJpegDecoderHostMsg_DecodeAck IPC message on IO
-// thread. This does very similar what MessageFilter usually does. It is not
-// MessageFilter because GpuChannelHost doesn't support AddFilter.
-class GpuJpegDecodeAcceleratorHost::Receiver : public IPC::Listener {
- public:
-  Receiver(Client* client,
-           const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner)
-      : client_(client),
-        io_task_runner_(io_task_runner),
-        weak_factory_for_io_(
-            base::MakeUnique<base::WeakPtrFactory<Receiver>>(this)),
-        weak_ptr_for_io_(weak_factory_for_io_->GetWeakPtr()) {
-    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  }
-
-  ~Receiver() override {
-    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-    // If |io_task_runner_| no longer accepts tasks, |weak_factory_for_io_|
-    // will leak. This is acceptable, because that should only happen on
-    // Browser shutdown.
-    io_task_runner_->DeleteSoon(FROM_HERE, weak_factory_for_io_.release());
-  }
-
-  void InvalidateWeakPtrOnIOThread(base::WaitableEvent* event) {
-    DCHECK(io_task_runner_->BelongsToCurrentThread());
-    weak_factory_for_io_->InvalidateWeakPtrs();
-    event->Signal();
-  }
-
-  // IPC::Listener implementation.
-  void OnChannelError() override {
-    DCHECK(io_task_runner_->BelongsToCurrentThread());
-
-    OnDecodeAck(kInvalidBitstreamBufferId, PLATFORM_FAILURE);
-  }
-
-  bool OnMessageReceived(const IPC::Message& msg) override {
-    DCHECK(io_task_runner_->BelongsToCurrentThread());
-
-    bool handled = true;
-    IPC_BEGIN_MESSAGE_MAP(GpuJpegDecodeAcceleratorHost::Receiver, msg)
-      IPC_MESSAGE_HANDLER(AcceleratedJpegDecoderHostMsg_DecodeAck, OnDecodeAck)
-      IPC_MESSAGE_UNHANDLED(handled = false)
-    IPC_END_MESSAGE_MAP()
-    DCHECK(handled);
-    return handled;
-  }
-
-  base::WeakPtr<IPC::Listener> AsWeakPtrForIO() { return weak_ptr_for_io_; }
-
- private:
-  void OnDecodeAck(int32_t bitstream_buffer_id, Error error) {
-    DCHECK(io_task_runner_->BelongsToCurrentThread());
-
-    if (!client_)
-      return;
-
-    if (error == JpegDecodeAccelerator::NO_ERRORS) {
-      client_->VideoFrameReady(bitstream_buffer_id);
-    } else {
-      // Only NotifyError once.
-      // Client::NotifyError() may trigger deletion of |this| (on another
-      // thread), so calling it needs to be the last thing done on this stack!
-      JpegDecodeAccelerator::Client* client = nullptr;
-      std::swap(client, client_);
-      client->NotifyError(bitstream_buffer_id, error);
-    }
-  }
-
-  Client* client_;
-
-  // GPU IO task runner.
-  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
-
-  SEQUENCE_CHECKER(sequence_checker_);
-
-  // Weak pointers will be invalidated on IO thread.
-  std::unique_ptr<base::WeakPtrFactory<Receiver>> weak_factory_for_io_;
-  base::WeakPtr<Receiver> weak_ptr_for_io_;
-
-  DISALLOW_COPY_AND_ASSIGN(Receiver);
-};
-
 GpuJpegDecodeAcceleratorHost::GpuJpegDecodeAcceleratorHost(
-    scoped_refptr<gpu::GpuChannelHost> channel,
-    int32_t route_id,
-    const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner)
-    : channel_(std::move(channel)),
-      decoder_route_id_(route_id),
-      io_task_runner_(io_task_runner) {
-  DCHECK(channel_);
-  DCHECK_NE(decoder_route_id_, MSG_ROUTING_NONE);
+    scoped_refptr<base::SingleThreadTaskRunner> io_task_runner)
+    : io_task_runner_(io_task_runner) {
+  auto request = mojo::MakeRequest(&jpeg_decoder_);
+  io_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&ConnectToGpuJpegDecodeAccelerator, base::Passed(&request)));
 }
 
 GpuJpegDecodeAcceleratorHost::~GpuJpegDecodeAcceleratorHost() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  Send(new AcceleratedJpegDecoderMsg_Destroy(decoder_route_id_));
-
-  if (receiver_) {
-    channel_->RemoveRoute(decoder_route_id_);
-
-    // Invalidate weak ptr of |receiver_|. After that, no more messages will be
-    // routed to |receiver_| on IO thread.
-    base::WaitableEvent event(base::WaitableEvent::ResetPolicy::AUTOMATIC,
-                              base::WaitableEvent::InitialState::NOT_SIGNALED);
-    // Use of Unretained() is safe, because if the task executes, we block
-    // until it is finished by waiting on |event| below.
-    bool task_expected_to_run = io_task_runner_->PostTask(
-        FROM_HERE, base::Bind(&Receiver::InvalidateWeakPtrOnIOThread,
-                              base::Unretained(receiver_.get()),
-                              base::Unretained(&event)));
-    // If the current call is happening during the browser shutdown, the
-    // |io_task_runner_| may no longer be accepting tasks.
-    if (task_expected_to_run)
-      event.Wait();
-  }
 }
 
 bool GpuJpegDecodeAcceleratorHost::Initialize(
     JpegDecodeAccelerator::Client* client) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   bool succeeded = false;
-  // This cannot be on IO thread because the msg is synchronous.
-  Send(new GpuChannelMsg_CreateJpegDecoder(decoder_route_id_, &succeeded));
+  jpeg_decoder_->Initialize(&succeeded);
 
-  if (!succeeded) {
-    DLOG(ERROR) << "Send(GpuChannelMsg_CreateJpegDecoder()) failed";
-    return false;
+  if (succeeded)
+    client_ = client;
+
+  return succeeded;
+}
+
+void GpuJpegDecodeAcceleratorHost::OnDecodeAckOnIOThread(
+    int32_t bitstream_buffer_id,
+    mojom::Error error) {
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
+
+  if (!client_)
+    return;
+
+  if (error == mojom::Error::NO_ERRORS) {
+    client_->VideoFrameReady(bitstream_buffer_id);
+  } else {
+    // Only NotifyError once.
+    // Client::NotifyError() may trigger deletion of |this| (on another
+    // thread), so calling it needs to be the last thing done on this stack!
+    JpegDecodeAccelerator::Client* client = nullptr;
+    std::swap(client, client_);
+    client->NotifyError(bitstream_buffer_id,
+                        static_cast<JpegDecodeAccelerator::Error>(error));
   }
+}
 
-  receiver_.reset(new Receiver(client, io_task_runner_));
+void GpuJpegDecodeAcceleratorHost::OnDecodeAck(int32_t bitstream_buffer_id,
+                                               mojom::Error error) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
-  return true;
+  io_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&GpuJpegDecodeAcceleratorHost::OnDecodeAckOnIOThread,
+                 base::Unretained(this), bitstream_buffer_id, error));
 }
 
 void GpuJpegDecodeAcceleratorHost::Decode(
     const BitstreamBuffer& bitstream_buffer,
     const scoped_refptr<VideoFrame>& video_frame) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   DCHECK(
       base::SharedMemory::IsHandleValid(video_frame->shared_memory_handle()));
 
-  AcceleratedJpegDecoderMsg_Decode_Params decode_params;
-  decode_params.input_buffer = bitstream_buffer;
   base::SharedMemoryHandle input_handle =
-      channel_->ShareToGpuProcess(bitstream_buffer.handle());
+      base::SharedMemory::DuplicateHandle(bitstream_buffer.handle());
   if (!base::SharedMemory::IsHandleValid(input_handle)) {
     DLOG(ERROR) << "Failed to duplicate handle of BitstreamBuffer";
     return;
   }
-  decode_params.input_buffer.set_handle(input_handle);
+
   base::SharedMemoryHandle output_handle =
-      channel_->ShareToGpuProcess(video_frame->shared_memory_handle());
+      base::SharedMemory::DuplicateHandle(video_frame->shared_memory_handle());
   if (!base::SharedMemory::IsHandleValid(output_handle)) {
     DLOG(ERROR) << "Failed to duplicate handle of VideoFrame";
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
     if (input_handle.OwnershipPassesToIPC()) {
       input_handle.Close();
     }
 #else
 // TODO(kcwu) fix the handle leak after crbug.com/493414 resolved.
 #endif
     return;
   }
 
+  mojo::ScopedSharedBufferHandle input_buffer_handle =
+      mojo::WrapSharedMemoryHandle(input_handle, input_handle.GetSize(),
+                                   true /* read_only */);
+  mojom::BitstreamBufferPtr buffer = mojom::BitstreamBuffer::New();
+  buffer->id = bitstream_buffer.id();
+  buffer->memory_handle = std::move(input_buffer_handle);
+  buffer->size = bitstream_buffer.size();
+  buffer->offset = bitstream_buffer.offset();
+  buffer->timestamp = bitstream_buffer.presentation_timestamp();
+  buffer->key_id = bitstream_buffer.key_id();
+  buffer->iv = bitstream_buffer.iv();
+  buffer->subsamples = bitstream_buffer.subsamples();
+
+  mojo::ScopedSharedBufferHandle output_frame_handle =
+      mojo::WrapSharedMemoryHandle(output_handle, output_handle.GetSize(),
+                                   false /* read_only */);
+
   size_t output_buffer_size = VideoFrame::AllocationSize(
       video_frame->format(), video_frame->coded_size());
 
-  decode_params.coded_size = video_frame->coded_size();
-  decode_params.output_video_frame_handle = output_handle;
-  decode_params.output_buffer_size =
-      base::checked_cast<uint32_t>(output_buffer_size);
-  Send(new AcceleratedJpegDecoderMsg_Decode(decoder_route_id_, decode_params));
+  jpeg_decoder_->Decode(std::move(buffer), video_frame->coded_size(),
+                        std::move(output_frame_handle),
+                        base::checked_cast<uint32_t>(output_buffer_size),
+                        base::Bind(&GpuJpegDecodeAcceleratorHost::OnDecodeAck,
+                                   base::Unretained(this)));
 }
 
 bool GpuJpegDecodeAcceleratorHost::IsSupported() {
-  return channel_->gpu_info().jpeg_decode_accelerator_supported;
-}
-
-void GpuJpegDecodeAcceleratorHost::Send(IPC::Message* message) {
-  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-
-  if (!channel_->Send(message)) {
-    DLOG(ERROR) << "Send(" << message->type() << ") failed";
-  }
-}
-
-base::WeakPtr<IPC::Listener> GpuJpegDecodeAcceleratorHost::GetReceiver() {
-  return receiver_->AsWeakPtrForIO();
+  return true;
 }
 
 }  // namespace media