Migrate GpuService to the new Mojo types

This CL converts old Mojo types to the new Mojo types
in GpuService interface.

 - Apply pending_receiver to FooRequest arguments.

Additionally, CreateVideoEncodeAcceleratorProvider of
Gpu interface needs to be converted to the new Mojo
type together.

Bug: 955171
Change-Id: I2636edd971d6d7962614204bf81ee0c25fce8edf
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1792039Reviewed-by: Shik Chen <shik@chromium.org>
Reviewed-by: Oksana Zhuravlova <oksamyt@chromium.org>
Reviewed-by: Xiaohan Wang <xhwang@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Reviewed-by: Victor Miura <vmiura@chromium.org>
Reviewed-by: danakj <danakj@chromium.org>
Commit-Queue: Gyuyoung Kim <gyuyoung@igalia.com>
Cr-Commit-Position: refs/heads/master@{#695950}

components/chromeos_camera/mojo_jpeg_encode_accelerator_service.cc

@@ -23,7 +23,7 @@
 #include "components/chromeos_camera/dmabuf_utils.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/video_frame.h"
-#include "mojo/public/cpp/bindings/strong_binding.h"
+#include "mojo/public/cpp/bindings/self_owned_receiver.h"
 #include "mojo/public/cpp/system/platform_handle.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/linux/native_pixmap_dmabuf.h"
@@ -56,9 +56,11 @@ media::VideoPixelFormat ToVideoPixelFormat(uint32_t fourcc_fmt) {
 
 // static
 void MojoJpegEncodeAcceleratorService::Create(
-    chromeos_camera::mojom::JpegEncodeAcceleratorRequest request) {
+    mojo::PendingReceiver<chromeos_camera::mojom::JpegEncodeAccelerator>
+        receiver) {
   auto* jpeg_encoder = new MojoJpegEncodeAcceleratorService();
-  mojo::MakeStrongBinding(base::WrapUnique(jpeg_encoder), std::move(request));
+  mojo::MakeSelfOwnedReceiver(base::WrapUnique(jpeg_encoder),
+                              std::move(receiver));
 }
 
 MojoJpegEncodeAcceleratorService::MojoJpegEncodeAcceleratorService()

components/chromeos_camera/mojo_jpeg_encode_accelerator_service.h

@@ -15,6 +15,7 @@
 #include "components/chromeos_camera/common/jpeg_encode_accelerator.mojom.h"
 #include "components/chromeos_camera/gpu_jpeg_encode_accelerator_factory.h"
 #include "components/chromeos_camera/jpeg_encode_accelerator.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
 
 namespace chromeos_camera {
 
@@ -25,7 +26,8 @@ class MojoJpegEncodeAcceleratorService
       public JpegEncodeAccelerator::Client {
  public:
   static void Create(
-      chromeos_camera::mojom::JpegEncodeAcceleratorRequest request);
+      mojo::PendingReceiver<chromeos_camera::mojom::JpegEncodeAccelerator>
+          receiver);
 
   ~MojoJpegEncodeAcceleratorService() override;
 

components/viz/host/gpu_client.cc

@@ -175,10 +175,11 @@ void GpuClient::CreateJpegDecodeAccelerator(
 #endif  // defined(OS_CHROMEOS)
 
 void GpuClient::CreateVideoEncodeAcceleratorProvider(
-    media::mojom::VideoEncodeAcceleratorProviderRequest vea_provider_request) {
+    mojo::PendingReceiver<media::mojom::VideoEncodeAcceleratorProvider>
+        vea_provider_receiver) {
   if (auto* gpu_host = delegate_->EnsureGpuHost()) {
     gpu_host->gpu_service()->CreateVideoEncodeAcceleratorProvider(
-        std::move(vea_provider_request));
+        std::move(vea_provider_receiver));
   }
 }
 

components/viz/host/gpu_client.h

@@ -62,8 +62,8 @@ class VIZ_HOST_EXPORT GpuClient : public mojom::GpuMemoryBufferFactory,
       override;
 #endif  // defined(OS_CHROMEOS)
   void CreateVideoEncodeAcceleratorProvider(
-      media::mojom::VideoEncodeAcceleratorProviderRequest vea_provider_request)
-      override;
+      mojo::PendingReceiver<media::mojom::VideoEncodeAcceleratorProvider>
+          vea_provider_receiver) override;
 
  private:
   enum class ErrorReason {

components/viz/host/host_gpu_memory_buffer_manager_unittest.cc

@@ -89,28 +89,33 @@ class TestGpuService : public mojom::GpuService {
   void CloseChannel(int32_t client_id) override {}
 #if defined(OS_CHROMEOS)
   void CreateArcVideoDecodeAccelerator(
-      arc::mojom::VideoDecodeAcceleratorRequest vda_request) override {}
+      mojo::PendingReceiver<arc::mojom::VideoDecodeAccelerator> vda_receiver)
+      override {}
 
   void CreateArcVideoEncodeAccelerator(
-      arc::mojom::VideoEncodeAcceleratorRequest vea_request) override {}
+      mojo::PendingReceiver<arc::mojom::VideoEncodeAccelerator> vea_receiver)
+      override {}
 
   void CreateArcVideoProtectedBufferAllocator(
-      arc::mojom::VideoProtectedBufferAllocatorRequest pba_request) override {}
+      mojo::PendingReceiver<arc::mojom::VideoProtectedBufferAllocator>
+          pba_receiver) override {}
 
   void CreateArcProtectedBufferManager(
-      arc::mojom::ProtectedBufferManagerRequest pbm_request) override {}
+      mojo::PendingReceiver<arc::mojom::ProtectedBufferManager> pbm_receiver)
+      override {}
 
   void CreateJpegDecodeAccelerator(
-      chromeos_camera::mojom::MjpegDecodeAcceleratorRequest jda_request)
-      override {}
+      mojo::PendingReceiver<chromeos_camera::mojom::MjpegDecodeAccelerator>
+          jda_receiver) override {}
 
   void CreateJpegEncodeAccelerator(
-      chromeos_camera::mojom::JpegEncodeAcceleratorRequest jea_request)
-      override {}
+      mojo::PendingReceiver<chromeos_camera::mojom::JpegEncodeAccelerator>
+          jea_receiver) override {}
 #endif  // defined(OS_CHROMEOS)
 
   void CreateVideoEncodeAcceleratorProvider(
-      media::mojom::VideoEncodeAcceleratorProviderRequest request) override {}
+      mojo::PendingReceiver<media::mojom::VideoEncodeAcceleratorProvider>
+          receiver) override {}
 
   void CreateGpuMemoryBuffer(gfx::GpuMemoryBufferId id,
                              const gfx::Size& size,

components/viz/service/gl/gpu_service_impl.cc

@@ -49,7 +49,7 @@
 #include "media/gpu/ipc/service/gpu_video_decode_accelerator.h"
 #include "media/gpu/ipc/service/media_gpu_channel_manager.h"
 #include "media/mojo/services/mojo_video_encode_accelerator_provider.h"
-#include "mojo/public/cpp/bindings/strong_binding.h"
+#include "mojo/public/cpp/bindings/self_owned_receiver.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 #include "third_party/skia/include/gpu/gl/GrGLAssembleInterface.h"
 #include "third_party/skia/include/gpu/gl/GrGLInterface.h"
@@ -372,102 +372,109 @@ void GpuServiceImpl::RecordLogMessage(int severity,
 
 #if defined(OS_CHROMEOS)
 void GpuServiceImpl::CreateArcVideoDecodeAccelerator(
-    arc::mojom::VideoDecodeAcceleratorRequest vda_request) {
+    mojo::PendingReceiver<arc::mojom::VideoDecodeAccelerator> vda_receiver) {
   DCHECK(io_runner_->BelongsToCurrentThread());
   main_runner_->PostTask(
       FROM_HERE,
       base::BindOnce(
           &GpuServiceImpl::CreateArcVideoDecodeAcceleratorOnMainThread,
-          weak_ptr_, std::move(vda_request)));
+          weak_ptr_, std::move(vda_receiver)));
 }
 
 void GpuServiceImpl::CreateArcVideoEncodeAccelerator(
-    arc::mojom::VideoEncodeAcceleratorRequest vea_request) {
+    mojo::PendingReceiver<arc::mojom::VideoEncodeAccelerator> vea_receiver) {
   DCHECK(io_runner_->BelongsToCurrentThread());
   main_runner_->PostTask(
       FROM_HERE,
       base::BindOnce(
           &GpuServiceImpl::CreateArcVideoEncodeAcceleratorOnMainThread,
-          weak_ptr_, std::move(vea_request)));
+          weak_ptr_, std::move(vea_receiver)));
 }
 
 void GpuServiceImpl::CreateArcVideoProtectedBufferAllocator(
-    arc::mojom::VideoProtectedBufferAllocatorRequest pba_request) {
+    mojo::PendingReceiver<arc::mojom::VideoProtectedBufferAllocator>
+        pba_receiver) {
   DCHECK(io_runner_->BelongsToCurrentThread());
   main_runner_->PostTask(
       FROM_HERE,
       base::BindOnce(
           &GpuServiceImpl::CreateArcVideoProtectedBufferAllocatorOnMainThread,
-          weak_ptr_, std::move(pba_request)));
+          weak_ptr_, std::move(pba_receiver)));
 }
 
 void GpuServiceImpl::CreateArcProtectedBufferManager(
-    arc::mojom::ProtectedBufferManagerRequest pbm_request) {
+    mojo::PendingReceiver<arc::mojom::ProtectedBufferManager> pbm_receiver) {
   DCHECK(io_runner_->BelongsToCurrentThread());
   main_runner_->PostTask(
       FROM_HERE,
       base::BindOnce(
           &GpuServiceImpl::CreateArcProtectedBufferManagerOnMainThread,
-          weak_ptr_, std::move(pbm_request)));
+          weak_ptr_, std::move(pbm_receiver)));
 }
 
 void GpuServiceImpl::CreateArcVideoDecodeAcceleratorOnMainThread(
-    arc::mojom::VideoDecodeAcceleratorRequest vda_request) {
+    mojo::PendingReceiver<arc::mojom::VideoDecodeAccelerator> vda_receiver) {
   DCHECK(main_runner_->BelongsToCurrentThread());
-  mojo::MakeStrongBinding(std::make_unique<arc::GpuArcVideoDecodeAccelerator>(
-                              gpu_preferences_, protected_buffer_manager_),
-                          std::move(vda_request));
+  mojo::MakeSelfOwnedReceiver(
+      std::make_unique<arc::GpuArcVideoDecodeAccelerator>(
+          gpu_preferences_, protected_buffer_manager_),
+      std::move(vda_receiver));
 }
 
 void GpuServiceImpl::CreateArcVideoEncodeAcceleratorOnMainThread(
-    arc::mojom::VideoEncodeAcceleratorRequest vea_request) {
+    mojo::PendingReceiver<arc::mojom::VideoEncodeAccelerator> vea_receiver) {
   DCHECK(main_runner_->BelongsToCurrentThread());
-  mojo::MakeStrongBinding(
+  mojo::MakeSelfOwnedReceiver(
       std::make_unique<arc::GpuArcVideoEncodeAccelerator>(gpu_preferences_),
-      std::move(vea_request));
+      std::move(vea_receiver));
 }
 
 void GpuServiceImpl::CreateArcVideoProtectedBufferAllocatorOnMainThread(
-    arc::mojom::VideoProtectedBufferAllocatorRequest pba_request) {
+    mojo::PendingReceiver<arc::mojom::VideoProtectedBufferAllocator>
+        pba_receiver) {
   DCHECK(main_runner_->BelongsToCurrentThread());
   auto gpu_arc_video_protected_buffer_allocator =
       arc::GpuArcVideoProtectedBufferAllocator::Create(
           protected_buffer_manager_);
   if (!gpu_arc_video_protected_buffer_allocator)
     return;
-  mojo::MakeStrongBinding(std::move(gpu_arc_video_protected_buffer_allocator),
-                          std::move(pba_request));
+  mojo::MakeSelfOwnedReceiver(
+      std::move(gpu_arc_video_protected_buffer_allocator),
+      std::move(pba_receiver));
 }
 
 void GpuServiceImpl::CreateArcProtectedBufferManagerOnMainThread(
-    arc::mojom::ProtectedBufferManagerRequest pbm_request) {
+    mojo::PendingReceiver<arc::mojom::ProtectedBufferManager> pbm_receiver) {
   DCHECK(main_runner_->BelongsToCurrentThread());
-  mojo::MakeStrongBinding(
+  mojo::MakeSelfOwnedReceiver(
       std::make_unique<arc::GpuArcProtectedBufferManagerProxy>(
           protected_buffer_manager_),
-      std::move(pbm_request));
+      std::move(pbm_receiver));
 }
 
 void GpuServiceImpl::CreateJpegDecodeAccelerator(
-    chromeos_camera::mojom::MjpegDecodeAcceleratorRequest jda_request) {
+    mojo::PendingReceiver<chromeos_camera::mojom::MjpegDecodeAccelerator>
+        jda_receiver) {
   DCHECK(io_runner_->BelongsToCurrentThread());
   chromeos_camera::MojoMjpegDecodeAcceleratorService::Create(
-      std::move(jda_request));
+      std::move(jda_receiver));
 }
 
 void GpuServiceImpl::CreateJpegEncodeAccelerator(
-    chromeos_camera::mojom::JpegEncodeAcceleratorRequest jea_request) {
+    mojo::PendingReceiver<chromeos_camera::mojom::JpegEncodeAccelerator>
+        jea_receiver) {
   DCHECK(io_runner_->BelongsToCurrentThread());
   chromeos_camera::MojoJpegEncodeAcceleratorService::Create(
-      std::move(jea_request));
+      std::move(jea_receiver));
 }
 #endif  // defined(OS_CHROMEOS)
 
 void GpuServiceImpl::CreateVideoEncodeAcceleratorProvider(
-    media::mojom::VideoEncodeAcceleratorProviderRequest vea_provider_request) {
+    mojo::PendingReceiver<media::mojom::VideoEncodeAcceleratorProvider>
+        vea_provider_receiver) {
   DCHECK(io_runner_->BelongsToCurrentThread());
   media::MojoVideoEncodeAcceleratorProvider::Create(
-      std::move(vea_provider_request),
+      std::move(vea_provider_receiver),
       base::BindRepeating(&media::GpuVideoEncodeAcceleratorFactory::CreateVEA),
       gpu_preferences_);
 }

