video_capture: add support for GpuMemoryBuffer virtual device

Added support for virtual capture device that can transport
video frames backed by GpuMemoryBuffer.

Bug: 1129531
Test: service_unittests, manual test on Cast device
Change-Id: I045046c403df714996e4c3908d889cecfab22fb6
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2417105Reviewed-by: Dominick Ng <dominickn@chromium.org>
Reviewed-by: Guido Urdaneta <guidou@chromium.org>
Reviewed-by: Ken Rockot <rockot@google.com>
Commit-Queue: Peter Qiu <zqiu@chromium.org>
Cr-Commit-Position: refs/heads/master@{#811297}

services/video_capture/BUILD.gn

@@ -12,6 +12,8 @@ source_set("lib") {
     "device_factory_media_to_mojo_adapter.h",
     "device_media_to_mojo_adapter.cc",
     "device_media_to_mojo_adapter.h",
+    "gpu_memory_buffer_virtual_device_mojo_adapter.cc",
+    "gpu_memory_buffer_virtual_device_mojo_adapter.h",
     "push_video_stream_subscription_impl.cc",
     "push_video_stream_subscription_impl.h",
     "receiver_mojo_to_media_adapter.cc",
@@ -63,6 +65,7 @@ source_set("tests") {
   sources = [
     "broadcasting_receiver_unittest.cc",
     "device_media_to_mojo_adapter_unittest.cc",
+    "gpu_memory_buffer_virtual_device_mojo_adapter_unittest.cc",
     "test/fake_device_descriptor_test.cc",
     "test/fake_device_descriptor_test.h",
     "test/fake_device_descriptor_unittest.cc",

services/video_capture/device_factory_media_to_mojo_adapter.cc

@@ -156,6 +156,13 @@ void DeviceFactoryMediaToMojoAdapter::AddTextureVirtualDevice(
   NOTIMPLEMENTED();
 }
 
+void DeviceFactoryMediaToMojoAdapter::AddGpuMemoryBufferVirtualDevice(
+    const media::VideoCaptureDeviceInfo& device_info,
+    mojo::PendingReceiver<mojom::GpuMemoryBufferVirtualDevice>
+        virtual_device_receiver) {
+  NOTIMPLEMENTED();
+}
+
 void DeviceFactoryMediaToMojoAdapter::RegisterVirtualDevicesChangedObserver(
     mojo::PendingRemote<mojom::DevicesChangedObserver> observer,
     bool raise_event_if_virtual_devices_already_present) {

services/video_capture/device_factory_media_to_mojo_adapter.h

@@ -55,6 +55,10 @@ class DeviceFactoryMediaToMojoAdapter : public DeviceFactory {
       const media::VideoCaptureDeviceInfo& device_info,
       mojo::PendingReceiver<mojom::TextureVirtualDevice>
           virtual_device_receiver) override;
+  void AddGpuMemoryBufferVirtualDevice(
+      const media::VideoCaptureDeviceInfo& device_info,
+      mojo::PendingReceiver<mojom::GpuMemoryBufferVirtualDevice>
+          virtual_device_receiver) override;
   void RegisterVirtualDevicesChangedObserver(
       mojo::PendingRemote<mojom::DevicesChangedObserver> observer,
       bool raise_event_if_virtual_devices_already_present) override;

services/video_capture/gpu_memory_buffer_virtual_device_mojo_adapter.cc

+// Copyright 2020 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/gpu_memory_buffer_virtual_device_mojo_adapter.h"
+
+#include <utility>
+
+#include "base/bind.h"
+#include "base/check_op.h"
+#include "base/memory/ptr_util.h"
+#include "media/base/bind_to_current_loop.h"
+#include "mojo/public/cpp/bindings/callback_helpers.h"
+#include "services/video_capture/public/mojom/constants.mojom.h"
+#include "services/video_capture/public/mojom/scoped_access_permission.mojom.h"
+
+namespace video_capture {
+
+GpuMemoryBufferVirtualDeviceMojoAdapter::
+    GpuMemoryBufferVirtualDeviceMojoAdapter() = default;
+
+GpuMemoryBufferVirtualDeviceMojoAdapter::
+    ~GpuMemoryBufferVirtualDeviceMojoAdapter() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+}
+
+void GpuMemoryBufferVirtualDeviceMojoAdapter::SetReceiverDisconnectedCallback(
+    base::OnceClosure callback) {
+  optional_receiver_disconnected_callback_ = std::move(callback);
+}
+
+void GpuMemoryBufferVirtualDeviceMojoAdapter::OnNewGpuMemoryBufferHandle(
+    int32_t buffer_id,
+    gfx::GpuMemoryBufferHandle gmb_handle) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+
+  // Keep track of the buffer handles in order to be able to forward them to
+  // the Receiver when it connects. This includes cases where a new Receiver
+  // connects after a previous one has disconnected.
+  known_buffer_handles_.insert(std::make_pair(buffer_id, gmb_handle.Clone()));
+
+  if (!video_frame_handler_.is_bound())
+    return;
+  media::mojom::VideoBufferHandlePtr buffer_handle =
+      media::mojom::VideoBufferHandle::New();
+  buffer_handle->set_gpu_memory_buffer_handle(std::move(gmb_handle));
+  video_frame_handler_->OnNewBuffer(buffer_id, std::move(buffer_handle));
+}
+
+void GpuMemoryBufferVirtualDeviceMojoAdapter::OnFrameReadyInBuffer(
+    int32_t buffer_id,
+    mojo::PendingRemote<mojom::ScopedAccessPermission> access_permission,
+    media::mojom::VideoFrameInfoPtr frame_info) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  if (!video_frame_handler_.is_bound())
+    return;
+  video_frame_handler_->OnFrameReadyInBuffer(
+      buffer_id, 0 /* frame_feedback_id */, std::move(access_permission),
+      std::move(frame_info));
+}
+
+void GpuMemoryBufferVirtualDeviceMojoAdapter::OnBufferRetired(int buffer_id) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  known_buffer_handles_.erase(buffer_id);
+  if (!video_frame_handler_.is_bound())
+    return;
+  video_frame_handler_->OnBufferRetired(buffer_id);
+}
+
+void GpuMemoryBufferVirtualDeviceMojoAdapter::Start(
+    const media::VideoCaptureParams& requested_settings,
+    mojo::PendingRemote<mojom::VideoFrameHandler> handler) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  video_frame_handler_.Bind(std::move(handler));
+  video_frame_handler_.set_disconnect_handler(
+      base::BindOnce(&GpuMemoryBufferVirtualDeviceMojoAdapter::
+                         OnReceiverConnectionErrorOrClose,
+                     base::Unretained(this)));
+  video_frame_handler_->OnStarted();
+
+  // Notify receiver of known buffer handles */
+  for (auto& entry : known_buffer_handles_) {
+    media::mojom::VideoBufferHandlePtr buffer_handle =
+        media::mojom::VideoBufferHandle::New();
+    buffer_handle->set_gpu_memory_buffer_handle(entry.second.Clone());
+    video_frame_handler_->OnNewBuffer(entry.first, std::move(buffer_handle));
+  }
+}
+
+void GpuMemoryBufferVirtualDeviceMojoAdapter::MaybeSuspend() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+}
+
+void GpuMemoryBufferVirtualDeviceMojoAdapter::Resume() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+}
+
+void GpuMemoryBufferVirtualDeviceMojoAdapter::GetPhotoState(
+    GetPhotoStateCallback callback) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  std::move(callback).Run(nullptr);
+}
+
+void GpuMemoryBufferVirtualDeviceMojoAdapter::SetPhotoOptions(
+    media::mojom::PhotoSettingsPtr settings,
+    SetPhotoOptionsCallback callback) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+}
+
+void GpuMemoryBufferVirtualDeviceMojoAdapter::TakePhoto(
+    TakePhotoCallback callback) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+}
+
+void GpuMemoryBufferVirtualDeviceMojoAdapter::Stop() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  if (!video_frame_handler_.is_bound())
+    return;
+  // Unsubscribe from connection error callbacks.
+  video_frame_handler_.set_disconnect_handler(base::OnceClosure());
+  // Send out OnBufferRetired events and OnStopped.
+  for (const auto& entry : known_buffer_handles_)
+    video_frame_handler_->OnBufferRetired(entry.first);
+  video_frame_handler_->OnStopped();
+  video_frame_handler_.reset();
+}
+
+void GpuMemoryBufferVirtualDeviceMojoAdapter::
+    OnReceiverConnectionErrorOrClose() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  Stop();
+  if (optional_receiver_disconnected_callback_)
+    std::move(optional_receiver_disconnected_callback_).Run();
+}
+
+}  // namespace video_capture

