Pass ApplicationSessionId to CastRenderer

Chromecast needs to know which application session
certain CastRenderer/CmaBackend is created for
(see b/79265398). In order to establish the association
between the application session and the CastRenderer,
we need to pass a std::string type |application_session_id|
into the CastRenderer initialization process.

This CL adds a |host_interfaces_| member in CastRenderer
and an ApplicationSessionIdManager service that's
attached to RenderFrameHost. During Initialization process,
the CastRenderer uses |host_interfaces_| to obtain the
ApplicationSessionIdManager service and then retrives
the corresponding |applicationSessionId| from such service.

Bug:internal b/79265398
Test:

1. verified a special case (LocalAudioRenderer) is not broken.
2. cherry-picked into internal Chromecast and verified real
ID arrived at CastRenderer.

Change-Id: Ief94a532dbdc346516333e981c8f445efb3a4333
Reviewed-on: https://chromium-review.googlesource.com/1117840
Commit-Queue: Guohui Deng <guohuideng@chromium.org>
Reviewed-by: Yuchen Liu <yucliu@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Reviewed-by: Kenneth MacKay <kmackay@chromium.org>
Reviewed-by: Sergey Volk <servolk@chromium.org>
Reviewed-by: Xiaohan Wang <xhwang@chromium.org>
Cr-Commit-Position: refs/heads/master@{#572211}

chromecast/browser/BUILD.gn

@@ -17,6 +17,8 @@ cast_source_set("browser") {
   sources = [
     "application_media_capabilities.cc",
     "application_media_capabilities.h",
+    "application_session_id_manager.cc",
+    "application_session_id_manager.h",
     "bluetooth/cast_bluetooth_chooser.cc",
     "bluetooth/cast_bluetooth_chooser.h",
     "cast_browser_context.cc",

chromecast/browser/application_session_id_manager.cc

+// Copyright 2018 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 "chromecast/browser/application_session_id_manager.h"
+
+#include <utility>
+
+namespace chromecast {
+namespace media {
+
+void CreateApplicationSessionIdManager(
+    content::RenderFrameHost* render_frame_host,
+    std::string application_session_id,
+    ::media::mojom::ApplicationSessionIdManagerRequest request) {
+  // The created CastApplicationSessionIdManager will return
+  // the |application_session_id| that's passed in here.
+  // The object will be deleted on connection error, or when the frame navigates
+  // away. See FrameServiceBase for details.
+  new CastApplicationSessionIdManager(render_frame_host, std::move(request),
+                                      std::move(application_session_id));
+}
+
+CastApplicationSessionIdManager::CastApplicationSessionIdManager(
+    content::RenderFrameHost* render_frame_host,
+    ::media::mojom::ApplicationSessionIdManagerRequest request,
+    std::string application_session_id)
+    : FrameServiceBase(render_frame_host, std::move(request)),
+      application_session_id_(std::move(application_session_id)) {}
+
+void CastApplicationSessionIdManager::GetApplicationSessionId(
+    GetApplicationSessionIdCallback callback) {
+  std::move(callback).Run(application_session_id_);
+}
+
+}  // namespace media
+}  // namespace chromecast
\ No newline at end of file

chromecast/browser/application_session_id_manager.h

+// Copyright 2018 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 CHROMECAST_BROWSER_APPLICATION_SESSION_ID_MANAGER_H_
+#define CHROMECAST_BROWSER_APPLICATION_SESSION_ID_MANAGER_H_
+
+#include <string>
+
+#include "base/macros.h"
+#include "content/public/browser/frame_service_base.h"
+#include "media/mojo/interfaces/application_session_id_manager.mojom.h"
+
+namespace content {
+class RenderFrameHost;
+}  // namespace content
+
+namespace chromecast {
+namespace media {
+
+class CastApplicationSessionIdManager
+    : public ::content::FrameServiceBase<
+          ::media::mojom::ApplicationSessionIdManager> {
+ public:
+  CastApplicationSessionIdManager(
+      content::RenderFrameHost* render_frame_host,
+      ::media::mojom::ApplicationSessionIdManagerRequest request,
+      std::string application_session_id);
+
+ private:
+  // ::media::mojom::ApplicationSessionIdManager implementation.
+  void GetApplicationSessionId(GetApplicationSessionIdCallback callback) final;
+
+  const std::string application_session_id_;
+
+  DISALLOW_COPY_AND_ASSIGN(CastApplicationSessionIdManager);
+};
+
+void CreateApplicationSessionIdManager(
+    content::RenderFrameHost* render_frame_host,
+    std::string application_session_id,
+    ::media::mojom::ApplicationSessionIdManagerRequest request);
+
+}  // namespace media
+}  // namespace chromecast
+
+#endif  // CHROMECAST_BROWSER_APPLICATION_SESSION_ID_MANAGER_H_

chromecast/browser/cast_content_browser_client.cc

@@ -24,6 +24,7 @@
 #include "chromecast/base/cast_features.h"
 #include "chromecast/base/cast_paths.h"
 #include "chromecast/base/chromecast_switches.h"
+#include "chromecast/browser/application_session_id_manager.h"
 #include "chromecast/browser/cast_browser_context.h"
 #include "chromecast/browser/cast_browser_main_parts.h"
 #include "chromecast/browser/cast_browser_process.h"
@@ -662,6 +663,13 @@ void CastContentBrowserClient::ExposeInterfacesToMediaService(
   registry->AddInterface(
       base::BindRepeating(&CreateMediaDrmStorage, render_frame_host));
 #endif
+
+  std::string application_session_id =
+      CastNavigationUIData::GetSessionIdForWebContents(
+          content::WebContents::FromRenderFrameHost(render_frame_host));
+  registry->AddInterface(base::BindRepeating(
+      &media::CreateApplicationSessionIdManager, render_frame_host,
+      std::move(application_session_id)));
 }
 
 void CastContentBrowserClient::RegisterInProcessServices(

chromecast/media/service/cast_mojo_media_client.cc

@@ -38,12 +38,14 @@ void CastMojoMediaClient::Initialize(service_manager::Connector* connector) {
 }
 
 std::unique_ptr<::media::Renderer> CastMojoMediaClient::CreateRenderer(
+    service_manager::mojom::InterfaceProvider* host_interfaces,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     ::media::MediaLog* /* media_log */,
     const std::string& audio_device_id) {
   return std::make_unique<CastRenderer>(
       backend_factory_, task_runner, audio_device_id, video_mode_switcher_,
-      video_resolution_policy_, media_resource_tracker_, connector_);
+      video_resolution_policy_, media_resource_tracker_, connector_,
+      host_interfaces);
 }
 
 std::unique_ptr<::media::CdmFactory> CastMojoMediaClient::CreateCdmFactory(

chromecast/media/service/cast_mojo_media_client.h

@@ -33,6 +33,7 @@ class CastMojoMediaClient : public ::media::MojoMediaClient {
   // MojoMediaClient overrides.
   void Initialize(service_manager::Connector* connector) override;
   std::unique_ptr<::media::Renderer> CreateRenderer(
+      service_manager::mojom::InterfaceProvider* host_interfaces,
       scoped_refptr<base::SingleThreadTaskRunner> task_runner,
       ::media::MediaLog* media_log,
       const std::string& audio_device_id) override;

chromecast/media/service/cast_renderer.cc

@@ -28,7 +28,9 @@
 #include "media/base/media_log.h"
 #include "media/base/media_resource.h"
 #include "media/base/renderer_client.h"
+#include "services/service_manager/public/cpp/connect.h"
 #include "services/service_manager/public/cpp/connector.h"
+#include "services/service_manager/public/mojom/interface_provider.mojom.h"
 
 namespace chromecast {
 namespace media {
@@ -57,7 +59,8 @@ CastRenderer::CastRenderer(
     VideoModeSwitcher* video_mode_switcher,
     VideoResolutionPolicy* video_resolution_policy,
     MediaResourceTracker* media_resource_tracker,
-    service_manager::Connector* connector)
+    service_manager::Connector* connector,
+    service_manager::mojom::InterfaceProvider* host_interfaces)
     : backend_factory_(backend_factory),
       task_runner_(task_runner),
       audio_device_id_(audio_device_id.empty()
@@ -67,6 +70,7 @@ CastRenderer::CastRenderer(
       video_resolution_policy_(video_resolution_policy),
       media_resource_tracker_(media_resource_tracker),
       connector_(connector),
+      host_interfaces_(host_interfaces),
       client_(nullptr),
       cast_cdm_context_(nullptr),
       media_task_runner_factory_(
@@ -92,7 +96,36 @@ void CastRenderer::Initialize(::media::MediaResource* media_resource,
                               const ::media::PipelineStatusCB& init_cb) {
   CMALOG(kLogControl) << __FUNCTION__ << ": " << this;
   DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(!application_session_id_manager_ptr_);
 
+  // Retrieve application_session_id if it is available via
+  // ApplicationSessionIdManager.
+
+  // If a CastRenderer is created for a purpose other than a web application,
+  // the ApplicationSessionIdManager interface is not available, and application
+  // session ID will be an empty string.
+
+  if (host_interfaces_) {
+    service_manager::GetInterface<::media::mojom::ApplicationSessionIdManager>(
+        host_interfaces_, &application_session_id_manager_ptr_);
+  }
+
+  if (application_session_id_manager_ptr_) {
+    application_session_id_manager_ptr_->GetApplicationSessionId(base::BindOnce(
+        &CastRenderer::OnApplicationSessionIdReceived,
+        weak_factory_.GetWeakPtr(), media_resource, client, init_cb));
+  } else {
+    OnApplicationSessionIdReceived(media_resource, client, init_cb,
+                                   std::string());
+  }
+}
+
+void CastRenderer::OnApplicationSessionIdReceived(
+    ::media::MediaResource* media_resource,
+    ::media::RendererClient* client,
+    const ::media::PipelineStatusCB& init_cb,
+    const std::string& application_session_id) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
   // Create pipeline backend.
   media_resource_usage_.reset(
       new MediaResourceTracker::ScopedUsage(media_resource_tracker_));

chromecast/media/service/cast_renderer.h

@@ -13,6 +13,7 @@
 #include "chromecast/media/base/video_resolution_policy.h"
 #include "chromecast/media/cma/backend/cma_backend_factory.h"
 #include "media/base/renderer.h"
+#include "media/mojo/interfaces/application_session_id_manager.mojom.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace base {
@@ -21,6 +22,9 @@ class SingleThreadTaskRunner;
 
 namespace service_manager {
 class Connector;
+namespace mojom {
+class InterfaceProvider;
+}  // namespace mojom
 }  // namespace service_manager
 
 namespace chromecast {
@@ -35,13 +39,16 @@ class VideoModeSwitcher;
 class CastRenderer : public ::media::Renderer,
                      public VideoResolutionPolicy::Observer {
  public:
+  // |connector| provides interfaces for services hosted by ServiceManager.
+  // |host_interfaces| provides interfaces tied to RenderFrameHost.
   CastRenderer(CmaBackendFactory* backend_factory,
                const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
                const std::string& audio_device_id,
                VideoModeSwitcher* video_mode_switcher,
                VideoResolutionPolicy* video_resolution_policy,
                MediaResourceTracker* media_resource_tracker,
-               service_manager::Connector* connector);
+               service_manager::Connector* connector,
+               service_manager::mojom::InterfaceProvider* host_interfaces);
   ~CastRenderer() final;
 
   // ::media::Renderer implementation.
@@ -61,6 +68,11 @@ class CastRenderer : public ::media::Renderer,
 
  private:
   enum Stream { STREAM_AUDIO, STREAM_VIDEO };
+  void OnApplicationSessionIdReceived(
+      ::media::MediaResource* media_resource,
+      ::media::RendererClient* client,
+      const ::media::PipelineStatusCB& init_cb,
+      const std::string& application_session_id);
   void OnError(::media::PipelineStatus status);
   void OnEnded(Stream stream);
   void OnStatisticsUpdate(const ::media::PipelineStatistics& stats);
@@ -80,6 +92,7 @@ class CastRenderer : public ::media::Renderer,
   VideoResolutionPolicy* video_resolution_policy_;
   MediaResourceTracker* media_resource_tracker_;
   service_manager::Connector* connector_;
+  service_manager::mojom::InterfaceProvider* host_interfaces_;
   // Must outlive |pipeline_| to properly count resource usage.
   std::unique_ptr<MediaResourceTracker::ScopedUsage> media_resource_usage_;
 
@@ -91,6 +104,9 @@ class CastRenderer : public ::media::Renderer,
   bool eos_[2];
   gfx::Size video_res_;
 
+  ::media::mojom::ApplicationSessionIdManagerPtr
+      application_session_id_manager_ptr_;
+
   base::WeakPtrFactory<CastRenderer> weak_factory_;
   DISALLOW_COPY_AND_ASSIGN(CastRenderer);
 };

media/mojo/interfaces/BUILD.gn

@@ -47,6 +47,10 @@ mojom("interfaces") {
     ]
   }
 
+  if (is_chromecast) {
+    sources += [ "application_session_id_manager.mojom" ]
+  }
+
   public_deps = [
     "//gpu/ipc/common:interfaces",
     "//mojo/public/mojom/base",

media/mojo/interfaces/application_session_id_manager.mojom

+// Copyright 2018 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.
+
+module media.mojom;
+
+// This is a service attached to RenderFrameHost.
+// This is only used for Chromecast.
+interface ApplicationSessionIdManager {
+  // Returns the |application_session_id| associated with the
+  // RenderFrameHost.
+  GetApplicationSessionId() => (string application_session_id);
+};
\ No newline at end of file

media/mojo/services/interface_factory_impl.cc

@@ -116,7 +116,8 @@ void InterfaceFactoryImpl::CreateRenderer(
   // audio device ID. See interface_factory.mojom.
   const std::string& audio_device_id = type_specific_id;
   auto renderer = mojo_media_client_->CreateRenderer(
-      base::ThreadTaskRunnerHandle::Get(), media_log_, audio_device_id);
+      interfaces_.get(), base::ThreadTaskRunnerHandle::Get(), media_log_,
+      audio_device_id);
   if (!renderer) {
     DLOG(ERROR) << "Renderer creation failed.";
     return;

media/mojo/services/mojo_media_client.cc

@@ -38,6 +38,7 @@ std::unique_ptr<VideoDecoder> MojoMediaClient::CreateVideoDecoder(
 }
 
 std::unique_ptr<Renderer> MojoMediaClient::CreateRenderer(
+    service_manager::mojom::InterfaceProvider* host_interfaces,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     MediaLog* media_log,
     const std::string& audio_device_id) {

media/mojo/services/mojo_media_client.h

@@ -64,6 +64,7 @@ class MEDIA_MOJO_EXPORT MojoMediaClient {
   // Returns the Renderer to be used by MojoRendererService.
   // TODO(hubbe): Find out whether we should pass in |target_color_space| here.
   virtual std::unique_ptr<Renderer> CreateRenderer(
+      service_manager::mojom::InterfaceProvider* host_interfaces,
       scoped_refptr<base::SingleThreadTaskRunner> task_runner,
       MediaLog* media_log,
       const std::string& audio_device_id);

media/mojo/services/test_mojo_media_client.cc

@@ -57,6 +57,7 @@ void TestMojoMediaClient::Initialize(
 }
 
 std::unique_ptr<Renderer> TestMojoMediaClient::CreateRenderer(
+    service_manager::mojom::InterfaceProvider* host_interfaces,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     MediaLog* media_log,
     const std::string& /* audio_device_id */) {

media/mojo/services/test_mojo_media_client.h

@@ -30,6 +30,7 @@ class TestMojoMediaClient : public MojoMediaClient {
   // MojoMediaClient implementation.
   void Initialize(service_manager::Connector* connector) final;
   std::unique_ptr<Renderer> CreateRenderer(
+      service_manager::mojom::InterfaceProvider* host_interfaces,
       scoped_refptr<base::SingleThreadTaskRunner> task_runner,
       MediaLog* media_log,
       const std::string& audio_device_id) final;