components/viz/service/gl/gpu_service_impl.h

@@ -117,24 +117,28 @@ class VIZ_SERVICE_EXPORT GpuServiceImpl : public gpu::GpuChannelManagerDelegate,
   void CloseChannel(int32_t client_id) override;
 #if defined(OS_CHROMEOS)
   void CreateArcVideoDecodeAccelerator(
-      arc::mojom::VideoDecodeAcceleratorRequest vda_request) override;
+      mojo::PendingReceiver<arc::mojom::VideoDecodeAccelerator> vda_receiver)
+      override;
   void CreateArcVideoEncodeAccelerator(
-      arc::mojom::VideoEncodeAcceleratorRequest vea_request) override;
+      mojo::PendingReceiver<arc::mojom::VideoEncodeAccelerator> vea_receiver)
+      override;
   void CreateArcVideoProtectedBufferAllocator(
-      arc::mojom::VideoProtectedBufferAllocatorRequest pba_request) override;
+      mojo::PendingReceiver<arc::mojom::VideoProtectedBufferAllocator>
+          pba_receiver) override;
   void CreateArcProtectedBufferManager(
-      arc::mojom::ProtectedBufferManagerRequest pbm_request) override;
-  void CreateJpegDecodeAccelerator(
-      chromeos_camera::mojom::MjpegDecodeAcceleratorRequest jda_request)
+      mojo::PendingReceiver<arc::mojom::ProtectedBufferManager> pbm_receiver)
       override;
