Modify the Mojo interfaces so that clients interact with the VideoCap…

…tureDeviceClient interface instead of VideoCaptureDevice.

This CL is part of the Mojo Video Capture work. For the bigger picture, see [1] CL1.7.1.

* Instead of exposing the interface mojom::VideoCaptureDeviceClient
  (which is the mojo equivalent of media::VideoCaptureDevice::Client)
  to clients of the Mojo service, use the implementation
  media::VideoCaptureDeviceClient inside the service and expose its
  client interface (media::VideoFrameReceiver) as mojom::VideoFrameReceiver
  to clients of the service.
* Add class video_capture::BufferTrackerFactory, and use it as the Mojo
  service's implementation of media::VideoCaptureBufferTrackerFactory
  required to operate the media::VideoCaptureDeviceClient. The buffers
  it creates are backed by MojoSharedBufferVideoFrames.
* Add support to VideoCaptureDeviceClient for buffers that are backed
  by video frames in order to avoid wrapping the
  MojoSharedBufferVideoFrame-backed buffers in another VideoFrame.

BUG=584797
TEST=content_unittest, capture_unittest, video_capture_unittest

[1] https://docs.google.com/a/chromium.org/document/d/1Qw7rw1AJy0QHXjha36jZNiEuxsxWslJ_X-zpOhijvI8/edit?usp=sharing

Review-Url: https://codereview.chromium.org/2378943002
Cr-Commit-Position: refs/heads/master@{#424550}

content/browser/media/capture/web_contents_video_capture_device_unittest.cc

@@ -442,12 +442,17 @@ class StubClient : public media::VideoCaptureDevice::Client {
       return buffer_handle_->mapped_size();
     }
     void* data(int plane) override { return buffer_handle_->data(plane); }
-    ClientBuffer AsClientBuffer(int plane) override { return nullptr; }
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
     base::FileDescriptor AsPlatformFile() override {
       return base::FileDescriptor();
     }
 #endif
+    bool IsBackedByVideoFrame() const override {
+      return buffer_handle_->IsBackedByVideoFrame();
+    }
+    scoped_refptr<media::VideoFrame> GetVideoFrame() override {
+      return buffer_handle_->GetVideoFrame();
+    }
 
    private:
     ~AutoReleaseBuffer() override { pool_->RelinquishProducerReservation(id_); }

content/browser/renderer_host/media/shared_memory_buffer_handle.cc

@@ -27,15 +27,18 @@ void* SharedMemoryBufferHandle::data(int plane) {
   return tracker_->shared_memory_.memory();
 }
 
-ClientBuffer SharedMemoryBufferHandle::AsClientBuffer(int plane) {
-  NOTREACHED();
-  return nullptr;
-}
-
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
 base::FileDescriptor SharedMemoryBufferHandle::AsPlatformFile() {
   return tracker_->shared_memory_.handle();
 }
 #endif
 
+bool SharedMemoryBufferHandle::IsBackedByVideoFrame() const {
+  return false;
+}
+
+scoped_refptr<media::VideoFrame> SharedMemoryBufferHandle::GetVideoFrame() {
+  return scoped_refptr<media::VideoFrame>();
+}
+
 }  // namespace content

content/browser/renderer_host/media/shared_memory_buffer_handle.h

