VEA mojification: allow for Mojo VEAs to be instantiated several times

On ToT, RenderThreadImpl creates one "remote" mojom::VideoEncodeAcceleratorPtr
on main render thread and gives it to GpuVideoAcceleratorFactoriesImpl [1];
this factory gives it to the first constructed MojoVideoEncodeAccelerator;
this is good for the first time, but after that it'd be gone, the construction
of subsequent MojoVideoEncodeAccelerators will fail and we'll be falling back 
to software and/or the old IPC mechanism.

This CL changes that by adding a mojom VideoEncodeAcceleratorProvider interface,
which is bound along the chain:

 RenderThreadImpl --> gpu.mojom --> GpuClient --> gpu_service.mojom --> GpuService

GpuService finally bind the request to a new MojoVideoEncodeAcceleratorProvider 
(added in this CL as well).

GpuVideoAcceleratorFactoriesImpl uses this bound Provider to create 
MojoVideoEncodeAccelerators every time.

[1] https://cs.chromium.org/chromium/src/content/renderer/render_thread_impl.cc?dr=CSs&sq=package:chromium&l=1463

Bug: 736517
Change-Id: I3c753f951f120e1d2ffefb50a526fac15de6e881
Reviewed-on: https://chromium-review.googlesource.com/590513
Commit-Queue: Miguel Casas <mcasas@chromium.org>
Reviewed-by: Scott Violet <sky@chromium.org>
Reviewed-by: Xiaohan Wang <xhwang@chromium.org>
Reviewed-by: Tom Sepez <tsepez@chromium.org>
Reviewed-by: Emircan Uysaler <emircan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#490658}

components/viz/host/server_gpu_memory_buffer_manager_unittest.cc