+  void CreateJpegDecodeAccelerator(
+      mojo::PendingReceiver<chromeos_camera::mojom::MjpegDecodeAccelerator>
+          jda_receiver) override;
   void CreateJpegEncodeAccelerator(
-      chromeos_camera::mojom::JpegEncodeAcceleratorRequest jea_request)
-      override;
+      mojo::PendingReceiver<chromeos_camera::mojom::JpegEncodeAccelerator>
+          jea_receiver) override;
 #endif  // defined(OS_CHROMEOS)
 
   void CreateVideoEncodeAcceleratorProvider(
-      media::mojom::VideoEncodeAcceleratorProviderRequest vea_provider_request)
-      override;
+      mojo::PendingReceiver<media::mojom::VideoEncodeAcceleratorProvider>
+          vea_provider_receiver) override;
   void CreateGpuMemoryBuffer(gfx::GpuMemoryBufferId id,
                              const gfx::Size& size,
                              gfx::BufferFormat format,
@@ -266,13 +270,14 @@ class VIZ_SERVICE_EXPORT GpuServiceImpl : public gpu::GpuChannelManagerDelegate,
 
 #if defined(OS_CHROMEOS)
   void CreateArcVideoDecodeAcceleratorOnMainThread(
-      arc::mojom::VideoDecodeAcceleratorRequest vda_request);
+      mojo::PendingReceiver<arc::mojom::VideoDecodeAccelerator> vda_receiver);
   void CreateArcVideoEncodeAcceleratorOnMainThread(
-      arc::mojom::VideoEncodeAcceleratorRequest vea_request);
+      mojo::PendingReceiver<arc::mojom::VideoEncodeAccelerator> vea_receiver);
   void CreateArcVideoProtectedBufferAllocatorOnMainThread(
-      arc::mojom::VideoProtectedBufferAllocatorRequest pba_request);
+      mojo::PendingReceiver<arc::mojom::VideoProtectedBufferAllocator>
+          pba_receiver);
   void CreateArcProtectedBufferManagerOnMainThread(
-      arc::mojom::ProtectedBufferManagerRequest pbm_request);
+      mojo::PendingReceiver<arc::mojom::ProtectedBufferManager> pbm_receiver);
 #endif  // defined(OS_CHROMEOS)
 
   void RequestHDRStatusOnMainThread(RequestHDRStatusCallback callback);