@@ -24,10 +24,11 @@ class SharedMemoryBufferHandle : public media::VideoCaptureBufferHandle {
   gfx::Size dimensions() const override;
   size_t mapped_size() const override;
   void* data(int plane) override;
-  ClientBuffer AsClientBuffer(int plane) override;
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
   base::FileDescriptor AsPlatformFile() override;
 #endif
+  bool IsBackedByVideoFrame() const override;
+  scoped_refptr<media::VideoFrame> GetVideoFrame() override;
 
  private:
   SharedMemoryBufferTracker* const tracker_;

media/capture/video/fake_video_capture_device_unittest.cc

@@ -47,12 +47,13 @@ class MockBuffer : public VideoCaptureDevice::Client::Buffer {
   gfx::Size dimensions() const override { return gfx::Size(); }
   size_t mapped_size() const override { return mapped_size_; }
   void* data(int plane) override { return data_; }
-  ClientBuffer AsClientBuffer(int plane) override { return nullptr; }
 #if defined(OS_POSIX) && !(defined(OS_MACOSX) && !defined(OS_IOS))
   base::FileDescriptor AsPlatformFile() override {
     return base::FileDescriptor();
   }
 #endif
+  bool IsBackedByVideoFrame() const override { return false; };
+  scoped_refptr<VideoFrame> GetVideoFrame() override { return nullptr; }
 
  private:
   const int id_;

media/capture/video/video_capture_buffer_handle.h

@@ -6,6 +6,7 @@
 #define MEDIA_CAPTURE_VIDEO_VIDEO_CAPTURE_BUFFER_HANDLE_H_
 
 #include "base/files/file.h"
+#include "media/base/video_frame.h"
 #include "media/capture/capture_export.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/gpu_memory_buffer.h"
@@ -19,10 +20,11 @@ class CAPTURE_EXPORT VideoCaptureBufferHandle {
   virtual gfx::Size dimensions() const = 0;
   virtual size_t mapped_size() const = 0;
   virtual void* data(int plane) = 0;
-  virtual ClientBuffer AsClientBuffer(int plane) = 0;
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
   virtual base::FileDescriptor AsPlatformFile() = 0;
 #endif
+  virtual bool IsBackedByVideoFrame() const = 0;
+  virtual scoped_refptr<VideoFrame> GetVideoFrame() = 0;
 };
 
 }  // namespace media

media/capture/video/video_capture_device.h

@@ -59,10 +59,11 @@ class CAPTURE_EXPORT VideoCaptureDevice {
       virtual size_t mapped_size() const = 0;
       virtual void* data(int plane) = 0;
       void* data() { return data(0); }
-      virtual ClientBuffer AsClientBuffer(int plane) = 0;
 #if defined(OS_POSIX) && !(defined(OS_MACOSX) && !defined(OS_IOS))
       virtual base::FileDescriptor AsPlatformFile() = 0;
 #endif
+      virtual bool IsBackedByVideoFrame() const = 0;
+      virtual scoped_refptr<VideoFrame> GetVideoFrame() = 0;
     };
 
     virtual ~Client() {}
@@ -109,6 +110,8 @@ class CAPTURE_EXPORT VideoCaptureDevice {
     // additional copies in the browser process.
     // See OnIncomingCapturedData for details of |reference_time| and
     // |timestamp|.
+    // TODO(chfremer): Consider removing one of the two in order to simplify the
+    // interface.
     virtual void OnIncomingCapturedBuffer(
         std::unique_ptr<Buffer> buffer,
         const VideoCaptureFormat& frame_format,

media/capture/video/video_capture_device_client.cc

@@ -44,14 +44,17 @@ class AutoReleaseBuffer : public media::VideoCaptureDevice::Client::Buffer {
   gfx::Size dimensions() const override { return buffer_handle_->dimensions(); }
   size_t mapped_size() const override { return buffer_handle_->mapped_size(); }
   void* data(int plane) override { return buffer_handle_->data(plane); }
-  ClientBuffer AsClientBuffer(int plane) override {
-    return buffer_handle_->AsClientBuffer(plane);
-  }
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
   base::FileDescriptor AsPlatformFile() override {
     return buffer_handle_->AsPlatformFile();
   }
 #endif
+  bool IsBackedByVideoFrame() const override {
+    return buffer_handle_->IsBackedByVideoFrame();
+  }
+  scoped_refptr<VideoFrame> GetVideoFrame() override {
+    return buffer_handle_->GetVideoFrame();
+  }
 
  private:
   ~AutoReleaseBuffer() override { pool_->RelinquishProducerReservation(id_); }
@@ -279,13 +282,19 @@ void VideoCaptureDeviceClient::OnIncomingCapturedBuffer(
   DCHECK_EQ(media::PIXEL_FORMAT_I420, frame_format.pixel_format);
   DCHECK_EQ(media::PIXEL_STORAGE_CPU, frame_format.pixel_storage);
 
-  scoped_refptr<VideoFrame> frame = VideoFrame::WrapExternalSharedMemory(
-      media::PIXEL_FORMAT_I420, frame_format.frame_size,
-      gfx::Rect(frame_format.frame_size), frame_format.frame_size,
-      reinterpret_cast<uint8_t*>(buffer->data()),
-      VideoFrame::AllocationSize(media::PIXEL_FORMAT_I420,
-                                 frame_format.frame_size),
-      base::SharedMemory::NULLHandle(), 0u, timestamp);
+  scoped_refptr<VideoFrame> frame;
+  if (buffer->IsBackedByVideoFrame()) {
+    frame = buffer->GetVideoFrame();
+    frame->set_timestamp(timestamp);
+  } else {
+    frame = VideoFrame::WrapExternalSharedMemory(
+        media::PIXEL_FORMAT_I420, frame_format.frame_size,
+        gfx::Rect(frame_format.frame_size), frame_format.frame_size,
+        reinterpret_cast<uint8_t*>(buffer->data()),
+        VideoFrame::AllocationSize(media::PIXEL_FORMAT_I420,
+                                   frame_format.frame_size),
+        base::SharedMemory::NULLHandle(), 0u, timestamp);
+  }
   if (!frame)
     return;
   frame->metadata()->SetDouble(media::VideoFrameMetadata::FRAME_RATE,

services/video_capture/BUILD.gn

@@ -33,12 +33,18 @@ service_manifest("manifest") {
 
 source_set("lib") {
   sources = [
+    "buffer_tracker_factory_impl.cc",
+    "buffer_tracker_factory_impl.h",
     "device_client_media_to_mojo_adapter.cc",
     "device_client_media_to_mojo_adapter.h",
-    "device_client_mojo_to_media_adapter.cc",
-    "device_client_mojo_to_media_adapter.h",
     "device_mock_to_media_adapter.cc",
     "device_mock_to_media_adapter.h",
+    "mojo_shared_memory_buffer_handle.cc",
+    "mojo_shared_memory_buffer_handle.h",
+    "mojo_shared_memory_buffer_tracker.cc",
+    "mojo_shared_memory_buffer_tracker.h",
+    "receiver_mojo_to_media_adapter.cc",
+    "receiver_mojo_to_media_adapter.h",
     "video_capture_device_factory_impl.cc",
     "video_capture_device_factory_impl.h",
     "video_capture_device_proxy_impl.cc",
@@ -47,6 +53,7 @@ source_set("lib") {
 
   deps = [
     "//base",
+    "//media",
     "//media/capture:capture",
     "//media/mojo/common:common",
     "//media/mojo/interfaces:image_capture",
@@ -69,10 +76,10 @@ test("video_capture_unittests") {
     "mock_device_video_capture_service_test.cc",
     "mock_device_video_capture_service_test.h",
     "mock_device_video_capture_service_unittest.cc",
-    "mock_video_capture_device_client.cc",
-    "mock_video_capture_device_client.h",
     "mock_video_capture_device_impl.cc",
     "mock_video_capture_device_impl.h",
+    "mock_video_frame_receiver.cc",
+    "mock_video_frame_receiver.h",
     "video_capture_service_test.cc",
     "video_capture_service_test.h",
     "video_capture_service_unittest.cc",

services/video_capture/buffer_tracker_factory_impl.cc

@@ -0,0 +1,22 @@
+// 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 "services/video_capture/buffer_tracker_factory_impl.h"
+
+#include "base/memory/ptr_util.h"
+#include "services/video_capture/mojo_shared_memory_buffer_tracker.h"
+
+namespace video_capture {
+
+std::unique_ptr<media::VideoCaptureBufferTracker>
+BufferTrackerFactoryImpl::CreateTracker(media::VideoPixelStorage storage) {
+  switch (storage) {
+    case media::PIXEL_STORAGE_CPU:
+      return base::MakeUnique<MojoSharedMemoryBufferTracker>();
+  }
+  NOTREACHED();
+  return std::unique_ptr<media::VideoCaptureBufferTracker>();
+}
+
+}  // namespace video_capture

services/video_capture/buffer_tracker_factory_impl.h

@@ -0,0 +1,26 @@
+// 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.
+
+#ifndef SERVICES_VIDEO_CAPTURE_BUFFER_TRACKER_FACTORY_IMPL_H_
+#define SERVICES_VIDEO_CAPTURE_BUFFER_TRACKER_FACTORY_IMPL_H_
+
+#include <memory>
+
+#include "media/capture/video/video_capture_buffer_tracker_factory.h"
+
+namespace video_capture {
+
+// Implementation of media::VideoCaptureBufferTrackerFactory specific to the
+// Mojo Video Capture service. It produces buffers that are backed by
+// mojo shared memory.
+class BufferTrackerFactoryImpl
+    : public media::VideoCaptureBufferTrackerFactory {
+ public:
+  std::unique_ptr<media::VideoCaptureBufferTracker> CreateTracker(
+      media::VideoPixelStorage storage) override;
+};
+
+}  // namespace video_capture
+
+#endif  // SERVICES_VIDEO_CAPTURE_BUFFER_TRACKER_FACTORY_IMPL_H_