@@ -61,8 +61,8 @@ class TestGpuService : public ui::mojom::GpuService {
   void CreateJpegDecodeAccelerator(
       media::mojom::GpuJpegDecodeAcceleratorRequest jda_request) override {}
 
-  void CreateVideoEncodeAccelerator(
-      media::mojom::VideoEncodeAcceleratorRequest vea_request) override {}
+  void CreateVideoEncodeAcceleratorProvider(
+      media::mojom::VideoEncodeAcceleratorProviderRequest request) override {}
 
   void CreateGpuMemoryBuffer(
       gfx::GpuMemoryBufferId id,

content/browser/gpu/gpu_client.cc

@@ -97,11 +97,13 @@ void GpuClient::CreateJpegDecodeAccelerator(
     host->gpu_service()->CreateJpegDecodeAccelerator(std::move(jda_request));
 }
 
-void GpuClient::CreateVideoEncodeAccelerator(
-    media::mojom::VideoEncodeAcceleratorRequest vea_request) {
+void GpuClient::CreateVideoEncodeAcceleratorProvider(
+    media::mojom::VideoEncodeAcceleratorProviderRequest vea_provider_request) {
   GpuProcessHost* host = GpuProcessHost::Get();
-  if (host)
-    host->gpu_service()->CreateVideoEncodeAccelerator(std::move(vea_request));
+  if (!host)
+    return;
+  host->gpu_service()->CreateVideoEncodeAcceleratorProvider(
+      std::move(vea_provider_request));
 }
 
 void GpuClient::CreateGpuMemoryBuffer(

content/browser/gpu/gpu_client.h

@@ -34,8 +34,9 @@ class GpuClient : public ui::mojom::Gpu {
       const EstablishGpuChannelCallback& callback) override;
   void CreateJpegDecodeAccelerator(
       media::mojom::GpuJpegDecodeAcceleratorRequest jda_request) override;
-  void CreateVideoEncodeAccelerator(
-      media::mojom::VideoEncodeAcceleratorRequest vea_request) override;
+  void CreateVideoEncodeAcceleratorProvider(
+      media::mojom::VideoEncodeAcceleratorProviderRequest vea_provider_request)
+      override;
   void CreateGpuMemoryBuffer(
       gfx::GpuMemoryBufferId id,
       const gfx::Size& size,

content/renderer/media/gpu/gpu_video_accelerator_factories_impl.cc

@@ -58,13 +58,14 @@ GpuVideoAcceleratorFactoriesImpl::Create(
     bool enable_gpu_memory_buffer_video_frames,
     const viz::BufferToTextureTargetMap& image_texture_targets,
     bool enable_video_accelerator,
-    media::mojom::VideoEncodeAcceleratorPtrInfo unbound_vea) {
+    media::mojom::VideoEncodeAcceleratorProviderPtrInfo unbound_vea_provider) {
   RecordContextProviderPhaseUmaEnum(
       ContextProviderPhase::CONTEXT_PROVIDER_ACQUIRED);
   return base::WrapUnique(new GpuVideoAcceleratorFactoriesImpl(
       std::move(gpu_channel_host), main_thread_task_runner, task_runner,
       context_provider, enable_gpu_memory_buffer_video_frames,
-      image_texture_targets, enable_video_accelerator, std::move(unbound_vea)));
+      image_texture_targets, enable_video_accelerator,
+      std::move(unbound_vea_provider)));
 }
 
 GpuVideoAcceleratorFactoriesImpl::GpuVideoAcceleratorFactoriesImpl(
@@ -75,7 +76,7 @@ GpuVideoAcceleratorFactoriesImpl::GpuVideoAcceleratorFactoriesImpl(
     bool enable_gpu_memory_buffer_video_frames,
     const viz::BufferToTextureTargetMap& image_texture_targets,
     bool enable_video_accelerator,
-    media::mojom::VideoEncodeAcceleratorPtrInfo unbound_vea)
+    media::mojom::VideoEncodeAcceleratorProviderPtrInfo unbound_vea_provider)
     : main_thread_task_runner_(main_thread_task_runner),
       task_runner_(task_runner),
       gpu_channel_host_(std::move(gpu_channel_host)),
@@ -87,10 +88,15 @@ GpuVideoAcceleratorFactoriesImpl::GpuVideoAcceleratorFactoriesImpl(
       video_accelerator_enabled_(enable_video_accelerator),
       gpu_memory_buffer_manager_(
           RenderThreadImpl::current()->GetGpuMemoryBufferManager()),
-      unbound_vea_(std::move(unbound_vea)),
       thread_safe_sender_(ChildThreadImpl::current()->thread_safe_sender()) {
   DCHECK(main_thread_task_runner_);
   DCHECK(gpu_channel_host_);
+
+  task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&GpuVideoAcceleratorFactoriesImpl::
+                     BindVideoEncodeAcceleratorProviderOnTaskRunner,
+                 base::Unretained(this), base::Passed(&unbound_vea_provider)));
 }
 
 GpuVideoAcceleratorFactoriesImpl::~GpuVideoAcceleratorFactoriesImpl() {}
@@ -157,12 +163,14 @@ std::unique_ptr<media::VideoEncodeAccelerator>
 GpuVideoAcceleratorFactoriesImpl::CreateVideoEncodeAccelerator() {
   DCHECK(video_accelerator_enabled_);
   DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(vea_provider_.is_bound());
   if (CheckContextLost())
     return nullptr;
 
   if (base::FeatureList::IsEnabled(features::kMojoVideoEncodeAccelerator)) {
     media::mojom::VideoEncodeAcceleratorPtr vea;
-    vea.Bind(std::move(unbound_vea_));
+    vea_provider_->CreateVideoEncodeAccelerator(mojo::MakeRequest(&vea));
+
     if (vea) {
       return std::unique_ptr<media::VideoEncodeAccelerator>(
           new media::MojoVideoEncodeAccelerator(
@@ -366,4 +374,13 @@ GpuVideoAcceleratorFactoriesImpl::ContextProviderMainThread() {
   return context_provider_refptr_;
 }
 
+void GpuVideoAcceleratorFactoriesImpl::
+    BindVideoEncodeAcceleratorProviderOnTaskRunner(
+        media::mojom::VideoEncodeAcceleratorProviderPtrInfo
+            unbound_vea_provider) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(!vea_provider_.is_bound());
+  vea_provider_.Bind(std::move(unbound_vea_provider));
+}
+
 }  // namespace content

content/renderer/media/gpu/gpu_video_accelerator_factories_impl.h

@@ -57,7 +57,7 @@ class CONTENT_EXPORT GpuVideoAcceleratorFactoriesImpl
       bool enable_gpu_memory_buffer_video_frames,
       const viz::BufferToTextureTargetMap& image_texture_targets,
       bool enable_video_accelerator,
-      media::mojom::VideoEncodeAcceleratorPtrInfo unbound_vea);
+      media::mojom::VideoEncodeAcceleratorProviderPtrInfo unbound_vea_provider);
 
   // media::GpuVideoAcceleratorFactories implementation.
   bool IsGpuVideoAcceleratorEnabled() override;
@@ -113,7 +113,10 @@ class CONTENT_EXPORT GpuVideoAcceleratorFactoriesImpl
       bool enable_gpu_memory_buffer_video_frames,
       const viz::BufferToTextureTargetMap& image_texture_targets,
       bool enable_video_accelerator,
-      media::mojom::VideoEncodeAcceleratorPtrInfo unbound_vea);
+      media::mojom::VideoEncodeAcceleratorProviderPtrInfo unbound_vea_provider);
+
+  void BindVideoEncodeAcceleratorProviderOnTaskRunner(
+      media::mojom::VideoEncodeAcceleratorProviderPtrInfo unbound_vea_provider);
 
   scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
@@ -136,7 +139,7 @@ class CONTENT_EXPORT GpuVideoAcceleratorFactoriesImpl
 
   gpu::GpuMemoryBufferManager* const gpu_memory_buffer_manager_;
 
-  media::mojom::VideoEncodeAcceleratorPtrInfo unbound_vea_;
+  media::mojom::VideoEncodeAcceleratorProviderPtr vea_provider_;
 
   // For sending requests to allocate shared memory in the Browser process.
   scoped_refptr<ThreadSafeSender> thread_safe_sender_;

content/renderer/render_thread_impl.cc

@@ -1459,15 +1459,14 @@ media::GpuVideoAcceleratorFactories* RenderThreadImpl::GetGpuFactories() {
       cmd_line->HasSwitch(switches::kEnableGpuMemoryBufferVideoFrames);
 #endif
 
-  media::mojom::VideoEncodeAcceleratorPtr vea;
-  gpu_->CreateVideoEncodeAccelerator(mojo::MakeRequest(&vea));
-  media::mojom::VideoEncodeAcceleratorPtrInfo unbound_vea = vea.PassInterface();
+  media::mojom::VideoEncodeAcceleratorProviderPtr vea_provider;
+  gpu_->CreateVideoEncodeAcceleratorProvider(mojo::MakeRequest(&vea_provider));
 
   gpu_factories_.push_back(GpuVideoAcceleratorFactoriesImpl::Create(
       std::move(gpu_channel_host), base::ThreadTaskRunnerHandle::Get(),
       media_task_runner, std::move(media_context_provider),
       enable_gpu_memory_buffer_video_frames, buffer_to_texture_target_map_,
-      enable_video_accelerator, std::move(unbound_vea)));
+      enable_video_accelerator, vea_provider.PassInterface()));
   return gpu_factories_.back().get();
 }
 