media/mojo/services/mojo_video_encode_accelerator_provider.cc

@@ -10,20 +10,21 @@
 #include "base/logging.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/limits.h"
-#include "mojo/public/cpp/bindings/strong_binding.h"
+#include "mojo/public/cpp/bindings/self_owned_receiver.h"
 #include "mojo/public/cpp/system/platform_handle.h"
 
 namespace media {
 
 // static
 void MojoVideoEncodeAcceleratorProvider::Create(
-    mojom::VideoEncodeAcceleratorProviderRequest request,
+    mojo::PendingReceiver<mojom::VideoEncodeAcceleratorProvider> receiver,
     const CreateAndInitializeVideoEncodeAcceleratorCallback&
         create_vea_callback,
     const gpu::GpuPreferences& gpu_preferences) {
-  mojo::MakeStrongBinding(std::make_unique<MojoVideoEncodeAcceleratorProvider>(
-                              create_vea_callback, gpu_preferences),
-                          std::move(request));
+  mojo::MakeSelfOwnedReceiver(
+      std::make_unique<MojoVideoEncodeAcceleratorProvider>(create_vea_callback,
+                                                           gpu_preferences),
+      std::move(receiver));
 }
 
 MojoVideoEncodeAcceleratorProvider::MojoVideoEncodeAcceleratorProvider(

media/mojo/services/mojo_video_encode_accelerator_provider.h

@@ -26,10 +26,11 @@ class MEDIA_MOJO_EXPORT MojoVideoEncodeAcceleratorProvider
       MojoVideoEncodeAcceleratorService::
           CreateAndInitializeVideoEncodeAcceleratorCallback;
 
-  static void Create(mojom::VideoEncodeAcceleratorProviderRequest request,
-                     const CreateAndInitializeVideoEncodeAcceleratorCallback&
-                         create_vea_callback,
-                     const gpu::GpuPreferences& gpu_preferences);
+  static void Create(
+      mojo::PendingReceiver<mojom::VideoEncodeAcceleratorProvider> receiver,
+      const CreateAndInitializeVideoEncodeAcceleratorCallback&
+          create_vea_callback,
+      const gpu::GpuPreferences& gpu_preferences);
 
   MojoVideoEncodeAcceleratorProvider(
       const CreateAndInitializeVideoEncodeAcceleratorCallback&

services/viz/privileged/mojom/gl/gpu_service.mojom

@@ -40,33 +40,38 @@ interface GpuService {
 
   // Create a new ARC VideoDecodeAccelerator and binds it to |vda|.
   [EnableIf=is_chromeos]
-  CreateArcVideoDecodeAccelerator(arc.mojom.VideoDecodeAccelerator& vda);
+  CreateArcVideoDecodeAccelerator(
+      pending_receiver<arc.mojom.VideoDecodeAccelerator> vda);
 
   // Create a new ARC VideoEncodeAccelerator and binds it to |vea|.
   [EnableIf=is_chromeos]
-  CreateArcVideoEncodeAccelerator(arc.mojom.VideoEncodeAccelerator& vea);
+  CreateArcVideoEncodeAccelerator(
+      pending_receiver<arc.mojom.VideoEncodeAccelerator> vea);
 
   // Create a new ARC VideoProtectedBufferAllocator and binds it to |pba|.
   [EnableIf=is_chromeos]
   CreateArcVideoProtectedBufferAllocator(
-      arc.mojom.VideoProtectedBufferAllocator& pba);
+      pending_receiver<arc.mojom.VideoProtectedBufferAllocator> pba);
 
   // Create a new ARC ProtectedBufferManager and binds it to |pbm|.
   [EnableIf=is_chromeos]
-  CreateArcProtectedBufferManager(arc.mojom.ProtectedBufferManager& pbm);
+  CreateArcProtectedBufferManager(
+      pending_receiver<arc.mojom.ProtectedBufferManager> pbm);
 
   // Creates a new MjpegDecodeAccelerator and binds it to |jda|.
   [EnableIf=is_chromeos]
   CreateJpegDecodeAccelerator(
-      chromeos_camera.mojom.MjpegDecodeAccelerator& jda);
+      pending_receiver<chromeos_camera.mojom.MjpegDecodeAccelerator> jda);
 
   // Creates a new JpegEncodeAccelerator and binds it to |jea|.
   [EnableIf=is_chromeos]
-  CreateJpegEncodeAccelerator(chromeos_camera.mojom.JpegEncodeAccelerator& jea);
+  CreateJpegEncodeAccelerator(
+      pending_receiver<chromeos_camera.mojom.JpegEncodeAccelerator> jea);
 
   // Creates a VideoEncodeAcceleratorProvider and binds it to |vea_provider|.
   CreateVideoEncodeAcceleratorProvider(
-      media.mojom.VideoEncodeAcceleratorProvider& vea_provider);
+      pending_receiver<media.mojom.VideoEncodeAcceleratorProvider>
+          vea_provider);
 
   CreateGpuMemoryBuffer(gfx.mojom.GpuMemoryBufferId id,
                         gfx.mojom.Size size,

services/viz/public/cpp/gpu/gpu.cc

@@ -64,9 +64,10 @@ class Gpu::GpuPtrIO {
 #endif  // defined(OS_CHROMEOS)
 
   void CreateVideoEncodeAcceleratorProvider(
-      media::mojom::VideoEncodeAcceleratorProviderRequest request) {
+      mojo::PendingReceiver<media::mojom::VideoEncodeAcceleratorProvider>
+          receiver) {
     DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
-    gpu_ptr_->CreateVideoEncodeAcceleratorProvider(std::move(request));
+    gpu_ptr_->CreateVideoEncodeAcceleratorProvider(std::move(receiver));
   }
 
  private:
@@ -296,12 +297,13 @@ void Gpu::CreateJpegDecodeAccelerator(
 #endif  // defined(OS_CHROMEOS)
 
 void Gpu::CreateVideoEncodeAcceleratorProvider(
-    media::mojom::VideoEncodeAcceleratorProviderRequest vea_provider_request) {
+    mojo::PendingReceiver<media::mojom::VideoEncodeAcceleratorProvider>
+        vea_provider_receiver) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   io_task_runner_->PostTask(
       FROM_HERE, base::BindOnce(&GpuPtrIO::CreateVideoEncodeAcceleratorProvider,
                                 base::Unretained(gpu_.get()),
-                                std::move(vea_provider_request)));
+                                std::move(vea_provider_receiver)));
 }
 
 void Gpu::EstablishGpuChannel(gpu::GpuChannelEstablishedCallback callback) {

services/viz/public/cpp/gpu/gpu.h

@@ -46,7 +46,8 @@ class Gpu : public gpu::GpuChannelEstablishFactory {
       chromeos_camera::mojom::MjpegDecodeAcceleratorRequest jda_request);
 #endif  // defined(OS_CHROMEOS)
   void CreateVideoEncodeAcceleratorProvider(
-      media::mojom::VideoEncodeAcceleratorProviderRequest vea_provider_request);
+      mojo::PendingReceiver<media::mojom::VideoEncodeAcceleratorProvider>
+          vea_provider_receiver);
 
   // gpu::GpuChannelEstablishFactory:
   void EstablishGpuChannel(

services/viz/public/cpp/gpu/gpu_unittest.cc

@@ -65,7 +65,8 @@ class TestGpuImpl : public mojom::Gpu {
 #endif  // defined(OS_CHROMEOS)
 
   void CreateVideoEncodeAcceleratorProvider(
-      media::mojom::VideoEncodeAcceleratorProviderRequest request) override {}
+      mojo::PendingReceiver<media::mojom::VideoEncodeAcceleratorProvider>
+          receiver) override {}
 
  private:
   bool request_will_succeed_ = true;

services/viz/public/mojom/gpu.mojom

@@ -48,5 +48,6 @@ interface Gpu {
 
   // Creates a VideoEncodeAcceleratorProvider and binds it to |vea_provider|.
   CreateVideoEncodeAcceleratorProvider(
-      media.mojom.VideoEncodeAcceleratorProvider& vea_provider);
+      pending_receiver<media.mojom.VideoEncodeAcceleratorProvider>
+          vea_provider);
 };