Add FlingingRendererClient

Currently, a MojoRenderer is directly used to pass through messages to
and from the FlingingRenderer (FR).

This CL adds the FlingingRendererClient (FRC), which serves almost
exactly the same purpose as a pass-through MojoRenderer. The difference
is that, the FRC implements the mojom::FlingingRendererClientExtension,
which allows the FR to send remote Play/Pause change events directly to
the FRC. This removes the need for the general mojom::RendererClient to
have a specialized OnRemotePlayStateChange().

A follow up CL will remove media::RendererClient::OnRemotePlayState().

Bug: 956677
Change-Id: Ia7484b54849991cfad8a78040d0e47ab156bc3e3
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1526637
Commit-Queue: Thomas Guilbert <tguilbert@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Reviewed-by: Xiaohan Wang <xhwang@chromium.org>
Cr-Commit-Position: refs/heads/master@{#654573}

content/browser/media/flinging_renderer.cc

@@ -4,6 +4,8 @@
 
 #include "content/browser/media/flinging_renderer.h"
 
+#include <utility>
+
 #include "base/memory/ptr_util.h"
 #include "content/browser/frame_host/render_frame_host_delegate.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
@@ -15,8 +17,10 @@
 namespace content {
 
 FlingingRenderer::FlingingRenderer(
-    std::unique_ptr<media::FlingingController> controller)
-    : controller_(std::move(controller)) {
+    std::unique_ptr<media::FlingingController> controller,
+    ClientExtensionPtr client_extension)
+    : client_extension_(std::move(client_extension)),
+      controller_(std::move(controller)) {
   controller_->AddMediaStatusObserver(this);
 }
 
@@ -27,7 +31,8 @@ FlingingRenderer::~FlingingRenderer() {
 // static
 std::unique_ptr<FlingingRenderer> FlingingRenderer::Create(
     RenderFrameHost* render_frame_host,
-    const std::string& presentation_id) {
+    const std::string& presentation_id,
+    ClientExtensionPtr client_extension) {
   DVLOG(1) << __func__;
 
   ContentClient* content_client = GetContentClient();
@@ -54,8 +59,8 @@ std::unique_ptr<FlingingRenderer> FlingingRenderer::Create(
   if (!flinging_controller)
     return nullptr;
 
-  return base::WrapUnique<FlingingRenderer>(
-      new FlingingRenderer(std::move(flinging_controller)));
+  return base::WrapUnique<FlingingRenderer>(new FlingingRenderer(
+      std::move(flinging_controller), std::move(client_extension)));
 }
 
 // media::Renderer implementation
@@ -158,7 +163,7 @@ void FlingingRenderer::OnMediaStatusUpdated(const media::MediaStatus& status) {
   // reached a new stable PlayState without WMPI having asked for it.
   // Let WMPI know it should update itself.
   if (current_state != target_play_state_)
-    client_->OnRemotePlayStateChange(current_state);
+    client_extension_->OnRemotePlayStateChange(current_state);
 }
 
 }  // namespace content

content/browser/media/flinging_renderer.h

@@ -12,6 +12,7 @@
 #include "media/base/media_status_observer.h"
 #include "media/base/renderer.h"
 #include "media/base/renderer_client.h"
+#include "media/mojo/interfaces/renderer_extensions.mojom.h"
 #include "url/gurl.h"
 
 namespace content {
@@ -27,13 +28,16 @@ class RenderFrameHost;
 class CONTENT_EXPORT FlingingRenderer : public media::Renderer,
                                         media::MediaStatusObserver {
  public:
+  using ClientExtensionPtr = media::mojom::FlingingRendererClientExtensionPtr;
+
   // Helper method to create a FlingingRenderer from an already existing
   // presentation ID.
   // Returns nullptr if there was an error getting the MediaControllor for the
   // given presentation ID.
   static std::unique_ptr<FlingingRenderer> Create(
       RenderFrameHost* render_frame_host,
-      const std::string& presentation_id);
+      const std::string& presentation_id,
+      ClientExtensionPtr client_extension);
 
   ~FlingingRenderer() override;
 
@@ -57,7 +61,8 @@ class CONTENT_EXPORT FlingingRenderer : public media::Renderer,
   using PlayState = media::MediaStatus::State;
 
   explicit FlingingRenderer(
-      std::unique_ptr<media::FlingingController> controller);
+      std::unique_ptr<media::FlingingController> controller,
+      ClientExtensionPtr client_extension);
 
   void SetTargetPlayState(PlayState state);
 
@@ -69,6 +74,8 @@ class CONTENT_EXPORT FlingingRenderer : public media::Renderer,
 
   media::RendererClient* client_;
 
+  ClientExtensionPtr client_extension_;
+
   std::unique_ptr<media::FlingingController> controller_;
 
   DISALLOW_COPY_AND_ASSIGN(FlingingRenderer);

content/browser/media/flinging_renderer_unittest.cc

@@ -53,7 +53,8 @@ class FlingingRendererTest : public testing::Test {
     EXPECT_CALL(*flinging_controller_, RemoveMediaStatusObserver(_));
 
     renderer_ = base::WrapUnique(new FlingingRenderer(
-        std::unique_ptr<media::FlingingController>(flinging_controller_)));
+        std::unique_ptr<media::FlingingController>(flinging_controller_),
+        nullptr));
 
     renderer_->Initialize(nullptr, &renderer_client_, base::DoNothing());
   }

content/browser/media/media_interface_proxy.cc

@@ -177,13 +177,15 @@ void MediaInterfaceProxy::CreateCastRenderer(
 #if defined(OS_ANDROID)
 void MediaInterfaceProxy::CreateFlingingRenderer(
     const std::string& presentation_id,
+    media::mojom::FlingingRendererClientExtensionPtr client_extension,
     media::mojom::RendererRequest request) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  std::unique_ptr<FlingingRenderer> renderer =
-      FlingingRenderer::Create(render_frame_host_, presentation_id);
 
-  media::MojoRendererService::Create(nullptr, std::move(renderer),
-                                     std::move(request));
+  media::MojoRendererService::Create(
+      nullptr,
+      FlingingRenderer::Create(render_frame_host_, presentation_id,
+                               std::move(client_extension)),
+      std::move(request));
 }
 
 void MediaInterfaceProxy::CreateMediaPlayerRenderer(

content/browser/media/media_interface_proxy.h

@@ -56,8 +56,10 @@ class MediaInterfaceProxy : public media::mojom::InterfaceFactory {
                           media::mojom::RendererRequest request) final;
 #endif
 #if defined(OS_ANDROID)
-  void CreateFlingingRenderer(const std::string& presentation_id,
-                              media::mojom::RendererRequest request) final;
+  void CreateFlingingRenderer(
+      const std::string& presentation_id,
+      media::mojom::FlingingRendererClientExtensionPtr client_extension,
+      media::mojom::RendererRequest request) final;
   void CreateMediaPlayerRenderer(
       media::mojom::MediaPlayerRendererClientExtensionPtr client_extension_ptr,
       media::mojom::RendererRequest request,

content/browser/media/video_decoder_proxy.cc

@@ -55,6 +55,7 @@ void VideoDecoderProxy::CreateCastRenderer(
 #if defined(OS_ANDROID)
 void VideoDecoderProxy::CreateFlingingRenderer(
     const std::string& audio_device_id,
+    media::mojom::FlingingRendererClientExtensionPtr client_extenion,
     media::mojom::RendererRequest request) {}
 
 void VideoDecoderProxy::CreateMediaPlayerRenderer(

content/browser/media/video_decoder_proxy.h

@@ -43,8 +43,10 @@ class VideoDecoderProxy : public media::mojom::InterfaceFactory {
       media::mojom::RendererRequest request,
       media::mojom::MediaPlayerRendererExtensionRequest
           renderer_extension_request) final;
-  void CreateFlingingRenderer(const std::string& presentation_id,
-                              media::mojom::RendererRequest request) final;
+  void CreateFlingingRenderer(
+      const std::string& presentation_id,
+      media::mojom::FlingingRendererClientExtensionPtr client_extension,
+      media::mojom::RendererRequest request) final;
 #endif  // defined(OS_ANDROID)
   void CreateCdm(const std::string& key_system,
                  media::mojom::ContentDecryptionModuleRequest request) final;

content/renderer/BUILD.gn

@@ -196,6 +196,8 @@ target(link_target_type, "renderer") {
     "manifest/manifest_manager.h",
     "manifest/manifest_uma_util.cc",
     "manifest/manifest_uma_util.h",
+    "media/android/flinging_renderer_client.cc",
+    "media/android/flinging_renderer_client.h",
     "media/android/flinging_renderer_client_factory.cc",
     "media/android/flinging_renderer_client_factory.h",
     "media/android/media_player_renderer_client.cc",

content/renderer/media/android/flinging_renderer_client.cc

+// Copyright 2019 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/renderer/media/android/flinging_renderer_client.h"
+
+#include <utility>
+
+#include "base/bind.h"
+#include "base/callback_helpers.h"
+
+namespace content {
+
+FlingingRendererClient::FlingingRendererClient(
+    ClientExtentionRequest client_extension_request,
+    scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
+    std::unique_ptr<media::MojoRenderer> mojo_renderer)
+    : MojoRendererWrapper(std::move(mojo_renderer)),
+      media_task_runner_(std::move(media_task_runner)),
+      delayed_bind_client_extension_request_(
+          std::move(client_extension_request)),
+      client_extension_binding_(this) {}
+
+FlingingRendererClient::~FlingingRendererClient() = default;
+
+void FlingingRendererClient::Initialize(
+    media::MediaResource* media_resource,
+    media::RendererClient* client,
+    const media::PipelineStatusCB& init_cb) {
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
+
+  client_ = client;
+
+  client_extension_binding_.Bind(
+      std::move(delayed_bind_client_extension_request_), media_task_runner_);
+
+  MojoRendererWrapper::Initialize(media_resource, client, init_cb);
+}
+
+void FlingingRendererClient::OnRemotePlayStateChange(
+    media::MediaStatus::State state) {
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
+  client_->OnRemotePlayStateChange(state);
+}
+
+}  // namespace content

content/renderer/media/android/flinging_renderer_client.h

+// Copyright 2019 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 CONTENT_RENDERER_MEDIA_ANDROID_FLINGING_RENDERER_CLIENT_H_
+#define CONTENT_RENDERER_MEDIA_ANDROID_FLINGING_RENDERER_CLIENT_H_
+
+#include <memory>
+
+#include "base/callback.h"
+#include "base/macros.h"
+#include "base/memory/weak_ptr.h"
+#include "base/single_thread_task_runner.h"
+#include "content/common/content_export.h"
+#include "media/base/media_resource.h"
+#include "media/base/renderer.h"
+#include "media/base/renderer_client.h"
+#include "media/base/video_renderer_sink.h"
+#include "media/mojo/clients/mojo_renderer.h"
+#include "media/mojo/clients/mojo_renderer_wrapper.h"
+#include "media/mojo/interfaces/renderer_extensions.mojom.h"
+#include "mojo/public/cpp/bindings/binding.h"
+
+namespace content {
+
+// FlingingRendererClient lives in Renderer process and mirrors a
+// FlingingRenderer living in the Browser process.
+class CONTENT_EXPORT FlingingRendererClient
+    : public media::mojom::FlingingRendererClientExtension,
+      public media::MojoRendererWrapper {
+ public:
+  using ClientExtentionRequest =
+      media::mojom::FlingingRendererClientExtensionRequest;
+
+  FlingingRendererClient(
+      ClientExtentionRequest client_extension_request,
+      scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
+      std::unique_ptr<media::MojoRenderer> mojo_renderer);
+
+  ~FlingingRendererClient() override;
+
+  // media::MojoRendererWrapper overrides.
+  void Initialize(media::MediaResource* media_resource,
+                  media::RendererClient* client,
+                  const media::PipelineStatusCB& init_cb) override;
+
+  // media::mojom::FlingingRendererClientExtension implementation
+  void OnRemotePlayStateChange(media::MediaStatus::State state) override;
+
+ private:
+  scoped_refptr<base::SingleThreadTaskRunner> media_task_runner_;
+
+  media::RendererClient* client_;
+
+  // Used temporarily, to delay binding to |client_extension_binding_| until we
+  // are on the right sequence, when Initialize() is called.
+  ClientExtentionRequest delayed_bind_client_extension_request_;
+
+  mojo::Binding<FlingingRendererClientExtension> client_extension_binding_;
+
+  DISALLOW_COPY_AND_ASSIGN(FlingingRendererClient);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_RENDERER_MEDIA_ANDROID_FLINGING_RENDERER_CLIENT_H_

content/renderer/media/android/flinging_renderer_client_factory.cc

@@ -9,8 +9,10 @@
 #include <utility>
 
 #include "base/logging.h"
+#include "content/renderer/media/android/flinging_renderer_client.h"
 #include "media/mojo/clients/mojo_renderer.h"
 #include "media/mojo/clients/mojo_renderer_factory.h"
+#include "media/mojo/interfaces/renderer_extensions.mojom.h"
 
 namespace content {
 
@@ -31,8 +33,19 @@ std::unique_ptr<media::Renderer> FlingingRendererClientFactory::CreateRenderer(
     const gfx::ColorSpace& /* target_color_space */) {
   DCHECK(IsFlingingActive());
 
-  return mojo_flinging_factory_->CreateFlingingRenderer(
-      GetActivePresentationId(), media_task_runner, video_renderer_sink);
+  // Used to send messages from the FlingingRenderer (Browser process),
+  // to the FlingingRendererClient (Renderer process). The
+  // |client_extension_request| will be bound in FlingingRendererClient.
+  media::mojom::FlingingRendererClientExtensionPtr client_extension_ptr;
+  auto client_extension_request = mojo::MakeRequest(&client_extension_ptr);
+
+  auto mojo_renderer = mojo_flinging_factory_->CreateFlingingRenderer(
+      GetActivePresentationId(), std::move(client_extension_ptr),
+      media_task_runner, video_renderer_sink);
+
+  return std::make_unique<FlingingRendererClient>(
+      std::move(client_extension_request), media_task_runner,
+      std::move(mojo_renderer));
 }
 
 std::string FlingingRendererClientFactory::GetActivePresentationId() {

content/renderer/media/android/flinging_renderer_client_factory.h

@@ -20,15 +20,10 @@ namespace content {
 
 // Creates a renderer for media flinging.
 // The FRCF uses a MojoRendererFactory to create a FlingingRenderer in the
-// browser process. The actual renderer returned by the FRCF is a MojoRenderer
-// directly (as opposed to a dedicated FlingingRendererClient), because all the
-// renderer needs to do is forward calls to the FlingingRenderer in the browser.
+// browser process.
 class CONTENT_EXPORT FlingingRendererClientFactory
     : public media::RendererFactory {
  public:
-  // |mojo_flinging_factory| should be created using
-  // HostedRendererType::kFlinging, and GetActivePresentationId()
-  // should be given to it through SetGetTypeSpecificIdCB().
   FlingingRendererClientFactory(
       std::unique_ptr<media::MojoRendererFactory> mojo_renderer_factory,
       std::unique_ptr<media::RemotePlaybackClientWrapper>

content/renderer/media/media_interface_factory.cc

@@ -110,18 +110,20 @@ void MediaInterfaceFactory::CreateMediaPlayerRenderer(
 
 void MediaInterfaceFactory::CreateFlingingRenderer(
     const std::string& presentation_id,
+    media::mojom::FlingingRendererClientExtensionPtr client_extension,
     media::mojom::RendererRequest request) {
   if (!task_runner_->BelongsToCurrentThread()) {
     task_runner_->PostTask(
         FROM_HERE,
         base::BindOnce(&MediaInterfaceFactory::CreateFlingingRenderer,
-                       weak_this_, presentation_id, std::move(request)));
+                       weak_this_, presentation_id, std::move(client_extension),
+                       std::move(request)));
     return;
   }
 
   DVLOG(1) << __func__;
-  GetMediaInterfaceFactory()->CreateFlingingRenderer(presentation_id,
-                                                     std::move(request));
+  GetMediaInterfaceFactory()->CreateFlingingRenderer(
+      presentation_id, std::move(client_extension), std::move(request));
 }
 #endif  // defined(OS_ANDROID)
 

content/renderer/media/media_interface_factory.h

@@ -42,8 +42,10 @@ class CONTENT_EXPORT MediaInterfaceFactory
                           media::mojom::RendererRequest request) final;
 #endif
 #if defined(OS_ANDROID)
-  void CreateFlingingRenderer(const std::string& presentation_id,
-                              media::mojom::RendererRequest request) final;
+  void CreateFlingingRenderer(
+      const std::string& presentation_id,
+      media::mojom::FlingingRendererClientExtensionPtr client_extension,
+      media::mojom::RendererRequest request) final;
   void CreateMediaPlayerRenderer(
       media::mojom::MediaPlayerRendererClientExtensionPtr client_extension_ptr,
       media::mojom::RendererRequest request,

media/mojo/clients/mojo_renderer.cc

@@ -265,11 +265,6 @@ void MojoRenderer::OnVideoNaturalSizeChange(const gfx::Size& size) {
   client_->OnVideoNaturalSizeChange(size);
 }
 
-void MojoRenderer::OnRemotePlayStateChange(media::MediaStatus::State state) {
-  DVLOG(2) << __func__ << ": state [" << static_cast<int>(state) << "]";
-  client_->OnRemotePlayStateChange(state);
-}
-
 void MojoRenderer::OnVideoOpacityChange(bool opaque) {
   DVLOG(2) << __func__ << ": " << opaque;
   DCHECK(task_runner_->BelongsToCurrentThread());

media/mojo/clients/mojo_renderer.h

@@ -76,7 +76,6 @@ class MojoRenderer : public Renderer, public mojom::RendererClient {
   void OnVideoOpacityChange(bool opaque) override;
   void OnWaiting(WaitingReason reason) override;
   void OnStatisticsUpdate(const PipelineStatistics& stats) override;
-  void OnRemotePlayStateChange(media::MediaStatus::State state) override;
 
   // Binds |remote_renderer_| to the mojo message pipe. Can be called multiple
   // times. If an error occurs during connection, OnConnectionError will be

media/mojo/clients/mojo_renderer_factory.cc

@@ -49,11 +49,14 @@ std::unique_ptr<Renderer> MojoRendererFactory::CreateRenderer(
 #if defined(OS_ANDROID)
 std::unique_ptr<MojoRenderer> MojoRendererFactory::CreateFlingingRenderer(
     const std::string& presentation_id,
+    mojom::FlingingRendererClientExtensionPtr client_extension_ptr,
     const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
     VideoRendererSink* video_renderer_sink) {
   DCHECK(interface_factory_);
   mojom::RendererPtr renderer_ptr;
+
   interface_factory_->CreateFlingingRenderer(presentation_id,
+                                             std::move(client_extension_ptr),
                                              mojo::MakeRequest(&renderer_ptr));
 
   return std::make_unique<MojoRenderer>(

media/mojo/clients/mojo_renderer_factory.h

@@ -50,6 +50,7 @@ class MojoRendererFactory : public RendererFactory {
 #if defined(OS_ANDROID)
   std::unique_ptr<MojoRenderer> CreateFlingingRenderer(
       const std::string& presentation_id,
+      mojom::FlingingRendererClientExtensionPtr client_extenion_ptr,
       const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
       VideoRendererSink* video_renderer_sink);
 

media/mojo/interfaces/interface_factory.mojom

@@ -51,7 +51,9 @@ interface InterfaceFactory {
   // Creates a FlingingRenderer (FlingingRendererFactory).
   // The |presentation_id| is used to find an already set-up RemotePlayback
   // session (see blink::RemotePlayback).
-  CreateFlingingRenderer(string presentation_id, Renderer& renderer);
+  CreateFlingingRenderer(string presentation_id,
+                         FlingingRendererClientExtension client_extension,
+                         Renderer& renderer);
 
   // Creates a CDM based on the |key_system| provided. A |key_system| is a
   // generic term for a decryption mechanism and/or content protection provider.

media/mojo/interfaces/renderer.mojom

@@ -81,10 +81,4 @@ interface RendererClient {
   // Called when the remote renderering service is waiting for |reason|,
   // e.g. waiting for decryption key.
   OnWaiting(WaitingReason reason);
-
-  // Executed whenever a renderer receives notification of a status change that
-  // was not originated by its owner.
-  // Only used with the FlingingRenderer (when external devices play/pause the
-  // video playing remotely).
-  OnRemotePlayStateChange(MediaStatusState state);
 };

media/mojo/interfaces/renderer_extensions.mojom

@@ -4,13 +4,17 @@
 
 module media.mojom;
 
+import "media/mojo/interfaces/media_types.mojom";
 import "mojo/public/mojom/base/time.mojom";
 import "mojo/public/mojom/base/unguessable_token.mojom";
 import "ui/gfx/geometry/mojo/geometry.mojom";
 
-// Extension of the mojo::RendererClient communication layer, exposing
-// renderer-side events handlers to the Browser process.
-// Backed by MediaPlayerRendererClient, called by MediaPlayerRenderer.
+// Extension of the mojo::RendererClient communication layer for HLS and Android
+// software rendering fallback paths.
+// This allows the Browser side to call
+// back into the Renderer side. Concretely, the MediaPlayerRenderer uses these
+// methods to propagate events it raises to the MediaPlayerRendererClient, which
+// lives in the Renderer process.
 interface MediaPlayerRendererClientExtension {
   // Called when the first time the metadata is updated, and whenever the
   // metadata changes.
@@ -18,9 +22,11 @@ interface MediaPlayerRendererClientExtension {
   OnDurationChange(mojo_base.mojom.TimeDelta duration);
 };
 
-// Extension of the mojo::Renderer communication layer, exposing browser-side
-// methods to the Renderer process.
-// Backed by MediaPlayerRenderer, called by MediaPlayerRendererClient.
+// Extension of the mojo::RendererClient communication layer for HLS and Android
+// software rendering fallback paths.
+// This allows the Renderer side to call into the Browser side.
+// Concretely, the MediaPlayerRendererClient uses these methods to send commands
+// to MediaPlayerRenderer, which lives in the Browser process.
 interface MediaPlayerRendererExtension {
   // Registers a new request in the ScopedSurfaceRequestManager, and returns
   // its token.
@@ -29,3 +35,15 @@ interface MediaPlayerRendererExtension {
   InitiateScopedSurfaceRequest()
       => (mojo_base.mojom.UnguessableToken request_token);
 };
+
+// Extension of the mojo::RendererClient communication layer for media flinging,
+// a.k.a RemotePlayback, when playing media on a remote Cast device.
+// This allows the Browser side to call back into the Renderer side.
+// Concretely, the FlingingRenderer uses these methods to propagate events it
+// raises to the FlingingRendererClient, which lives in the Renderer process.
+interface FlingingRendererClientExtension {
+  // Called when the play state of a casted device goes out of sync with WMPI's
+  // play state (e.g. when another phone play/pauses a cast device on the same
+  // network).
+  OnRemotePlayStateChange(MediaStatusState state);
+};

media/mojo/services/interface_factory_impl.cc

@@ -170,6 +170,7 @@ void InterfaceFactoryImpl::CreateMediaPlayerRenderer(
 
 void InterfaceFactoryImpl::CreateFlingingRenderer(
     const std::string& audio_device_id,
+    mojom::FlingingRendererClientExtensionPtr client_extension,
     mojo::InterfaceRequest<mojom::Renderer> request) {
   NOTREACHED();
 }

media/mojo/services/interface_factory_impl.h

@@ -53,8 +53,10 @@ class InterfaceFactoryImpl : public DeferredDestroy<mojom::InterfaceFactory> {
       mojom::RendererRequest request,
       mojom::MediaPlayerRendererExtensionRequest renderer_extension_request)
       final;
-  void CreateFlingingRenderer(const std::string& presentation_id,
-                              mojom::RendererRequest request) final;
+  void CreateFlingingRenderer(
+      const std::string& presentation_id,
+      mojom::FlingingRendererClientExtensionPtr client_extension,
+      mojom::RendererRequest request) final;
 #endif  // defined(OS_ANDROID)
   void CreateCdm(const std::string& key_system,
                  mojom::ContentDecryptionModuleRequest request) final;

media/mojo/services/mojo_renderer_service.cc

@@ -189,7 +189,7 @@ void MojoRendererService::OnVideoNaturalSizeChange(const gfx::Size& size) {
 }
 
 void MojoRendererService::OnRemotePlayStateChange(MediaStatus::State state) {
-  client_->OnRemotePlayStateChange(state);
+  // TODO(https://crbug.com/956677, tguilbert): Remove this function.
 }
 
 void MojoRendererService::OnVideoOpacityChange(bool opaque) {