media/mojo/interfaces/video_encode_accelerator.mojom

@@ -32,6 +32,10 @@ import "ui/gfx/geometry/mojo/geometry.mojom";
 // time the Client can send a RequestEncodingParametersChange() to the VEA. None
 // of these messages are acknowledged.
 
+interface VideoEncodeAcceleratorProvider {
+  CreateVideoEncodeAccelerator(VideoEncodeAccelerator& request);
+};
+
 interface VideoEncodeAccelerator {
   // See media::VideoEncodeAccelerator::Error
   enum Error {

media/mojo/services/BUILD.gn

@@ -53,6 +53,8 @@ component("services") {
     "mojo_renderer_service.h",
     "mojo_video_decoder_service.cc",
     "mojo_video_decoder_service.h",
+    "mojo_video_encode_accelerator_provider.cc",
+    "mojo_video_encode_accelerator_provider.h",
     "mojo_video_encode_accelerator_service.cc",
     "mojo_video_encode_accelerator_service.h",
     "test_mojo_media_client.cc",

media/mojo/services/mojo_video_encode_accelerator_provider.cc

+// Copyright 2017 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 "media/mojo/services/mojo_video_encode_accelerator_provider.h"
+
+#include <memory>
+#include <utility>
+
+#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/system/platform_handle.h"
+
+namespace media {
+
+// static
+void MojoVideoEncodeAcceleratorProvider::Create(
+    mojom::VideoEncodeAcceleratorProviderRequest request,
+    const CreateAndInitializeVideoEncodeAcceleratorCallback&
+        create_vea_callback,
+    const gpu::GpuPreferences& gpu_preferences) {
+  mojo::MakeStrongBinding(base::MakeUnique<MojoVideoEncodeAcceleratorProvider>(
+                              create_vea_callback, gpu_preferences),
+                          std::move(request));
+}
+
+MojoVideoEncodeAcceleratorProvider::MojoVideoEncodeAcceleratorProvider(
+    const CreateAndInitializeVideoEncodeAcceleratorCallback&
+        create_vea_callback,
+    const gpu::GpuPreferences& gpu_preferences)
+    : create_vea_callback_(create_vea_callback),
+      gpu_preferences_(gpu_preferences) {}
+
+MojoVideoEncodeAcceleratorProvider::~MojoVideoEncodeAcceleratorProvider() {}
+
+void MojoVideoEncodeAcceleratorProvider::CreateVideoEncodeAccelerator(
+    mojom::VideoEncodeAcceleratorRequest request) {
+  MojoVideoEncodeAcceleratorService::Create(
+      std::move(request), create_vea_callback_, gpu_preferences_);
+}
+
+}  // namespace media

media/mojo/services/mojo_video_encode_accelerator_provider.h

+// Copyright 2017 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 MEDIA_MOJO_SERVICES_MOJO_VIDEO_ENCODE_ACCELERATOR_PROVIDER_H_
+#define MEDIA_MOJO_SERVICES_MOJO_VIDEO_ENCODE_ACCELERATOR_PROVIDER_H_
+
+#include "base/compiler_specific.h"
+#include "base/macros.h"
+#include "media/mojo/interfaces/video_encode_accelerator.mojom.h"
+#include "media/mojo/services/media_mojo_export.h"
+#include "media/mojo/services/mojo_video_encode_accelerator_service.h"
+
+namespace gpu {
+struct GpuPreferences;
+}  // namespace gpu
+
+namespace media {
+
+// This class implements the interface mojom::VideoEncodeAcceleratorProvider,
+// holds on to the necessary objects to create mojom::VideoEncodeAccelerators.
+class MEDIA_MOJO_EXPORT MojoVideoEncodeAcceleratorProvider
+    : public NON_EXPORTED_BASE(mojom::VideoEncodeAcceleratorProvider) {
+ public:
+  using CreateAndInitializeVideoEncodeAcceleratorCallback =
+      MojoVideoEncodeAcceleratorService::
+          CreateAndInitializeVideoEncodeAcceleratorCallback;
+
+  static void Create(mojom::VideoEncodeAcceleratorProviderRequest request,
+                     const CreateAndInitializeVideoEncodeAcceleratorCallback&
+                         create_vea_callback,
+                     const gpu::GpuPreferences& gpu_preferences);
+
+  MojoVideoEncodeAcceleratorProvider(
+      const CreateAndInitializeVideoEncodeAcceleratorCallback&
+          create_vea_callback,
+      const gpu::GpuPreferences& gpu_preferences);
+  ~MojoVideoEncodeAcceleratorProvider() override;
+
+  // mojom::VideoEncodeAcceleratorProvider impl.
+  void CreateVideoEncodeAccelerator(
+      mojom::VideoEncodeAcceleratorRequest request) override;
+
+ private:
+  const CreateAndInitializeVideoEncodeAcceleratorCallback create_vea_callback_;
+  const gpu::GpuPreferences& gpu_preferences_;
+
+  DISALLOW_COPY_AND_ASSIGN(MojoVideoEncodeAcceleratorProvider);
+};
+
+}  // namespace media
+
+#endif  // MEDIA_MOJO_SERVICES_MOJO_VIDEO_ENCODE_ACCELERATOR_PROVIDER_H_

services/ui/gpu/gpu_service.cc

@@ -37,7 +37,7 @@
 #include "media/gpu/ipc/service/gpu_video_decode_accelerator.h"
 #include "media/gpu/ipc/service/gpu_video_encode_accelerator.h"
 #include "media/gpu/ipc/service/media_gpu_channel_manager.h"
-#include "media/mojo/services/mojo_video_encode_accelerator_service.h"
+#include "media/mojo/services/mojo_video_encode_accelerator_provider.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_switches.h"
@@ -234,11 +234,11 @@ void GpuService::CreateJpegDecodeAccelerator(
   NOTIMPLEMENTED();
 }
 
-void GpuService::CreateVideoEncodeAccelerator(
-    media::mojom::VideoEncodeAcceleratorRequest vea_request) {
+void GpuService::CreateVideoEncodeAcceleratorProvider(
+    media::mojom::VideoEncodeAcceleratorProviderRequest vea_provider_request) {
   DCHECK(io_runner_->BelongsToCurrentThread());
-  media::MojoVideoEncodeAcceleratorService::Create(
-      std::move(vea_request),
+  media::MojoVideoEncodeAcceleratorProvider::Create(
+      std::move(vea_provider_request),
       base::Bind(&media::GpuVideoEncodeAcceleratorFactory::CreateVEA),
       gpu_preferences_);
 }

services/ui/gpu/gpu_service.h

@@ -136,8 +136,9 @@ class GpuService : public gpu::GpuChannelManagerDelegate,
   void CloseChannel(int32_t client_id) override;
   void CreateJpegDecodeAccelerator(
       media::mojom::GpuJpegDecodeAcceleratorRequest jda_request) override;
-  void CreateVideoEncodeAccelerator(
-      media::mojom::VideoEncodeAcceleratorRequest vea_request) override;
+  void CreateVideoEncodeAcceleratorProvider(
+      media::mojom::VideoEncodeAcceleratorProviderRequest vea_provider_request)
+      override;
   void CreateGpuMemoryBuffer(
       gfx::GpuMemoryBufferId id,
       const gfx::Size& size,

services/ui/gpu/interfaces/gpu_service.mojom

@@ -28,8 +28,9 @@ interface GpuService {
   // Creates a new JpegDecodeAccelerator and binds it to |jda|.
   CreateJpegDecodeAccelerator(media.mojom.GpuJpegDecodeAccelerator& jda);
 
-  // Creates a new VideoEncodeAccelerator and binds it to |vea|.
-  CreateVideoEncodeAccelerator(media.mojom.VideoEncodeAccelerator& vea);
+  // Creates a VideoEncodeAcceleratorProvider and binds it to |vea_provider|.
+  CreateVideoEncodeAcceleratorProvider(
+      media.mojom.VideoEncodeAcceleratorProvider& vea_provider);
 
   CreateGpuMemoryBuffer(gfx.mojom.GpuMemoryBufferId id,
                         gfx.mojom.Size size,

services/ui/public/cpp/gpu/gpu.cc

@@ -98,12 +98,12 @@ void Gpu::CreateJpegDecodeAccelerator(
   gpu_->CreateJpegDecodeAccelerator(std::move(jda_request));
 }
 
-void Gpu::CreateVideoEncodeAccelerator(
-    media::mojom::VideoEncodeAcceleratorRequest vea_request) {
+void Gpu::CreateVideoEncodeAcceleratorProvider(
+    media::mojom::VideoEncodeAcceleratorProviderRequest vea_provider_request) {
   DCHECK(IsMainThread());
   if (!gpu_ || !gpu_.is_bound())
     gpu_ = factory_.Run();
-  gpu_->CreateVideoEncodeAccelerator(std::move(vea_request));
+  gpu_->CreateVideoEncodeAcceleratorProvider(std::move(vea_provider_request));
 }
 
 void Gpu::EstablishGpuChannel(

services/ui/public/cpp/gpu/gpu.h

@@ -46,8 +46,8 @@ class Gpu : public gpu::GpuChannelHostFactory,
 
   void CreateJpegDecodeAccelerator(
       media::mojom::GpuJpegDecodeAcceleratorRequest jda_request);
-  void CreateVideoEncodeAccelerator(
-      media::mojom::VideoEncodeAcceleratorRequest vea_request);
+  void CreateVideoEncodeAcceleratorProvider(
+      media::mojom::VideoEncodeAcceleratorProviderRequest vea_provider_request);
 
   // gpu::GpuChannelEstablishFactory:
   void EstablishGpuChannel(

services/ui/public/cpp/tests/gpu_unittest.cc

@@ -56,8 +56,8 @@ class TestGpuImpl : public mojom::Gpu {
   void CreateJpegDecodeAccelerator(
       media::mojom::GpuJpegDecodeAcceleratorRequest jda_request) override {}
 
-  void CreateVideoEncodeAccelerator(
-      media::mojom::VideoEncodeAcceleratorRequest vea_request) override {}
+  void CreateVideoEncodeAcceleratorProvider(
+      media::mojom::VideoEncodeAcceleratorProviderRequest request) override {}
 
   void CreateGpuMemoryBuffer(
       gfx::GpuMemoryBufferId id,

services/ui/public/interfaces/gpu.mojom

@@ -23,8 +23,9 @@ interface Gpu {
   // Creates a new JpegDecodeAccelerator and binds it to |jda|.
   CreateJpegDecodeAccelerator(media.mojom.GpuJpegDecodeAccelerator& jda);
 
-  // Creates a new VideoEncodeAccelerator and binds it to |vea|.
-  CreateVideoEncodeAccelerator(media.mojom.VideoEncodeAccelerator& vea);
+  // Creates a VideoEncodeAcceleratorProvider and binds it to |vea_provider|.
+  CreateVideoEncodeAcceleratorProvider(
+      media.mojom.VideoEncodeAcceleratorProvider& vea_provider);
 
   // Tells the GPU service to create a new GPU memory buffer.
   CreateGpuMemoryBuffer(gfx.mojom.GpuMemoryBufferId id,

services/ui/ws/gpu_client.cc

@@ -61,8 +61,8 @@ void GpuClient::CreateJpegDecodeAccelerator(
   gpu_service_->CreateJpegDecodeAccelerator(std::move(jda_request));
 }
 
-void GpuClient::CreateVideoEncodeAccelerator(
-    media::mojom::VideoEncodeAcceleratorRequest vea_request) {
+void GpuClient::CreateVideoEncodeAcceleratorProvider(
+    media::mojom::VideoEncodeAcceleratorProviderRequest request) {
   NOTIMPLEMENTED();
 }
 

services/ui/ws/gpu_client.h

@@ -46,8 +46,8 @@ class GpuClient : public mojom::Gpu {
       const EstablishGpuChannelCallback& callback) override;
   void CreateJpegDecodeAccelerator(
       media::mojom::GpuJpegDecodeAcceleratorRequest jda_request) override;
-  void CreateVideoEncodeAccelerator(
-      media::mojom::VideoEncodeAcceleratorRequest vea_request) override;
+  void CreateVideoEncodeAcceleratorProvider(
+      media::mojom::VideoEncodeAcceleratorProviderRequest request) override;
   void CreateGpuMemoryBuffer(
       gfx::GpuMemoryBufferId id,
       const gfx::Size& size,