VideoCapture: more migration IPC-->mojo, part 6

content/renderer/media/video_capture_impl.cc

 // Copyright (c) 2012 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.
 //
 // Notes about usage of this object by VideoCaptureImplManager.
 //
 // VideoCaptureImplManager access this object by using a Unretained()
 // binding and tasks on the IO thread. It is then important that
 // VideoCaptureImpl never post task to itself. All operations must be
 // synchronous.
 
 #include "content/renderer/media/video_capture_impl.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/stl_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/child/child_process.h"
 #include "content/common/media/video_capture_messages.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/limits.h"
 #include "media/base/video_frame.h"
+#include "mojo/public/cpp/system/platform_handle.h"
 
 namespace content {
 
 // A holder of a memory-backed buffer and accessors to it.
 class VideoCaptureImpl::ClientBuffer
     : public base::RefCountedThreadSafe<ClientBuffer> {
  public:
   ClientBuffer(std::unique_ptr<base::SharedMemory> buffer, size_t buffer_size)
       : buffer_(std::move(buffer)), buffer_size_(buffer_size) {}
 
@@ skipping 132 matching lines @@
 
 void VideoCaptureImpl::GetDeviceFormatsInUse(
     const VideoCaptureDeviceFormatsCB& callback) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   GetVideoCaptureHost()->GetDeviceFormatsInUse(
       device_id_, session_id_,
       base::Bind(&VideoCaptureImpl::OnDeviceFormatsInUse,
                  weak_factory_.GetWeakPtr(), callback));
 }
 
-void VideoCaptureImpl::OnBufferCreated(base::SharedMemoryHandle handle,
-                                       int length,
-                                       int buffer_id) {
-  DCHECK(io_task_runner_->BelongsToCurrentThread());
-
-  // In case client calls StopCapture before the arrival of created buffer,
-  // just close this buffer and return.
-  if (state_ != VIDEO_CAPTURE_STATE_STARTED) {
-    base::SharedMemory::CloseHandle(handle);
-    return;
-  }
-
-  std::unique_ptr<base::SharedMemory> shm(
-      new base::SharedMemory(handle, false));
-  if (!shm->Map(length)) {
-    DLOG(ERROR) << "OnBufferCreated: Map failed.";
-    return;
-  }
-  const bool inserted =
-      client_buffers_.insert(std::make_pair(
-                                 buffer_id,
-                                 new ClientBuffer(std::move(shm), length)))
-          .second;
-  DCHECK(inserted);
-}
-
 void VideoCaptureImpl::OnDelegateAdded(int32_t device_id) {
   DVLOG(1) << __func__ << " " << device_id;
   DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   device_id_ = device_id;
   ClientInfoMap::iterator it = clients_pending_on_filter_.begin();
   while (it != clients_pending_on_filter_.end()) {
     const int client_id = it->first;
     const ClientInfo client_info = it->second;
     clients_pending_on_filter_.erase(it++);
@@ skipping 35 matching lines @@
     case mojom::VideoCaptureState::ENDED:
       // We'll only notify the client that the stream has stopped.
       for (const auto& client : clients_)
         client.second.state_update_cb.Run(VIDEO_CAPTURE_STATE_STOPPED);
       clients_.clear();
       state_ = VIDEO_CAPTURE_STATE_ENDED;
       break;
   }
 }
 
+void VideoCaptureImpl::OnBufferCreated(int32_t buffer_id,
+                                       mojo::ScopedSharedBufferHandle handle) {
+  DVLOG(1) << __func__ << " buffer_id: " << buffer_id;
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
+  DCHECK(handle.is_valid());
+
+  if (state_ != VIDEO_CAPTURE_STATE_STARTED)
+    return;
+
+  base::SharedMemoryHandle memory_handle;
+  size_t memory_size = 0;
+  bool read_only_flag = false;
+
+  const MojoResult result = mojo::UnwrapSharedMemoryHandle(
+      std::move(handle), &memory_handle, &memory_size, &read_only_flag);
+  DCHECK_EQ(MOJO_RESULT_OK, result);
+  DCHECK_GT(memory_size, 0u);
+
+  std::unique_ptr<base::SharedMemory> shm(
+      new base::SharedMemory(memory_handle, true /* read_only */));
+  if (!shm->Map(memory_size)) {
+    DLOG(ERROR) << "OnBufferCreated: Map failed.";
+    return;
+  }
+  const bool inserted =
+      client_buffers_
+          .insert(std::make_pair(buffer_id,
+                                 new ClientBuffer(std::move(shm), memory_size)))
+          .second;
+  DCHECK(inserted);
+}
+
 void VideoCaptureImpl::OnBufferReady(int32_t buffer_id,
                                      mojom::VideoFrameInfoPtr info) {
   DVLOG(1) << __func__ << " buffer_id: " << buffer_id;
-
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(media::PIXEL_FORMAT_I420, info->pixel_format);
   DCHECK_EQ(media::PIXEL_STORAGE_CPU, info->storage_type);
 
   if (state_ != VIDEO_CAPTURE_STATE_STARTED ||
       info->pixel_format != media::PIXEL_FORMAT_I420 ||
       info->storage_type != media::PIXEL_STORAGE_CPU) {
     GetVideoCaptureHost()->ReleaseBuffer(device_id_, buffer_id,
                                          gpu::SyncToken(), -1.0);
     return;
@@ skipping 122 matching lines @@
   callback.Run(supported_formats);
 }
 
 void VideoCaptureImpl::OnDeviceFormatsInUse(
     const VideoCaptureDeviceFormatsCB& callback,
     const media::VideoCaptureFormats& formats_in_use) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   callback.Run(formats_in_use);
 }
 
-void VideoCaptureImpl::Send(IPC::Message* message) {
-  DCHECK(io_task_runner_->BelongsToCurrentThread());
-  message_filter_->Send(message);
-}
-
 bool VideoCaptureImpl::RemoveClient(int client_id, ClientInfoMap* clients) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   const ClientInfoMap::iterator it = clients->find(client_id);
   if (it == clients->end())
     return false;
 
   it->second.state_update_cb.Run(VIDEO_CAPTURE_STATE_STOPPED);
   clients->erase(it);
   return true;
@@ skipping 25 matching lines @@
   double consumer_resource_utilization = -1.0;
   if (!metadata->GetDouble(media::VideoFrameMetadata::RESOURCE_UTILIZATION,
                            &consumer_resource_utilization)) {
     consumer_resource_utilization = -1.0;
   }
 
   callback_to_io_thread.Run(*release_sync_token, consumer_resource_utilization);
 }
 
 }  // namespace content