services/video_capture/gpu_memory_buffer_virtual_device_mojo_adapter.h

+// Copyright 2020 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_GPU_MEMORY_BUFFER_VIRTUAL_DEVICE_MOJO_ADAPTER_H_
+#define SERVICES_VIDEO_CAPTURE_GPU_MEMORY_BUFFER_VIRTUAL_DEVICE_MOJO_ADAPTER_H_
+
+#include <map>
+
+#include "base/callback.h"
+#include "base/sequence_checker.h"
+#include "media/capture/video/video_capture_buffer_pool.h"
+#include "media/capture/video_capture_types.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
+#include "mojo/public/cpp/bindings/remote.h"
+#include "services/video_capture/public/mojom/device.mojom.h"
+#include "services/video_capture/public/mojom/producer.mojom.h"
+#include "services/video_capture/public/mojom/video_frame_handler.mojom.h"
+#include "services/video_capture/public/mojom/virtual_device.mojom.h"
+
+namespace video_capture {
+
+class GpuMemoryBufferVirtualDeviceMojoAdapter
+    : public mojom::GpuMemoryBufferVirtualDevice,
+      public mojom::Device {
+ public:
+  GpuMemoryBufferVirtualDeviceMojoAdapter();
+  GpuMemoryBufferVirtualDeviceMojoAdapter(
+      GpuMemoryBufferVirtualDeviceMojoAdapter&) = delete;
+  GpuMemoryBufferVirtualDeviceMojoAdapter& operator=(
+      GpuMemoryBufferVirtualDeviceMojoAdapter&) = delete;
+  ~GpuMemoryBufferVirtualDeviceMojoAdapter() override;
+
+  void SetReceiverDisconnectedCallback(base::OnceClosure callback);
+
+  // mojom::GpuMemoryBufferVirtualDevice implementation.
+  void OnNewGpuMemoryBufferHandle(
+      int32_t buffer_id,
+      gfx::GpuMemoryBufferHandle gmb_handle) override;
+  void OnFrameReadyInBuffer(
+      int32_t buffer_id,
+      mojo::PendingRemote<mojom::ScopedAccessPermission> access_permission,
+      media::mojom::VideoFrameInfoPtr frame_info) override;
+  void OnBufferRetired(int buffer_id) override;
+
+  // mojom::Device implementation.
+  void Start(const media::VideoCaptureParams& requested_settings,
+             mojo::PendingRemote<mojom::VideoFrameHandler> handler) override;
+  void MaybeSuspend() override;
+  void Resume() override;
+  void GetPhotoState(GetPhotoStateCallback callback) override;
+  void SetPhotoOptions(media::mojom::PhotoSettingsPtr settings,
+                       SetPhotoOptionsCallback callback) override;
+  void TakePhoto(TakePhotoCallback callback) override;
+
+  void Stop();
+
+ private:
+  void OnReceiverConnectionErrorOrClose();
+
+  base::OnceClosure optional_receiver_disconnected_callback_;
+  mojo::Remote<mojom::VideoFrameHandler> video_frame_handler_;
+  std::map<int32_t, gfx::GpuMemoryBufferHandle> known_buffer_handles_;
+  SEQUENCE_CHECKER(sequence_checker_);
+
+  DISALLOW_COPY_AND_ASSIGN(GpuMemoryBufferVirtualDeviceMojoAdapter);
+};
+
+}  // namespace video_capture
+
+#endif  // SERVICES_VIDEO_CAPTURE_GPU_MEMORY_BUFFER_VIRTUAL_DEVICE_MOJO_ADAPTER_H_

