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

content/browser/renderer_host/media/video_capture_controller.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.
 
 #include "content/browser/renderer_host/media/video_capture_controller.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
@@ skipping 111 matching lines @@
 
  private:
   base::WeakPtr<VideoFrameReceiver> receiver_;
 };
 
 }  // anonymous namespace
 
 struct VideoCaptureController::ControllerClient {
   ControllerClient(VideoCaptureControllerID id,
                    VideoCaptureControllerEventHandler* handler,
-                   base::ProcessHandle render_process,
                    media::VideoCaptureSessionId session_id,
                    const media::VideoCaptureParams& params)
       : controller_id(id),
         event_handler(handler),
-        render_process_handle(render_process),
         session_id(session_id),
         parameters(params),
         session_closed(false),
         paused(false) {}
 
   ~ControllerClient() {}
 
   // ID used for identifying this object.
   const VideoCaptureControllerID controller_id;
   VideoCaptureControllerEventHandler* const event_handler;
 
-  // Handle to the render process that will receive the capture buffers.
-  const base::ProcessHandle render_process_handle;
   const media::VideoCaptureSessionId session_id;
   const media::VideoCaptureParams parameters;
 
   // Buffers that are currently known to this client.
   std::set<int> known_buffers;
 
   // Buffers currently held by this client, and sync token callback to call when
   // they are returned from the client.
   typedef std::map<int, scoped_refptr<VideoFrame>> ActiveBufferMap;
   ActiveBufferMap active_buffers;
@@ skipping 38 matching lines @@
           this->GetWeakPtrForIOThread()),
       buffer_pool_,
       base::Bind(&CreateGpuJpegDecoder,
                  base::Bind(&VideoFrameReceiver::OnIncomingCapturedVideoFrame,
                             this->GetWeakPtrForIOThread())));
 }
 
 void VideoCaptureController::AddClient(
     VideoCaptureControllerID id,
     VideoCaptureControllerEventHandler* event_handler,
-    base::ProcessHandle render_process,
     media::VideoCaptureSessionId session_id,
     const media::VideoCaptureParams& params) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DVLOG(1) << "VideoCaptureController::AddClient() -- id=" << id
            << ", session_id=" << session_id
            << ", params.requested_format="
            << media::VideoCaptureFormat::ToString(params.requested_format);
 
   // Check that requested VideoCaptureParams are valid and supported.  If not,
   // report an error immediately and punt.
@@ skipping 15 matching lines @@
   // Signal error in case device is already in error state.
   if (state_ == VIDEO_CAPTURE_STATE_ERROR) {
     event_handler->OnError(id);
     return;
   }
 
   // Do nothing if this client has called AddClient before.
   if (FindClient(id, event_handler, controller_clients_))
     return;
 
-  std::unique_ptr<ControllerClient> client = base::MakeUnique<ControllerClient>(
-      id, event_handler, render_process, session_id, params);
+  std::unique_ptr<ControllerClient> client =
+      base::MakeUnique<ControllerClient>(id, event_handler, session_id, params);
   // If we already have gotten frame_info from the device, repeat it to the new
   // client.
   if (state_ == VIDEO_CAPTURE_STATE_STARTED) {
     controller_clients_.push_back(std::move(client));
     return;
   }
 }
 
 int VideoCaptureController::RemoveClient(
     VideoCaptureControllerID id,
@@ skipping 96 matching lines @@
     double consumer_resource_utilization) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   ControllerClient* client = FindClient(id, event_handler, controller_clients_);
 
   // If this buffer is not held by this client, or this client doesn't exist
   // in controller, do nothing.
   ControllerClient::ActiveBufferMap::iterator iter;
   if (!client || (iter = client->active_buffers.find(buffer_id)) ==
                      client->active_buffers.end()) {
     NOTREACHED();

[dcheng, 2016/10/20 08:37:56]

Incidentally, I'm wondering if things like this should be
mojo::ReportBadMessage?

[mcasas, 2016/10/20 15:09:51]

Oh, that's a good one. I'll add it in the next patch
in VideoCaptureHost, who is the one actually
receiving the messages.

     return;
   }
 
   // Set the RESOURCE_UTILIZATION to the maximum of those provided by each
   // consumer (via separate calls to this method that refer to the same
   // VideoFrame).  The producer of this VideoFrame may check this value, after
   // all consumer holds are relinquished, to make quality versus performance
   // trade-off decisions.
   scoped_refptr<VideoFrame> frame = iter->second;
   if (std::isfinite(consumer_resource_utilization) &&
@@ skipping 127 matching lines @@
                                                buffer_id_to_drop);
     }
   }
 }
 
 void VideoCaptureController::DoNewBufferOnIOThread(
     ControllerClient* client,
     media::VideoCaptureDevice::Client::Buffer* buffer,
     const scoped_refptr<media::VideoFrame>& frame) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  const int buffer_id = buffer->id();
-
   DCHECK_EQ(media::VideoFrame::STORAGE_SHMEM, frame->storage_type());
 
-  base::SharedMemoryHandle remote_handle;
-  buffer_pool_->ShareToProcess(buffer_id, client->render_process_handle,
-                               &remote_handle);
-  client->event_handler->OnBufferCreated(client->controller_id, remote_handle,
+  const int buffer_id = buffer->id();
+  mojo::ScopedSharedBufferHandle handle =
+      buffer_pool_->GetHandleForTransit(buffer_id);
+  client->event_handler->OnBufferCreated(client->controller_id,
+                                         std::move(handle),
                                          buffer->mapped_size(), buffer_id);
 }
 
 VideoCaptureController::ControllerClient* VideoCaptureController::FindClient(
     VideoCaptureControllerID id,
     VideoCaptureControllerEventHandler* handler,
     const ControllerClients& clients) {
   for (const auto& client : clients) {
     if (client->controller_id == id && client->event_handler == handler)
       return client.get();
   }
   return nullptr;
 }
 
 VideoCaptureController::ControllerClient* VideoCaptureController::FindClient(
     int session_id,
     const ControllerClients& clients) {
   for (const auto& client : clients) {
     if (client->session_id == session_id)
       return client.get();
   }
   return nullptr;
 }
 
 }  // namespace content