[Audio Focus] Add an ArcMediaSession bridge

Add an ArcMediaSession bridge that will send an
AudioFocusManager mojo pointer to Android. This
will allow us to access the media session service
in Chrome from Android and in the future allow us
to delegate audio focus requests.

BUG=883958

Change-Id: I5a00e93ce1a1e4608d3f934522188b6252906cd2
Reviewed-on: https://chromium-review.googlesource.com/c/1225607Reviewed-by: John Abd-El-Malek <jam@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Reviewed-by: Hidehiko Abe <hidehiko@chromium.org>
Commit-Queue: Becca Hughes <beccahughes@chromium.org>
Cr-Commit-Position: refs/heads/master@{#597191}

chrome/browser/chromeos/BUILD.gn

@@ -103,6 +103,7 @@ source_set("chromeos") {
     "//chromeos/services/secure_channel/public/cpp/client",
     "//components/arc",
     "//components/arc/common:struct_traits",
+    "//components/arc/media_session",
     "//components/browser_sync",
     "//components/captive_portal",
     "//components/component_updater:crl_set_remover",

chrome/browser/chromeos/arc/arc_service_launcher.cc

@@ -56,6 +56,7 @@
 #include "components/arc/ime/arc_ime_service.h"
 #include "components/arc/intent_helper/arc_intent_helper_bridge.h"
 #include "components/arc/lock_screen/arc_lock_screen_bridge.h"
+#include "components/arc/media_session/arc_media_session_bridge.h"
 #include "components/arc/metrics/arc_metrics_service.h"
 #include "components/arc/midis/arc_midis_bridge.h"
 #include "components/arc/net/arc_net_host_impl.h"
@@ -171,6 +172,7 @@ void ArcServiceLauncher::OnPrimaryUserProfilePrepared(Profile* profile) {
   ArcIntentHelperBridge::GetForBrowserContext(profile);
   ArcKioskBridge::GetForBrowserContext(profile);
   ArcLockScreenBridge::GetForBrowserContext(profile);
+  ArcMediaSessionBridge::GetForBrowserContext(profile);
   ArcMetricsService::GetForBrowserContext(profile);
   ArcMidisBridge::GetForBrowserContext(profile);
   ArcNetHostImpl::GetForBrowserContext(profile)->SetPrefService(

components/arc/arc_bridge_host_impl.cc

@@ -143,6 +143,12 @@ void ArcBridgeHostImpl::OnLockScreenInstanceReady(
                   std::move(lock_screen_ptr));
 }
 
+void ArcBridgeHostImpl::OnMediaSessionInstanceReady(
+    mojom::MediaSessionInstancePtr media_session_ptr) {
+  OnInstanceReady(arc_bridge_service_->media_session(),
+                  std::move(media_session_ptr));
+}
+
 void ArcBridgeHostImpl::OnMetricsInstanceReady(
     mojom::MetricsInstancePtr metrics_ptr) {
   OnInstanceReady(arc_bridge_service_->metrics(), std::move(metrics_ptr));

components/arc/arc_bridge_host_impl.h

@@ -70,6 +70,8 @@ class ArcBridgeHostImpl : public mojom::ArcBridgeHost {
   void OnKioskInstanceReady(mojom::KioskInstancePtr kiosk_ptr) override;
   void OnLockScreenInstanceReady(
       mojom::LockScreenInstancePtr lock_screen_ptr) override;
+  void OnMediaSessionInstanceReady(
+      mojom::MediaSessionInstancePtr media_session_ptr) override;
   void OnMetricsInstanceReady(mojom::MetricsInstancePtr metrics_ptr) override;
   void OnMidisInstanceReady(mojom::MidisInstancePtr midis_ptr) override;
   void OnNetInstanceReady(mojom::NetInstancePtr net_ptr) override;

components/arc/arc_bridge_service.h

@@ -51,6 +51,7 @@ class IntentHelperInstance;
 class KioskHost;
 class KioskInstance;
 class LockScreenInstance;
+class MediaSessionInstance;
 class MetricsHost;
 class MetricsInstance;
 class MidisHost;
@@ -175,6 +176,9 @@ class ArcBridgeService {
   ConnectionHolder<mojom::LockScreenInstance>* lock_screen() {
     return &lock_screen_;
   }
+  ConnectionHolder<mojom::MediaSessionInstance>* media_session() {
+    return &media_session_;
+  }
   ConnectionHolder<mojom::MetricsInstance, mojom::MetricsHost>* metrics() {
     return &metrics_;
   }
@@ -276,6 +280,7 @@ class ArcBridgeService {
       intent_helper_;
   ConnectionHolder<mojom::KioskInstance, mojom::KioskHost> kiosk_;
   ConnectionHolder<mojom::LockScreenInstance> lock_screen_;
+  ConnectionHolder<mojom::MediaSessionInstance> media_session_;
   ConnectionHolder<mojom::MetricsInstance, mojom::MetricsHost> metrics_;
   ConnectionHolder<mojom::MidisInstance, mojom::MidisHost> midis_;
   ConnectionHolder<mojom::NetInstance, mojom::NetHost> net_;

components/arc/arc_features.cc

@@ -35,6 +35,10 @@ const base::Feature kEnableInputMethodFeature{
 const base::Feature kEnableRegularToChildTransitionFeature{
     "ArcEnableRegularToChildTransition", base::FEATURE_ENABLED_BY_DEFAULT};
 
+// Controls whether we should delegate audio focus requests from ARC to Chrome.
+const base::Feature kEnableUnifiedAudioFocusFeature{
+    "ArcEnableUnifiedAudioFocus", base::FEATURE_DISABLED_BY_DEFAULT};
+
 // Controls experimental native bridge feature for ARC.
 const base::Feature kNativeBridgeExperimentFeature {
     "ArcNativeBridgeExperiment", base::FEATURE_ENABLED_BY_DEFAULT

components/arc/arc_features.h

@@ -18,6 +18,7 @@ extern const base::Feature kCleanArcDataOnRegularToChildTransitionFeature;
 extern const base::Feature kEnableChildToRegularTransitionFeature;
 extern const base::Feature kEnableInputMethodFeature;
 extern const base::Feature kEnableRegularToChildTransitionFeature;
+extern const base::Feature kEnableUnifiedAudioFocusFeature;
 extern const base::Feature kNativeBridgeExperimentFeature;
 extern const base::Feature kSmartTextSelectionFeature;
 extern const base::Feature kUsbHostFeature;

components/arc/common/BUILD.gn

@@ -33,6 +33,7 @@ if (is_chromeos) {
       "intent_helper.mojom",
       "kiosk.mojom",
       "lock_screen.mojom",
+      "media_session.mojom",
       "metrics.mojom",
       "midis.mojom",
       "net.mojom",
@@ -65,6 +66,7 @@ if (is_chromeos) {
       ":notifications",
       "//device/usb/public/mojom",
       "//mojo/public/mojom/base",
+      "//services/media_session/public/mojom",
       "//ui/accessibility/mojom",
       "//ui/gfx/geometry/mojo",
       "//url/mojom:url_mojom_gurl",

components/arc/common/arc_bridge.mojom

@@ -24,6 +24,7 @@ import "components/arc/common/input_method_manager.mojom";
 import "components/arc/common/intent_helper.mojom";
 import "components/arc/common/kiosk.mojom";
 import "components/arc/common/lock_screen.mojom";
+import "components/arc/common/media_session.mojom";
 import "components/arc/common/metrics.mojom";
 import "components/arc/common/midis.mojom";
 import "components/arc/common/net.mojom";
@@ -50,9 +51,9 @@ import "components/arc/common/volume_mounter.mojom";
 import "components/arc/common/wake_lock.mojom";
 import "components/arc/common/wallpaper.mojom";
 
-// Next MinVersion: 43
+// Next MinVersion: 44
 // Deprecated method IDs: 101, 105
-// Next method ID: 148
+// Next method ID: 149
 interface ArcBridgeHost {
   // Keep the entries alphabetical. In order to do so without breaking
   // compatibility with the ARC instance, explicitly assign each interface a
@@ -127,6 +128,9 @@ interface ArcBridgeHost {
   // Notifies Chrome that the LockScreenInstance interface is ready.
   [MinVersion=29] OnLockScreenInstanceReady@134(LockScreenInstance instance_ptr);
 
+  // Notifies Chrome that the MediaSessionInstance interface is ready.
+  [MinVersion=43] OnMediaSessionInstanceReady@148(MediaSessionInstance instance_ptr);
+
   // Notifies Chrome that the MetricsInstance interface is ready.
   [MinVersion=10] OnMetricsInstanceReady@116(MetricsInstance instance_ptr);
 

components/arc/common/media_session.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.
+
+// Next MinVersion: 1
+
+module arc.mojom;
+
+import "services/media_session/public/mojom/audio_focus.mojom";
+
+// Next method ID: 3
+interface MediaSessionInstance {
+  // Enable audio focus integration on the Android side and register the
+  // unified AudioPolicy. The audio policy will send audio focus requests
+  // to |service|.
+  EnableAudioFocus@1(media_session.mojom.AudioFocusManager service);
+
+  // Disable audio focus integration if it is enabled.
+  DisableAudioFocus@2();
+};

components/arc/media_session/BUILD.gn

+# 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.
+
+static_library("media_session") {
+  sources = [
+    "arc_media_session_bridge.cc",
+    "arc_media_session_bridge.h",
+  ]
+
+  deps = [
+    "//components/arc:arc_base",
+    "//components/keyed_service/content",
+    "//content/public/common",
+    "//services/media_session/public/cpp",
+    "//services/media_session/public/mojom",
+  ]
+}

components/arc/media_session/DEPS

+include_rules = [
+  "+content/public/common/service_manager_connection.h",
+  "+services/media_session/public",
+  "+services/service_manager/public/cpp/connector.h",
+]

components/arc/media_session/OWNERS

+file://services/media_session/OWNERS
+
+# COMPONENT: Internals>Media>Session

components/arc/media_session/arc_media_session_bridge.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 "components/arc/media_session/arc_media_session_bridge.h"
+
+#include "base/feature_list.h"
+#include "base/logging.h"
+#include "base/no_destructor.h"
+#include "components/arc/arc_bridge_service.h"
+#include "components/arc/arc_browser_context_keyed_service_factory_base.h"
+#include "components/arc/arc_features.h"
+#include "content/public/common/service_manager_connection.h"
+#include "services/media_session/public/cpp/switches.h"
+#include "services/media_session/public/mojom/audio_focus.mojom.h"
+#include "services/media_session/public/mojom/constants.mojom.h"
+#include "services/service_manager/public/cpp/connector.h"
+
+namespace arc {
+namespace {
+
+// Singleton factory for ArcAccessibilityHelperBridge.
+class ArcMediaSessionBridgeFactory
+    : public internal::ArcBrowserContextKeyedServiceFactoryBase<
+          ArcMediaSessionBridge,
+          ArcMediaSessionBridgeFactory> {
+ public:
+  // Factory name used by ArcBrowserContextKeyedServiceFactoryBase.
+  static constexpr const char* kName = "ArcMediaSessionBridgeFactory";
+
+  static ArcMediaSessionBridgeFactory* GetInstance() {
+    static base::NoDestructor<ArcMediaSessionBridgeFactory> factory;
+    return factory.get();
+  }
+
+  ArcMediaSessionBridgeFactory() = default;
+  ~ArcMediaSessionBridgeFactory() override = default;
+};
+
+bool IsArcUnifiedAudioFocusEnabled() {
+  return media_session::IsAudioFocusEnabled() &&
+         base::FeatureList::IsEnabled(kEnableUnifiedAudioFocusFeature);
+}
+
+}  // namespace
+
+// static
+ArcMediaSessionBridge* ArcMediaSessionBridge::GetForBrowserContext(
+    content::BrowserContext* context) {
+  return ArcMediaSessionBridgeFactory::GetForBrowserContext(context);
+}
+
+ArcMediaSessionBridge::ArcMediaSessionBridge(content::BrowserContext* context,
+                                             ArcBridgeService* bridge_service)
+    : arc_bridge_service_(bridge_service) {
+  arc_bridge_service_->media_session()->AddObserver(this);
+}
+
+ArcMediaSessionBridge::~ArcMediaSessionBridge() {
+  arc_bridge_service_->media_session()->RemoveObserver(this);
+}
+
+void ArcMediaSessionBridge::OnConnectionReady() {
+  DVLOG(2) << "ArcMediaSessionBridge::OnConnectionReady";
+  SetupAudioFocus();
+}
+
+void ArcMediaSessionBridge::OnConnectionClosed() {
+  DVLOG(2) << "ArcMediaSessionBridge::OnConnectionClosed";
+}
+
+void ArcMediaSessionBridge::SetupAudioFocus() {
+  DVLOG(2) << "ArcMediaSessionBridge::SetupAudioFocus";
+  mojom::MediaSessionInstance* ms_instance = ARC_GET_INSTANCE_FOR_METHOD(
+      arc_bridge_service_->media_session(), DisableAudioFocus);
+  if (!ms_instance)
+    return;
+
+  if (!IsArcUnifiedAudioFocusEnabled()) {
+    DVLOG(2) << "ArcMediaSessionBridge will disable audio focus";
+    ms_instance->DisableAudioFocus();
+    return;
+  }
+
+  media_session::mojom::AudioFocusManagerPtr audio_focus_ptr;
+  content::ServiceManagerConnection::GetForProcess()
+      ->GetConnector()
+      ->BindInterface(media_session::mojom::kServiceName, &audio_focus_ptr);
+
+  DVLOG(2) << "ArcMediaSessionBridge will enable audio focus";
+  ms_instance->EnableAudioFocus(std::move(audio_focus_ptr));
+}
+
+}  // namespace arc

components/arc/media_session/arc_media_session_bridge.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 COMPONENTS_ARC_MEDIA_SESSION_ARC_MEDIA_SESSION_BRIDGE_H_
+#define COMPONENTS_ARC_MEDIA_SESSION_ARC_MEDIA_SESSION_BRIDGE_H_
+
+#include <string>
+
+#include "base/macros.h"
+#include "components/arc/common/media_session.mojom.h"
+#include "components/arc/connection_observer.h"
+#include "components/keyed_service/core/keyed_service.h"
+
+namespace content {
+class BrowserContext;
+}  // namespace content
+
+namespace arc {
+
+class ArcBridgeService;
+
+// ArcMediaSessionBridge exposes the media session service to ARC. This allows
+// Android apps to request and manage audio focus using the internal Chrome
+// API. This means that audio focus management is unified across both Android
+// and Chrome.
+class ArcMediaSessionBridge
+    : public KeyedService,
+      public ConnectionObserver<mojom::MediaSessionInstance> {
+ public:
+  // Returns singleton instance for the given BrowserContext,
+  // or nullptr if the browser |context| is not allowed to use ARC.
+  static ArcMediaSessionBridge* GetForBrowserContext(
+      content::BrowserContext* context);
+
+  ArcMediaSessionBridge(content::BrowserContext* context,
+                        ArcBridgeService* bridge_service);
+  ~ArcMediaSessionBridge() override;
+
+  // ConnectionObserver<mojom::MediaSessionInstance> overrides.
+  void OnConnectionReady() override;
+  void OnConnectionClosed() override;
+
+ private:
+  void SetupAudioFocus();
+
+  ArcBridgeService* const arc_bridge_service_;  // Owned by ArcServiceManager.
+
+  DISALLOW_COPY_AND_ASSIGN(ArcMediaSessionBridge);
+};
+
+}  // namespace arc
+
+#endif  // COMPONENTS_ARC_MEDIA_SESSION_ARC_MEDIA_SESSION_BRIDGE_H_

components/arc/test/fake_arc_bridge_host.cc

@@ -67,6 +67,9 @@ void FakeArcBridgeHost::OnKioskInstanceReady(
 void FakeArcBridgeHost::OnLockScreenInstanceReady(
     mojom::LockScreenInstancePtr lock_screen_ptr) {}
 
+void FakeArcBridgeHost::OnMediaSessionInstanceReady(
+    mojom::MediaSessionInstancePtr media_sesssion_ptr) {}
+
 void FakeArcBridgeHost::OnMetricsInstanceReady(
     mojom::MetricsInstancePtr metrics_ptr) {}
 

components/arc/test/fake_arc_bridge_host.h

@@ -50,6 +50,8 @@ class FakeArcBridgeHost : public mojom::ArcBridgeHost {
   void OnKioskInstanceReady(mojom::KioskInstancePtr kiosk_ptr) override;
   void OnLockScreenInstanceReady(
       mojom::LockScreenInstancePtr lock_screen_ptr) override;
+  void OnMediaSessionInstanceReady(
+      mojom::MediaSessionInstancePtr media_session_ptr) override;
   void OnMetricsInstanceReady(mojom::MetricsInstancePtr metrics_ptr) override;
   void OnMidisInstanceReady(mojom::MidisInstancePtr midis_ptr) override;
   void OnNetInstanceReady(mojom::NetInstancePtr net_ptr) override;

services/media_session/public/mojom/audio_focus.mojom

@@ -6,7 +6,10 @@ module media_session.mojom;
 
 import "services/media_session/public/mojom/media_session.mojom";
 
+// Next MinVersion: 1
+
 // These are the different types of audio focus that can be requested.
+[Extensible]
 enum AudioFocusType {
   // Request permanent audio focus when you plan to play audio for the
   // foreseeable future (for example, when playing music) and you expect the
@@ -32,47 +35,50 @@ struct AudioFocusRequestState {
 };
 
 // The observer for audio focus events.
+// Next Method ID: 2
 interface AudioFocusObserver {
   // The given |session| gained audio focus with the specified |type|.
-  OnFocusGained(MediaSessionInfo session, AudioFocusType type);
+  OnFocusGained@0(MediaSessionInfo session, AudioFocusType type);
 
   // The given |session| lost audio focus.
-  OnFocusLost(MediaSessionInfo session);
+  OnFocusLost@1(MediaSessionInfo session);
 };
 
 // Controls audio focus for an associated request.
+// Next Method ID: 4
 interface AudioFocusRequestClient {
   // Requests updated audio focus for this request. If the request was granted
   // then the callback will resolve.
-  RequestAudioFocus(MediaSessionInfo session_info, AudioFocusType type) => ();
+  RequestAudioFocus@0(MediaSessionInfo session_info, AudioFocusType type) => ();
 
   // Abandons audio focus for this request.
-  AbandonAudioFocus();
+  AbandonAudioFocus@1();
 
   // Notifies the audio focus backend when the associated session info changes.
-  MediaSessionInfoChanged(MediaSessionInfo session_info);
+  MediaSessionInfoChanged@2(MediaSessionInfo session_info);
 
   // Retrieve a unique ID for this request.
-  GetRequestId() => (uint64 request_id);
+  GetRequestId@3() => (uint64 request_id);
 };
 
 // Controls audio focus across the entire system.
+// Next Method ID: 3
 interface AudioFocusManager {
   // Requests audio focus with |type| for the |media_session| with
   // |session_info|. Media sessions should provide a |request| that will
   // provide an AudioFocusRequestClient that can be used to control this
   // request. The callback will resolve when audio focus has been granted.
-  RequestAudioFocus(AudioFocusRequestClient& client,
+  RequestAudioFocus@0(AudioFocusRequestClient& client,
                     MediaSession media_session,
                     MediaSessionInfo session_info,
                     AudioFocusType type) => ();
 
   // Gets all the information about all |MediaSessions| that have requested
   // audio focus and their current requested type.
-  GetFocusRequests() => (array<AudioFocusRequestState> requests);
+  GetFocusRequests@1() => (array<AudioFocusRequestState> requests);
 
   // Adds observers that receive audio focus events.
-  AddObserver(AudioFocusObserver observer);
+  AddObserver@2(AudioFocusObserver observer);
 };
 
 // Provides debug information about audio focus requests.

services/media_session/public/mojom/media_session.mojom

@@ -4,8 +4,11 @@
 
 module media_session.mojom;
 
+// Next MinVersion: 1
+
 // Contains state information about a MediaSession.
 struct MediaSessionInfo {
+  [Extensible]
   enum SessionState {
     // The MediaSession is currently playing media.
     kActive,
@@ -41,16 +44,19 @@ struct MediaSessionDebugInfo {
 };
 
 // The observer for observing media session events.
+// Next Method ID: 1
 interface MediaSessionObserver {
   // The info associated with the session changed.
-  MediaSessionInfoChanged(MediaSessionInfo info);
+  MediaSessionInfoChanged@0(MediaSessionInfo info);
 };
 
 // A MediaSession manages the media session and audio focus for a given
 // WebContents or ARC app.
 // TODO(https://crbug.com/875004): migrate media session from content/public
 // to mojo.
+// Next Method ID: 6
 interface MediaSession {
+  [Extensible]
   enum SuspendType {
     // Suspended by the system because a transient sound needs to be played.
     kSystem,
@@ -61,26 +67,26 @@ interface MediaSession {
   };
 
   // Returns information about the MediaSession.
-  GetMediaSessionInfo() => (MediaSessionInfo info);
+  GetMediaSessionInfo@0() => (MediaSessionInfo info);
 
   // Returns debug information about the MediaSession.
-  GetDebugInfo() => (MediaSessionDebugInfo info);
+  GetDebugInfo@1() => (MediaSessionDebugInfo info);
 
   // Let the media session start ducking such that the volume multiplier
   // is reduced.
-  StartDucking();
+  StartDucking@2();
 
   // Let the media session stop ducking such that the volume multiplier is
   // recovered.
-  StopDucking();
+  StopDucking@3();
 
   // Suspend the media session.
   // |type| represents the origin of the request.
-  Suspend(SuspendType suspend_type);
+  Suspend@4(SuspendType suspend_type);
 
   // Resume the media session.
   // |type| represents the origin of the request.
-  Resume(SuspendType suspend_type);
+  Resume@5(SuspendType suspend_type);
 
-  AddObserver(MediaSessionObserver observer);
+  AddObserver@6(MediaSessionObserver observer);
 };