services/video_capture/gpu_memory_buffer_virtual_device_mojo_adapter_unittest.cc

+// Copyright 2020 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/gpu_memory_buffer_virtual_device_mojo_adapter.h"
+
+#include "base/run_loop.h"
+#include "base/test/task_environment.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
+#include "services/video_capture/public/cpp/mock_video_frame_handler.h"
+#include "services/video_capture/public/mojom/video_frame_handler.mojom.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using testing::_;
+using testing::InvokeWithoutArgs;
+
+namespace video_capture {
+
+class GpuMemoryBufferVirtualDeviceMojoAdapterTest : public ::testing::Test {
+ public:
+  GpuMemoryBufferVirtualDeviceMojoAdapterTest() = default;
+
+  void SetUp() override {
+    mock_video_frame_handler_1_ = std::make_unique<MockVideoFrameHandler>(
+        video_frame_handler_1_.InitWithNewPipeAndPassReceiver());
+    mock_video_frame_handler_2_ = std::make_unique<MockVideoFrameHandler>(
+        video_frame_handler_2_.InitWithNewPipeAndPassReceiver());
+    adapter_ = std::make_unique<GpuMemoryBufferVirtualDeviceMojoAdapter>();
+  }
+
+ protected:
+  void ProducerSharesBufferHandle(int32_t buffer_id) {
+    gfx::GpuMemoryBufferHandle dummy_buffer_handle;
+    adapter_->OnNewGpuMemoryBufferHandle(buffer_id,
+                                         std::move(dummy_buffer_handle));
+  }
+
+  void ProducerRetiresBufferHandle(int32_t buffer_id) {
+    adapter_->OnBufferRetired(buffer_id);
+  }
+
+  void Receiver1Connects() {
+    const media::VideoCaptureParams kArbitraryRequestedSettings;
+    adapter_->Start(kArbitraryRequestedSettings,
+                    std::move(video_frame_handler_1_));
+  }
+
+  void Receiver2Connects() {
+    const media::VideoCaptureParams kArbitraryRequestedSettings;
+    adapter_->Start(kArbitraryRequestedSettings,
+                    std::move(video_frame_handler_2_));
+  }
+
+  void Receiver1Disconnects() {
+    base::RunLoop wait_loop;
+    adapter_->SetReceiverDisconnectedCallback(wait_loop.QuitClosure());
+    mock_video_frame_handler_1_.reset();
+    wait_loop.Run();
+  }
+
+  std::unique_ptr<MockVideoFrameHandler> mock_video_frame_handler_1_;
+  std::unique_ptr<MockVideoFrameHandler> mock_video_frame_handler_2_;
+
+ private:
+  base::test::TaskEnvironment task_environment_;
+  std::unique_ptr<GpuMemoryBufferVirtualDeviceMojoAdapter> adapter_;
+  mojo::PendingRemote<mojom::VideoFrameHandler> video_frame_handler_1_;
+  mojo::PendingRemote<mojom::VideoFrameHandler> video_frame_handler_2_;
+};
+
+// Tests that when buffer handles are shared by the producer before a receiver
+// has connected, these buffer handles get shared with the receiver as soon as
+// it connects.
+TEST_F(GpuMemoryBufferVirtualDeviceMojoAdapterTest,
+       BufferHandlesAreSharedWithReceiverConnectingLate) {
+  const int kArbitraryBufferId1 = 1;
+  const int kArbitraryBufferId2 = 2;
+  ProducerSharesBufferHandle(kArbitraryBufferId1);
+  ProducerSharesBufferHandle(kArbitraryBufferId2);
+
+  base::RunLoop wait_loop;
+  int buffer_received_count = 0;
+  EXPECT_CALL(*mock_video_frame_handler_1_,
+              DoOnNewBuffer(kArbitraryBufferId1, _))
+      .WillOnce(InvokeWithoutArgs([&wait_loop, &buffer_received_count]() {
+        buffer_received_count++;
+        if (buffer_received_count == 2)
+          wait_loop.Quit();
+      }));
+  EXPECT_CALL(*mock_video_frame_handler_1_,
+              DoOnNewBuffer(kArbitraryBufferId2, _))
+      .WillOnce(InvokeWithoutArgs([&wait_loop, &buffer_received_count]() {
+        buffer_received_count++;
+        if (buffer_received_count == 2)
+          wait_loop.Quit();
+      }));
+  Receiver1Connects();
+  wait_loop.Run();
+}
+
+// Tests that when a receiver disconnects and a new receiver connects, the
+// virtual device adapter shares all valid buffer handles with it.
+TEST_F(GpuMemoryBufferVirtualDeviceMojoAdapterTest,
+       BufferHandlesAreSharedWithSecondReceiver) {
+  const int kArbitraryBufferId1 = 1;
+  const int kArbitraryBufferId2 = 2;
+
+  Receiver1Connects();
+  ProducerSharesBufferHandle(kArbitraryBufferId1);
+  ProducerSharesBufferHandle(kArbitraryBufferId2);
+  Receiver1Disconnects();
+
+  ProducerRetiresBufferHandle(kArbitraryBufferId1);
+
+  base::RunLoop wait_loop;
+  EXPECT_CALL(*mock_video_frame_handler_2_,
+              DoOnNewBuffer(kArbitraryBufferId2, _))
+      .WillOnce(InvokeWithoutArgs([&wait_loop]() { wait_loop.Quit(); }));
+  Receiver2Connects();
+  wait_loop.Run();
+}
+
+}  // namespace video_capture

services/video_capture/public/mojom/device_factory.mojom

@@ -64,6 +64,12 @@ interface DeviceFactory {
       media.mojom.VideoCaptureDeviceInfo device_info,
       pending_receiver<TextureVirtualDevice> virtual_device_receiver);
 
+  // Add a virtual device with video frames backed by GpuMemoryBufferHandle.
+  // The buffers are allocated and managed by the caller.
+  AddGpuMemoryBufferVirtualDevice(
+      media.mojom.VideoCaptureDeviceInfo device_info,
+      pending_receiver<GpuMemoryBufferVirtualDevice> virtual_device_receiver);
+
   // Registered observers will get notified whenever a virtual device is added
   // or removed. Note: Changes to non-virtual devices are currently being
   // monitored outside the video capture service, and therefore the service

services/video_capture/public/mojom/virtual_device.mojom

@@ -8,6 +8,7 @@ import "media/capture/mojom/video_capture_types.mojom";
 import "services/video_capture/public/mojom/producer.mojom";
 import "services/video_capture/public/mojom/scoped_access_permission.mojom";
 import "ui/gfx/geometry/mojom/geometry.mojom";
+import "ui/gfx/mojom/buffer_types.mojom";
 
 // Interface for a producer to feed video frames into a virtual
 // device. These frames will appear to the consumer of the device
@@ -66,3 +67,24 @@ interface TextureVirtualDevice {
   // while the corresponding buffer is still in use via OnFrameReadyInBuffer().
   OnBufferRetired(int32 buffer_id);
 };
+
+// Virtual capture device with video frames backed by GpuMemoryBuffer.
+interface GpuMemoryBufferVirtualDevice {
+  // Registers a GpuMemoryBufferHandle for subsequent transport of frames.
+  OnNewGpuMemoryBufferHandle(
+      int32 buffer_id, gfx.mojom.GpuMemoryBufferHandle gmb_handle);
+
+  // The invoker must guarantee that the GpuMemoryBufferHandle with |buffer_id|
+  // stay valid until |access_permission| is released by the invocation target.
+  // In |frame_info|, |visible_rect| must be equivalent to the full |coded_size|
+  // of the frame, i.e. using |visible_rect| to crop to subregions of the frame
+  // is not supported.
+  OnFrameReadyInBuffer(int32 buffer_id,
+                       pending_remote<ScopedAccessPermission> access_permission,
+                       media.mojom.VideoFrameInfo frame_info);
+
+  // Unregisters a GpuMemoryBufferHandle previously registered via
+  // OnNewGpuMemoryBufferHandle(). Note, that this should not be called while
+  // the corresponding buffer is still in use via OnFrameReadyInBuffer().
+  OnBufferRetired(int32 buffer_id);
+};

services/video_capture/virtual_device_enabled_device_factory.cc

@@ -13,6 +13,7 @@
 #include "mojo/public/cpp/bindings/receiver.h"
 #include "mojo/public/cpp/bindings/remote.h"
 #include "services/video_capture/device_factory.h"
+#include "services/video_capture/gpu_memory_buffer_virtual_device_mojo_adapter.h"
 #include "services/video_capture/shared_memory_virtual_device_mojo_adapter.h"
 #include "services/video_capture/texture_virtual_device_mojo_adapter.h"
 
@@ -40,6 +41,16 @@ class VirtualDeviceEnabledDeviceFactory::VirtualDeviceEntry {
         texture_device_(std::move(device)),
         texture_producer_receiver_(std::move(producer_receiver)) {}
 
+  VirtualDeviceEntry(
+      const media::VideoCaptureDeviceInfo& device_info,
+      std::unique_ptr<GpuMemoryBufferVirtualDeviceMojoAdapter> device,
+      std::unique_ptr<mojo::Receiver<mojom::GpuMemoryBufferVirtualDevice>>
+          producer_receiver)
+      : device_info_(device_info),
+        device_type_(DeviceType::kGpuMemoryBuffer),
+        gmb_device_(std::move(device)),
+        gmb_producer_receiver_(std::move(producer_receiver)) {}
+
   VirtualDeviceEntry(VirtualDeviceEntry&& other) = default;
   VirtualDeviceEntry& operator=(VirtualDeviceEntry&& other) = default;
 
@@ -57,6 +68,10 @@ class VirtualDeviceEnabledDeviceFactory::VirtualDeviceEntry {
         consumer_receiver_ = std::make_unique<mojo::Receiver<mojom::Device>>(
             texture_device_.get(), std::move(device_receiver));
         break;
+      case DeviceType::kGpuMemoryBuffer:
+        consumer_receiver_ = std::make_unique<mojo::Receiver<mojom::Device>>(
+            gmb_device_.get(), std::move(device_receiver));
+        break;
     }
     consumer_receiver_->set_disconnect_handler(
         std::move(connection_error_handler));
@@ -67,14 +82,16 @@ class VirtualDeviceEnabledDeviceFactory::VirtualDeviceEntry {
   void StopDevice() {
     if (shared_memory_device_)
       shared_memory_device_->Stop();
-    else
+    else if (texture_device_)
       texture_device_->Stop();
+    else
+      gmb_device_->Stop();
   }
 
   media::VideoCaptureDeviceInfo device_info() const { return device_info_; }
 
  private:
-  enum class DeviceType { kSharedMemory, kTexture };
+  enum class DeviceType { kSharedMemory, kTexture, kGpuMemoryBuffer };
 
   media::VideoCaptureDeviceInfo device_info_;
   DeviceType device_type_;
@@ -89,6 +106,11 @@ class VirtualDeviceEnabledDeviceFactory::VirtualDeviceEntry {
   std::unique_ptr<mojo::Receiver<mojom::TextureVirtualDevice>>
       texture_producer_receiver_;
 
+  // Only valid for |device_type_ == kGpuMemoryBuffer|
+  std::unique_ptr<GpuMemoryBufferVirtualDeviceMojoAdapter> gmb_device_;
+  std::unique_ptr<mojo::Receiver<mojom::GpuMemoryBufferVirtualDevice>>
+      gmb_producer_receiver_;
+
   std::unique_ptr<mojo::Receiver<mojom::Device>> consumer_receiver_;
 };
 
@@ -196,6 +218,33 @@ void VirtualDeviceEnabledDeviceFactory::AddTextureVirtualDevice(
   EmitDevicesChangedEvent();
 }
 
+void VirtualDeviceEnabledDeviceFactory::AddGpuMemoryBufferVirtualDevice(
+    const media::VideoCaptureDeviceInfo& device_info,
+    mojo::PendingReceiver<mojom::GpuMemoryBufferVirtualDevice>
+        virtual_device_receiver) {
+  auto device_id = device_info.descriptor.device_id;
+  auto virtual_device_iter = virtual_devices_by_id_.find(device_id);
+  if (virtual_device_iter != virtual_devices_by_id_.end()) {
+    // Revoke the access for the current producer and consumer by
+    // removing it from the list.
+    virtual_devices_by_id_.erase(virtual_device_iter);
+  }
+
+  auto device = std::make_unique<GpuMemoryBufferVirtualDeviceMojoAdapter>();
+  auto producer_receiver =
+      std::make_unique<mojo::Receiver<mojom::GpuMemoryBufferVirtualDevice>>(
+          device.get(), std::move(virtual_device_receiver));
+  producer_receiver->set_disconnect_handler(
+      base::BindOnce(&VirtualDeviceEnabledDeviceFactory::
+                         OnVirtualDeviceProducerConnectionErrorOrClose,
+                     base::Unretained(this), device_id));
+  VirtualDeviceEntry device_entry(device_info, std::move(device),
+                                  std::move(producer_receiver));
+  virtual_devices_by_id_.insert(
+      std::make_pair(device_id, std::move(device_entry)));
+  EmitDevicesChangedEvent();
+}
+
 void VirtualDeviceEnabledDeviceFactory::RegisterVirtualDevicesChangedObserver(
     mojo::PendingRemote<mojom::DevicesChangedObserver> observer_pending_remote,
     bool raise_event_if_virtual_devices_already_present) {

services/video_capture/virtual_device_enabled_device_factory.h

@@ -40,6 +40,10 @@ class VirtualDeviceEnabledDeviceFactory : public DeviceFactory {
       const media::VideoCaptureDeviceInfo& device_info,
       mojo::PendingReceiver<mojom::TextureVirtualDevice>
           virtual_device_receiver) override;
+  void AddGpuMemoryBufferVirtualDevice(
+      const media::VideoCaptureDeviceInfo& device_info,
+      mojo::PendingReceiver<mojom::GpuMemoryBufferVirtualDevice>
+          virtual_device_receiver) override;
   void RegisterVirtualDevicesChangedObserver(
       mojo::PendingRemote<mojom::DevicesChangedObserver> observer,
       bool raise_event_if_virtual_devices_already_present) override;