Allow MediaSession in iframes to be routed

This CL allows MediaSession in iframes to be routed, as per spec change:
https://github.com/WICG/mediasession/pull/149

To achieve this goal, class MediaSessionServiceRouter is added for selecting
which MediaSession object to route.

The current MediaSessionService routing strategy is:

* If the top-level frame uses MediaSession API, always select the
  top-level session.
* If the top-level frame has no MediaSession, select one of an
  audio-producing frame, and route its session (or null if the frame
  does not use MediaSession API).

CL explanation:
https://docs.google.com/a/google.com/document/d/1Ht6DxjOcfBctfRT3_wOkwGoNUaJY-Q8K18MV3xdAh_8/edit?usp=sharing

BUG=670319

Review-Url: https://codereview.chromium.org/2526533002
Cr-Commit-Position: refs/heads/master@{#436266}

chrome/android/java/src/org/chromium/chrome/browser/media/ui/MediaSessionTabHelper.java

@@ -30,7 +30,6 @@ import org.chromium.ui.base.WindowAndroid;
 
 import java.net.URI;
 import java.net.URISyntaxException;
-import java.util.HashSet;
 import java.util.Set;
 
 import javax.annotation.Nullable;
@@ -61,7 +60,7 @@ public class MediaSessionTabHelper implements MediaImageCallback {
     // The currently showing metadata.
     private MediaMetadata mCurrentMetadata = null;
     private MediaImageManager mMediaImageManager = null;
-    private Set<Integer> mMediaSessionActions = new HashSet<Integer>();
+    private Set<Integer> mMediaSessionActions = null;
     private Handler mHandler;
     // The delayed task to hide notification. Hiding notification can be immediate or delayed.
     // Delayed hiding will schedule this delayed task to |mHandler|. The task will be canceled when
@@ -228,16 +227,8 @@ public class MediaSessionTabHelper implements MediaImageCallback {
             }
 
             @Override
-            public void mediaSessionEnabledAction(int action) {
-                if (!MediaSessionAction.isKnownValue(action)) return;
-                mMediaSessionActions.add(action);
-                updateNotificationActions();
-            }
-
-            @Override
-            public void mediaSessionDisabledAction(int action) {
-                if (!MediaSessionAction.isKnownValue(action)) return;
-                mMediaSessionActions.remove(action);
+            public void mediaSessionActionsChanged(Set<Integer> actions) {
+                mMediaSessionActions = actions;
                 updateNotificationActions();
             }
         };
@@ -261,7 +252,7 @@ public class MediaSessionTabHelper implements MediaImageCallback {
         if (mMediaSessionObserver == null) return;
         mMediaSessionObserver.stopObserving();
         mMediaSessionObserver = null;
-        mMediaSessionActions.clear();
+        mMediaSessionActions = null;
     }
 
     private final TabObserver mTabObserver = new EmptyTabObserver() {

content/browser/media/session/audio_focus_manager_unittest.cc

@@ -24,6 +24,7 @@ class MockMediaSessionPlayerObserver : public MediaSessionPlayerObserver {
   void OnResume(int player_id) override {}
   void OnSetVolumeMultiplier(
       int player_id, double volume_multiplier) override {}
+  RenderFrameHost* GetRenderFrameHost() const override { return nullptr; }
 };
 
 }  // anonymous namespace

content/browser/media/session/media_session_android.cc

@@ -4,7 +4,7 @@
 
 #include "content/browser/media/session/media_session_android.h"
 
-#include <algorithm>
+#include "base/android/jni_array.h"
 #include "content/browser/media/session/media_session_impl.h"
 #include "content/browser/web_contents/web_contents_android.h"
 #include "content/browser/web_contents/web_contents_impl.h"
@@ -103,26 +103,19 @@ void MediaSessionAndroid::MediaSessionMetadataChanged(
                                                     j_metadata);
 }
 
-void MediaSessionAndroid::MediaSessionEnabledAction(
-    blink::mojom::MediaSessionAction action) {
+void MediaSessionAndroid::MediaSessionActionsChanged(
+    const std::set<blink::mojom::MediaSessionAction>& actions) {
   ScopedJavaLocalRef<jobject> j_local_session = GetJavaObject();
   if (j_local_session.is_null())
     return;
 
-  JNIEnv* env = base::android::AttachCurrentThread();
-  Java_MediaSessionImpl_mediaSessionEnabledAction(env, j_local_session,
-                                                  static_cast<int>(action));
-}
-
-void MediaSessionAndroid::MediaSessionDisabledAction(
-    blink::mojom::MediaSessionAction action) {
-  ScopedJavaLocalRef<jobject> j_local_session = GetJavaObject();
-  if (j_local_session.is_null())
-    return;
+  std::vector<int> actions_vec;
+  for (auto action : actions)
+    actions_vec.push_back(static_cast<int>(action));
 
   JNIEnv* env = base::android::AttachCurrentThread();
-  Java_MediaSessionImpl_mediaSessionDisabledAction(env, j_local_session,
-                                                   static_cast<int>(action));
+  Java_MediaSessionImpl_mediaSessionActionsChanged(
+      env, j_local_session, base::android::ToJavaIntArray(env, actions_vec));
 }
 
 void MediaSessionAndroid::Resume(

content/browser/media/session/media_session_android.h

@@ -39,10 +39,8 @@ class MediaSessionAndroid final : public MediaSessionObserver {
                                 bool is_suspended) override;
   void MediaSessionMetadataChanged(
       const base::Optional<MediaMetadata>& metadata) override;
-  void MediaSessionEnabledAction(
-      blink::mojom::MediaSessionAction action) override;
-  void MediaSessionDisabledAction(
-      blink::mojom::MediaSessionAction action) override;
+  void MediaSessionActionsChanged(
+      const std::set<blink::mojom::MediaSessionAction>& actions) override;
 
   // MediaSession method wrappers.
   void Resume(JNIEnv* env, const base::android::JavaParamRef<jobject>& j_obj);

content/browser/media/session/media_session_controller.cc

@@ -95,6 +95,10 @@ void MediaSessionController::OnSetVolumeMultiplier(int player_id,
           id_.first->GetRoutingID(), id_.second, volume_multiplier));
 }
 
+RenderFrameHost* MediaSessionController::GetRenderFrameHost() const {
+  return id_.first;
+}
+
 void MediaSessionController::OnPlaybackPaused() {
   // We check for suspension here since the renderer may issue its own pause
   // in response to or while a pause from the browser is in flight.

content/browser/media/session/media_session_controller.h

@@ -50,6 +50,7 @@ class CONTENT_EXPORT MediaSessionController
   void OnSuspend(int player_id) override;
   void OnResume(int player_id) override;
   void OnSetVolumeMultiplier(int player_id, double volume_multiplier) override;
+  RenderFrameHost* GetRenderFrameHost() const override;
 
   // Test helpers.
   int get_player_id_for_testing() const { return player_id_; }

content/browser/media/session/media_session_impl.cc

@@ -6,6 +6,7 @@
 
 #include <algorithm>
 #include "content/browser/media/session/audio_focus_delegate.h"
+#include "content/browser/media/session/media_session_controller.h"
 #include "content/browser/media/session/media_session_player_observer.h"
 #include "content/browser/media/session/media_session_service_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
@@ -25,6 +26,26 @@ namespace {
 const double kDefaultVolumeMultiplier = 1.0;
 const double kDuckingVolumeMultiplier = 0.2;
 
+using MapRenderFrameHostToDepth = std::map<RenderFrameHost*, size_t>;
+
+size_t ComputeFrameDepth(RenderFrameHost* rfh,
+                         MapRenderFrameHostToDepth* map_rfh_to_depth) {
+  DCHECK(rfh);
+  size_t depth = 0;
+  RenderFrameHost* current_frame = rfh;
+  while (current_frame) {
+    auto it = map_rfh_to_depth->find(current_frame);
+    if (it != map_rfh_to_depth->end()) {
+      depth += it->second;
+      break;
+    }
+    ++depth;
+    current_frame = current_frame->GetParent();
+  }
+  (*map_rfh_to_depth)[rfh] = depth;
+  return depth;
+}
+
 }  // anonymous namespace
 
 using MediaSessionSuspendedSource =
@@ -89,11 +110,6 @@ void MediaSessionImpl::WebContentsDestroyed() {
   AbandonSystemAudioFocusIfNeeded();
 }
 
-void MediaSessionImpl::SetMediaSessionService(
-    MediaSessionServiceImpl* service) {
-  service_ = service;
-}
-
 void MediaSessionImpl::AddObserver(MediaSessionObserver* observer) {
   observers_.AddObserver(observer);
 }
@@ -102,13 +118,18 @@ void MediaSessionImpl::RemoveObserver(MediaSessionObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
-void MediaSessionImpl::SetMetadata(
+void MediaSessionImpl::NotifyMediaSessionMetadataChange(
     const base::Optional<MediaMetadata>& metadata) {
-  metadata_ = metadata;
   for (auto& observer : observers_)
     observer.MediaSessionMetadataChanged(metadata);
 }
 
+void MediaSessionImpl::NotifyMediaSessionActionsChange(
+    const std::set<blink::mojom::MediaSessionAction>& actions) {
+  for (auto& observer : observers_)
+    observer.MediaSessionActionsChanged(actions);
+}
+
 bool MediaSessionImpl::AddPlayer(MediaSessionPlayerObserver* observer,
                                  int player_id,
                                  media::MediaContentType media_content_type) {
@@ -150,8 +171,9 @@ bool MediaSessionImpl::AddPlayer(MediaSessionPlayerObserver* observer,
     normal_players_.clear();
 
   normal_players_.insert(PlayerIdentifier(observer, player_id));
-  NotifyAboutStateChange();
 
+  UpdateRoutedService();
+  NotifyAboutStateChange();
   return true;
 }
 
@@ -174,6 +196,7 @@ void MediaSessionImpl::RemovePlayer(MediaSessionPlayerObserver* observer,
     one_shot_players_.erase(it);
 
   AbandonSystemAudioFocusIfNeeded();
+  UpdateRoutedService();
 
   // The session may become controllable after removing a one-shot player.
   // However AbandonSystemAudioFocusIfNeeded will short-return and won't notify
@@ -207,6 +230,7 @@ void MediaSessionImpl::RemovePlayers(MediaSessionPlayerObserver* observer) {
   }
 
   AbandonSystemAudioFocusIfNeeded();
+  UpdateRoutedService();
 
   // The session may become controllable after removing a one-shot player.
   // However AbandonSystemAudioFocusIfNeeded will short-return and won't notify
@@ -299,24 +323,6 @@ void MediaSessionImpl::Stop(SuspendType suspend_type) {
   AbandonSystemAudioFocusIfNeeded();
 }
 
-void MediaSessionImpl::DidReceiveAction(
-    blink::mojom::MediaSessionAction action) {
-  if (service_)
-    service_->GetClient()->DidReceiveAction(action);
-}
-
-void MediaSessionImpl::OnMediaSessionEnabledAction(
-    blink::mojom::MediaSessionAction action) {
-  for (auto& observer : observers_)
-    observer.MediaSessionEnabledAction(action);
-}
-
-void MediaSessionImpl::OnMediaSessionDisabledAction(
-    blink::mojom::MediaSessionAction action) {
-  for (auto& observer : observers_)
-    observer.MediaSessionDisabledAction(action);
-}
-
 void MediaSessionImpl::StartDucking() {
   if (is_ducking_)
     return;
@@ -470,7 +476,7 @@ MediaSessionImpl::MediaSessionImpl(WebContents* web_contents)
       audio_focus_type_(
           AudioFocusManager::AudioFocusType::GainTransientMayDuck),
       is_ducking_(false),
-      service_(nullptr) {
+      routed_service_(nullptr) {
 #if defined(OS_ANDROID)
   session_android_.reset(new MediaSessionAndroid(this));
 #endif  // defined(OS_ANDROID)
@@ -552,4 +558,103 @@ bool MediaSessionImpl::AddOneShotPlayer(MediaSessionPlayerObserver* observer,
   return true;
 }
 
+// MediaSessionService-related methods
+
+void MediaSessionImpl::OnServiceCreated(MediaSessionServiceImpl* service) {
+  services_[service->GetRenderFrameHost()] = service;
+}
+
+void MediaSessionImpl::OnServiceDestroyed(MediaSessionServiceImpl* service) {
+  services_.erase(service->GetRenderFrameHost());
+}
+
+void MediaSessionImpl::OnMediaSessionMetadataChanged(
+    MediaSessionServiceImpl* service) {
+  if (service != routed_service_)
+    return;
+
+  NotifyMediaSessionMetadataChange(routed_service_->metadata());
+}
+
+void MediaSessionImpl::OnMediaSessionActionsChanged(
+    MediaSessionServiceImpl* service) {
+  if (service != routed_service_)
+    return;
+
+  NotifyMediaSessionActionsChange(routed_service_->actions());
+}
+
+void MediaSessionImpl::DidReceiveAction(
+    blink::mojom::MediaSessionAction action) {
+  if (!routed_service_)
+    return;
+
+  routed_service_->GetClient()->DidReceiveAction(action);
+}
+
+bool MediaSessionImpl::IsServiceActiveForRenderFrameHost(RenderFrameHost* rfh) {
+  if (!services_.count(rfh))
+    return false;
+
+  return services_[rfh]->metadata().has_value() ||
+         !services_[rfh]->actions().empty();
+}
+
+void MediaSessionImpl::UpdateRoutedService() {
+  MediaSessionServiceImpl* new_service = ComputeServiceForRouting();
+  if (new_service == routed_service_)
+    return;
+
+  routed_service_ = new_service;
+  if (routed_service_) {
+    NotifyMediaSessionMetadataChange(routed_service_->metadata());
+    NotifyMediaSessionActionsChange(routed_service_->actions());
+  } else {
+    NotifyMediaSessionMetadataChange(base::nullopt);
+    NotifyMediaSessionActionsChange(
+        std::set<blink::mojom::MediaSessionAction>());
+  }
+}
+
+MediaSessionServiceImpl* MediaSessionImpl::ComputeServiceForRouting() {
+  // The service selection strategy is: select a frame that has a playing/paused
+  // player and has a corresponding MediaSessionService and return the
+  // corresponding MediaSessionService. If multiple frames satisfy the criteria,
+  // prefer the top-most frame.
+  std::set<RenderFrameHost*> frames;
+  for (const auto& player : normal_players_) {
+    RenderFrameHost* frame = player.observer->GetRenderFrameHost();
+    if (frame)
+      frames.insert(frame);
+  }
+
+  for (const auto& player : one_shot_players_) {
+    RenderFrameHost* frame = player.observer->GetRenderFrameHost();
+    if (frame)
+      frames.insert(frame);
+  }
+
+  for (const auto& player : pepper_players_) {
+    RenderFrameHost* frame = player.observer->GetRenderFrameHost();
+    if (frame)
+      frames.insert(frame);
+  }
+
+  RenderFrameHost* best_frame = nullptr;
+  size_t min_depth = std::numeric_limits<size_t>::max();
+  std::map<RenderFrameHost*, size_t> map_rfh_to_depth;
+
+  for (RenderFrameHost* frame : frames) {
+    size_t depth = ComputeFrameDepth(frame, &map_rfh_to_depth);
+    if (depth >= min_depth)
+      continue;
+    if (!IsServiceActiveForRenderFrameHost(frame))
+      continue;
+    best_frame = frame;
+    min_depth = depth;
+  }
+
+  return best_frame ? services_[best_frame] : nullptr;
+}
+
 }  // namespace content

content/browser/media/session/media_session_impl.h

@@ -7,6 +7,9 @@
 
 #include <stddef.h>
 
+#include <map>
+#include <set>
+
 #include "base/callback_list.h"
 #include "base/id_map.h"
 #include "base/macros.h"
@@ -35,6 +38,7 @@ namespace content {
 
 class AudioFocusDelegate;
 class AudioFocusManagerTest;
+class MediaSessionImplServiceRoutingTest;
 class MediaSessionImplStateObserver;
 class MediaSessionImplVisibilityBrowserTest;
 class MediaSessionObserver;
@@ -84,8 +88,10 @@ class MediaSessionImpl : public MediaSession,
   void AddObserver(MediaSessionObserver* observer);
   void RemoveObserver(MediaSessionObserver* observer);
 
-  void SetMetadata(const base::Optional<MediaMetadata>& metadata);
-  const base::Optional<MediaMetadata>& metadata() const { return metadata_; }
+  void NotifyMediaSessionMetadataChange(
+      const base::Optional<MediaMetadata>& metadata);
+  void NotifyMediaSessionActionsChange(
+      const std::set<blink::mojom::MediaSessionAction>& actions);
 
   // Adds the given player to the current media session. Returns whether the
   // player was successfully added. If it returns false, AddPlayer() should be
@@ -124,17 +130,6 @@ class MediaSessionImpl : public MediaSession,
   // |type| represents the origin of the request.
   CONTENT_EXPORT void Stop(MediaSession::SuspendType suspend_type) override;
 
-  // Received a media session action and forward to blink::MediaSession.
-  void DidReceiveAction(blink::mojom::MediaSessionAction action) override;
-
-  // Called when an action is enabled in blink::MediaSession. This method will
-  // notify the observers that the action is enabled.
-  void OnMediaSessionEnabledAction(blink::mojom::MediaSessionAction action);
-
-  // Called when an action is disabled in blink::MediaSession. This method will
-  // notify the observers that the action is disabled.
-  void OnMediaSessionDisabledAction(blink::mojom::MediaSessionAction action);
-
   // Let the media session start ducking such that the volume multiplier is
   // reduced.
   CONTENT_EXPORT void StartDucking();
@@ -172,16 +167,32 @@ class MediaSessionImpl : public MediaSession,
   // WebContentsObserver implementation
   void WebContentsDestroyed() override;
 
-  // Sets the associated MediaSessionService for communicating with
-  // blink::MediaSession.
-  MediaSessionServiceImpl* GetMediaSessionService() { return service_; }
-  void SetMediaSessionService(MediaSessionServiceImpl* service);
+  // MediaSessionService-related methods
+
+  // Called when a MediaSessionService is created, which registers itself to
+  // this session.
+  void OnServiceCreated(MediaSessionServiceImpl* service);
+  // Called when a MediaSessionService is destroyed, which unregisters itself
+  // from this session.
+  void OnServiceDestroyed(MediaSessionServiceImpl* service);
+
+  // Called when the metadata of a MediaSessionService has changed. Will notify
+  // observers if the service is currently routed.
+  void OnMediaSessionMetadataChanged(MediaSessionServiceImpl* service);
+  // Called when the actions of a MediaSessionService has changed. Will notify
+  // observers if the service is currently routed.
+  void OnMediaSessionActionsChanged(MediaSessionServiceImpl* service);
+
+  // Called when a MediaSessionAction is received. The action will be forwarded
+  // to blink::MediaSession corresponding to the current routed service.
+  void DidReceiveAction(blink::mojom::MediaSessionAction action) override;
 
  private:
   friend class content::WebContentsUserData<MediaSessionImpl>;
   friend class ::MediaSessionImplBrowserTest;
   friend class content::MediaSessionImplVisibilityBrowserTest;
   friend class content::AudioFocusManagerTest;
+  friend class content::MediaSessionImplServiceRoutingTest;
   friend class content::MediaSessionImplStateObserver;
 
   CONTENT_EXPORT void SetDelegateForTests(
@@ -251,6 +262,18 @@ class MediaSessionImpl : public MediaSession,
   CONTENT_EXPORT bool AddOneShotPlayer(MediaSessionPlayerObserver* observer,
                                        int player_id);
 
+  // MediaSessionService-related methods
+
+  // Called when the routed service may have changed.
+  void UpdateRoutedService();
+
+  // Returns whether the frame |rfh| uses MediaSession API.
+  bool IsServiceActiveForRenderFrameHost(RenderFrameHost* rfh);
+
+  // Compute the MediaSessionService that should be routed, which will be used
+  // to update |routed_service_|.
+  CONTENT_EXPORT MediaSessionServiceImpl* ComputeServiceForRouting();
+
   std::unique_ptr<AudioFocusDelegate> delegate_;
   PlayersMap normal_players_;
   PlayersMap pepper_players_;
@@ -267,7 +290,6 @@ class MediaSessionImpl : public MediaSession,
   // StopDucking().
   bool is_ducking_;
 
-  base::Optional<MediaMetadata> metadata_;
   base::CallbackList<void(State)> media_session_state_listeners_;
 
   base::ObserverList<MediaSessionObserver> observers_;
@@ -276,9 +298,15 @@ class MediaSessionImpl : public MediaSession,
   std::unique_ptr<MediaSessionAndroid> session_android_;
 #endif  // defined(OS_ANDROID)
 
-  // The MediaSessionService this session is associated with (the service of the
-  // top-level frame).
-  MediaSessionServiceImpl* service_;
+  // MediaSessionService-related fields
+  using ServicesMap = std::map<RenderFrameHost*, MediaSessionServiceImpl*>;
+
+  // The collection of all managed services (non-owned pointers). The services
+  // are owned by RenderFrameHost and should be registered on creation and
+  // unregistered on destroy.
+  ServicesMap services_;
+  // The currently routed service (non-owned pointer).
+  MediaSessionServiceImpl* routed_service_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaSessionImpl);
 };

content/browser/media/session/media_session_impl_service_routing_unittest.cc

+// Copyright 2016 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/browser/media/session/media_session_impl.h"
+
+#include <map>
+#include <memory>
+
+#include "content/browser/media/session/media_session_player_observer.h"
+#include "content/browser/media/session/media_session_service_impl.h"
+#include "content/test/test_render_view_host.h"
+#include "content/test/test_web_contents.h"
+#include "media/base/media_content_type.h"
+
+namespace content {
+
+namespace {
+
+static const int kPlayerId = 0;
+
+class MockMediaSessionServiceImpl : public MediaSessionServiceImpl {
+ public:
+  explicit MockMediaSessionServiceImpl(RenderFrameHost* rfh)
+      : MediaSessionServiceImpl(rfh) {}
+  ~MockMediaSessionServiceImpl() override = default;
+};
+
+class MockMediaSessionPlayerObserver : public MediaSessionPlayerObserver {
+ public:
+  explicit MockMediaSessionPlayerObserver(RenderFrameHost* rfh)
+      : render_frame_host_(rfh) {}
+
+  ~MockMediaSessionPlayerObserver() override = default;
+
+  void OnSuspend(int player_id) override {}
+  void OnResume(int player_id) override {}
+  void OnSetVolumeMultiplier(int player_id, double volume_multiplier) override {
+  }
+  RenderFrameHost* GetRenderFrameHost() const override {
+    return render_frame_host_;
+  }
+
+ private:
+  RenderFrameHost* render_frame_host_;
+};
+
+}  // anonymous namespace
+
+class MediaSessionImplServiceRoutingTest
+    : public RenderViewHostImplTestHarness {
+ public:
+  MediaSessionImplServiceRoutingTest() = default;
+  ~MediaSessionImplServiceRoutingTest() override = default;
+
+  void SetUp() override {
+    RenderViewHostImplTestHarness::SetUp();
+
+    contents()->GetMainFrame()->InitializeRenderFrameIfNeeded();
+    main_frame_ = contents()->GetMainFrame();
+    sub_frame_ = main_frame_->AppendChild("sub_frame");
+
+    player_in_main_frame_.reset(
+        new MockMediaSessionPlayerObserver(main_frame_));
+    player_in_sub_frame_.reset(new MockMediaSessionPlayerObserver(sub_frame_));
+  }
+
+  void TearDown() override {
+    services_.clear();
+
+    RenderViewHostImplTestHarness::TearDown();
+  }
+
+ protected:
+  void CreateServiceForFrame(TestRenderFrameHost* frame) {
+    services_[frame] = base::MakeUnique<MockMediaSessionServiceImpl>(frame);
+    services_[frame]->SetMetadata(MediaMetadata());
+  }
+
+  void StartPlayerForFrame(TestRenderFrameHost* frame) {
+    players_[frame] = base::MakeUnique<MockMediaSessionPlayerObserver>(frame);
+    MediaSessionImpl::Get(contents())
+        ->AddPlayer(players_[frame].get(), kPlayerId,
+                    media::MediaContentType::Persistent);
+  }
+
+  void ClearPlayersForFrame(TestRenderFrameHost* frame) {
+    if (!players_.count(frame))
+      return;
+
+    MediaSessionImpl::Get(contents())
+        ->RemovePlayer(players_[frame].get(), kPlayerId);
+  }
+
+  MediaSessionServiceImpl* ComputeServiceForRouting() {
+    return MediaSessionImpl::Get(contents())->ComputeServiceForRouting();
+  }
+
+  TestRenderFrameHost* main_frame_;
+  TestRenderFrameHost* sub_frame_;
+
+  std::unique_ptr<MockMediaSessionPlayerObserver> player_in_main_frame_;
+  std::unique_ptr<MockMediaSessionPlayerObserver> player_in_sub_frame_;
+
+  using ServiceMap = std::map<TestRenderFrameHost*,
+                              std::unique_ptr<MockMediaSessionServiceImpl>>;
+  ServiceMap services_;
+
+  using PlayerMap = std::map<TestRenderFrameHost*,
+                             std::unique_ptr<MockMediaSessionPlayerObserver>>;
+  PlayerMap players_;
+};
+
+TEST_F(MediaSessionImplServiceRoutingTest, NoFrameProducesAudio) {
+  CreateServiceForFrame(main_frame_);
+  CreateServiceForFrame(sub_frame_);
+
+  ASSERT_EQ(nullptr, ComputeServiceForRouting());
+}
+
+TEST_F(MediaSessionImplServiceRoutingTest,
+       OnlyMainFrameProducesAudioButHasNoService) {
+  StartPlayerForFrame(main_frame_);
+
+  ASSERT_EQ(nullptr, ComputeServiceForRouting());
+}
+
+TEST_F(MediaSessionImplServiceRoutingTest,
+       OnlySubFrameProducesAudioButHasNoService) {
+  StartPlayerForFrame(sub_frame_);
+
+  ASSERT_EQ(nullptr, ComputeServiceForRouting());
+}
+
+TEST_F(MediaSessionImplServiceRoutingTest,
+       OnlyMainFrameProducesAudioButHasInactiveService) {
+  StartPlayerForFrame(main_frame_);
+
+  CreateServiceForFrame(main_frame_);
+  services_[main_frame_]->SetMetadata(base::nullopt);
+
+  ASSERT_EQ(nullptr, ComputeServiceForRouting());
+}
+
+TEST_F(MediaSessionImplServiceRoutingTest,
+       OnlySubFrameProducesAudioButHasInactiveService) {
+  StartPlayerForFrame(sub_frame_);
+
+  CreateServiceForFrame(sub_frame_);
+  services_[sub_frame_]->SetMetadata(base::nullopt);
+
+  ASSERT_EQ(nullptr, ComputeServiceForRouting());
+}
+
+TEST_F(MediaSessionImplServiceRoutingTest,
+       BothFrameProducesAudioButOnlySubFrameHasService) {
+  StartPlayerForFrame(main_frame_);
+  StartPlayerForFrame(sub_frame_);
+
+  CreateServiceForFrame(sub_frame_);
+
+  ASSERT_EQ(services_[sub_frame_].get(), ComputeServiceForRouting());
+}
+
+TEST_F(MediaSessionImplServiceRoutingTest, PreferTopMostFrame) {
+  StartPlayerForFrame(main_frame_);
+  StartPlayerForFrame(sub_frame_);
+
+  CreateServiceForFrame(main_frame_);
+  CreateServiceForFrame(sub_frame_);
+
+  ASSERT_EQ(services_[main_frame_].get(), ComputeServiceForRouting());
+}
+
+TEST_F(MediaSessionImplServiceRoutingTest,
+       RoutedServiceUpdatedAfterRemovingPlayer) {
+  StartPlayerForFrame(main_frame_);
+  StartPlayerForFrame(sub_frame_);
+
+  CreateServiceForFrame(main_frame_);
+  CreateServiceForFrame(sub_frame_);
+
+  ClearPlayersForFrame(main_frame_);
+
+  ASSERT_EQ(services_[sub_frame_].get(), ComputeServiceForRouting());
+}
+
+}  // namespace content

content/browser/media/session/media_session_player_observer.h

@@ -7,6 +7,8 @@
 
 namespace content {
 
+class RenderFrameHost;
+
 class MediaSessionPlayerObserver {
  public:
   MediaSessionPlayerObserver() = default;
@@ -22,6 +24,10 @@ class MediaSessionPlayerObserver {
   // the MediaSession.
   virtual void OnSetVolumeMultiplier(int player_id,
                                      double volume_multiplier) = 0;
+
+  // Returns the RenderFrameHost this player observer belongs to. Returns
+  // nullptr if unavailable.
+  virtual RenderFrameHost* GetRenderFrameHost() const = 0;
 };
 
 }  // namespace content

content/browser/media/session/media_session_service_impl.cc

@@ -17,13 +17,13 @@ MediaSessionServiceImpl::MediaSessionServiceImpl(
     : render_frame_host_(render_frame_host) {
   MediaSessionImpl* session = GetMediaSession();
   if (session)
-    session->SetMediaSessionService(this);
+    session->OnServiceCreated(this);
 }
 
 MediaSessionServiceImpl::~MediaSessionServiceImpl() {
   MediaSessionImpl* session = GetMediaSession();
-  if (session && session->GetMediaSessionService() == this)
-    session->SetMediaSessionService(nullptr);
+  if (session)
+    session->OnServiceDestroyed(this);
 }
 
 // static
@@ -50,24 +50,27 @@ void MediaSessionServiceImpl::SetMetadata(
         RenderProcessHost::CrashReportMode::GENERATE_CRASH_DUMP);
     return;
   }
+  metadata_ = metadata;
 
   MediaSessionImpl* session = GetMediaSession();
   if (session)
-    session->SetMetadata(metadata);
+    session->OnMediaSessionMetadataChanged(this);
 }
 
 void MediaSessionServiceImpl::EnableAction(
     blink::mojom::MediaSessionAction action) {
+  actions_.insert(action);
   MediaSessionImpl* session = GetMediaSession();
   if (session)
-    session->OnMediaSessionEnabledAction(action);
+    session->OnMediaSessionActionsChanged(this);
 }
 
 void MediaSessionServiceImpl::DisableAction(
     blink::mojom::MediaSessionAction action) {
+  actions_.erase(action);
   MediaSessionImpl* session = GetMediaSession();
   if (session)
-    session->OnMediaSessionDisabledAction(action);
+    session->OnMediaSessionActionsChanged(this);
 }
 
 MediaSessionImpl* MediaSessionServiceImpl::GetMediaSession() {
@@ -75,8 +78,6 @@ MediaSessionImpl* MediaSessionServiceImpl::GetMediaSession() {
       WebContentsImpl::FromRenderFrameHost(render_frame_host_));
   if (!contents)
     return nullptr;
-  if (render_frame_host_ != contents->GetMainFrame())
-    return nullptr;
   return MediaSessionImpl::Get(contents);
 }
 

content/browser/media/session/media_session_service_impl.h

@@ -12,32 +12,39 @@
 
 namespace content {
 
-class MediaSessionImpl;
 class RenderFrameHost;
+class MediaSessionImpl;
 
-// There is one MediaSessionService per frame.
-class MediaSessionServiceImpl : public blink::mojom::MediaSessionService {
+// There is one MediaSessionService per frame. The class is owned by
+// RenderFrameHost and should register/unregister itself to/from
+// MediaSessionImpl when RenderFrameHost is created/destroyed.
+class CONTENT_EXPORT MediaSessionServiceImpl
+    : public blink::mojom::MediaSessionService {
  public:
   ~MediaSessionServiceImpl() override;
 
   static void Create(RenderFrameHost* render_frame_host,
                      blink::mojom::MediaSessionServiceRequest request);
   const blink::mojom::MediaSessionClientPtr& GetClient() { return client_; }
+  RenderFrameHost* GetRenderFrameHost() { return render_frame_host_; }
 
- private:
-  explicit MediaSessionServiceImpl(RenderFrameHost* render_frame_host);
+  const base::Optional<MediaMetadata>& metadata() const { return metadata_; }
+  const std::set<blink::mojom::MediaSessionAction>& actions() const {
+    return actions_;
+  }
 
   // blink::mojom::MediaSessionService implementation.
   void SetClient(blink::mojom::MediaSessionClientPtr client) override;
 
-  void SetMetadata(
-      const base::Optional<content::MediaMetadata>& metadata) override;
+  void SetMetadata(const base::Optional<MediaMetadata>& metadata) override;
 
   void EnableAction(blink::mojom::MediaSessionAction action) override;
   void DisableAction(blink::mojom::MediaSessionAction action) override;
 
-  // Returns the content::MediaSession this service is associated with. Only
-  // returns non-null when this service is in the top-level frame.
+ protected:
+  explicit MediaSessionServiceImpl(RenderFrameHost* render_frame_host);
+
+ private:
   MediaSessionImpl* GetMediaSession();
 
   void Bind(blink::mojom::MediaSessionServiceRequest request);
@@ -48,6 +55,8 @@ class MediaSessionServiceImpl : public blink::mojom::MediaSessionService {
   // The binding is removed when binding_ is cleared or goes out of scope.
   std::unique_ptr<mojo::Binding<blink::mojom::MediaSessionService>> binding_;
   blink::mojom::MediaSessionClientPtr client_;
+  base::Optional<MediaMetadata> metadata_;
+  std::set<blink::mojom::MediaSessionAction> actions_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaSessionServiceImpl);
 };

content/browser/media/session/mock_media_session_player_observer.cc

@@ -40,6 +40,10 @@ void MockMediaSessionPlayerObserver::OnSetVolumeMultiplier(
   players_[player_id].volume_multiplier_ = volume_multiplier;
 }
 
+RenderFrameHost* MockMediaSessionPlayerObserver::GetRenderFrameHost() const {
+  return nullptr;
+}
+
 int MockMediaSessionPlayerObserver::StartNewPlayer() {
   players_.push_back(MockPlayer(true, 1.0f));
   return players_.size() - 1;

content/browser/media/session/mock_media_session_player_observer.h

@@ -20,6 +20,7 @@ class MockMediaSessionPlayerObserver : public MediaSessionPlayerObserver {
   void OnSuspend(int player_id) override;
   void OnResume(int player_id) override;
   void OnSetVolumeMultiplier(int player_id, double volume_multiplier) override;
+  RenderFrameHost* GetRenderFrameHost() const override;
 
   // Simulate that a new player started.
   // Returns the player_id.

content/browser/media/session/pepper_player_delegate.cc

@@ -59,6 +59,11 @@ void PepperPlayerDelegate::OnSetVolumeMultiplier(int player_id,
   SetVolume(player_id, volume_multiplier);
 }
 
+RenderFrameHost* PepperPlayerDelegate::GetRenderFrameHost() const {
+  // TODO(zqzhang): Pepper player should be associated to a RenderFrameHost.
+  return nullptr;
+}
+
 void PepperPlayerDelegate::SetVolume(int player_id, double volume) {
   contents_->Send(new FrameMsg_SetPepperVolume(
       contents_->GetMainFrame()->routing_id(), pp_instance_, volume));

content/browser/media/session/pepper_player_delegate.h

@@ -26,6 +26,7 @@ class PepperPlayerDelegate : public MediaSessionPlayerObserver {
   void OnResume(int player_id) override;
   void OnSetVolumeMultiplier(int player_id,
                              double volume_multiplier) override;
+  RenderFrameHost* GetRenderFrameHost() const override;
 
  private:
   void SetVolume(int player_id, double volume);

content/public/android/java/src/org/chromium/content/browser/MediaSessionImpl.java

@@ -12,6 +12,8 @@ import org.chromium.content_public.browser.MediaSessionObserver;
 import org.chromium.content_public.browser.WebContents;
 import org.chromium.content_public.common.MediaMetadata;
 
+import java.util.HashSet;
+
 /**
  * The MediaSessionImpl Java wrapper to allow communicating with the native MediaSessionImpl object.
  * The object is owned by Java WebContentsImpl instead of native to avoid introducing a new garbage
@@ -93,16 +95,12 @@ public class MediaSessionImpl extends MediaSession {
     }
 
     @CalledByNative
-    private void mediaSessionEnabledAction(int action) {
-        for (mObserversIterator.rewind(); mObserversIterator.hasNext();) {
-            mObserversIterator.next().mediaSessionEnabledAction(action);
-        }
-    }
+    private void mediaSessionActionsChanged(int[] actions) {
+        HashSet<Integer> actionSet = new HashSet<Integer>();
+        for (int action : actions) actionSet.add(action);
 
-    @CalledByNative
-    private void mediaSessionDisabledAction(int action) {
         for (mObserversIterator.rewind(); mObserversIterator.hasNext();) {
-            mObserversIterator.next().mediaSessionDisabledAction(action);
+            mObserversIterator.next().mediaSessionActionsChanged(actionSet);
         }
     }
 

content/public/android/java/src/org/chromium/content_public/browser/MediaSessionObserver.java

@@ -9,6 +9,8 @@ import android.support.annotation.Nullable;
 import org.chromium.content.browser.MediaSessionImpl;
 import org.chromium.content_public.common.MediaMetadata;
 
+import java.util.Set;
+
 /**
  * This class is Java implementation of native MediaSessionObserver. The class receives media
  * session messages from Java {@link MediaSession}, which acts acts as a proxy forwarding messages
@@ -56,16 +58,10 @@ public abstract class MediaSessionObserver {
     public void mediaSessionMetadataChanged(MediaMetadata metadata) {}
 
     /**
-     * Called when the observed {@link MediaSession} has enabled an action.
-     * @param action The enabled action.
-     */
-    public void mediaSessionEnabledAction(int action) {}
-
-    /**
-     * Called when the observed {@link MediaSession} has disabled an action.
-     * @param action The disabled action.
+     * Called when the observed {@link MediaSession} has changed its action list.
+     * @param actions The new action list after the change.
      */
-    public void mediaSessionDisabledAction(int action) {}
+    public void mediaSessionActionsChanged(Set<Integer> actions) {}
 
     /**
      * Stop observing the media session. Users must explicitly call this before dereferencing the

content/public/browser/media_session_observer.h

@@ -5,6 +5,8 @@
 #ifndef CONTENT_PUBLIC_BROWSER_MEDIA_SESSION_OBSERVER_H_
 #define CONTENT_PUBLIC_BROWSER_MEDIA_SESSION_OBSERVER_H_
 
+#include <set>
+
 #include "base/macros.h"
 #include "base/optional.h"
 #include "content/common/content_export.h"
@@ -41,13 +43,9 @@ class CONTENT_EXPORT MediaSessionObserver {
   virtual void MediaSessionMetadataChanged(
       const base::Optional<MediaMetadata>& metadata) {}
 
-  // Called when media session action is enabled.
-  virtual void MediaSessionEnabledAction(
-      blink::mojom::MediaSessionAction action) {}
-
-  // Called when media session action is disabled.
-  virtual void MediaSessionDisabledAction(
-      blink::mojom::MediaSessionAction action) {}
+  // Called when the media session action list has changed.
+  virtual void MediaSessionActionsChanged(
+      const std::set<blink::mojom::MediaSessionAction>& action) {}
 
  protected:
   // Create a MediaSessionObserver and start observing a session.

content/test/BUILD.gn

@@ -1130,6 +1130,7 @@ test("content_unittests") {
     "../browser/media/midi_host_unittest.cc",
     "../browser/media/session/audio_focus_manager_unittest.cc",
     "../browser/media/session/media_session_controller_unittest.cc",
+    "../browser/media/session/media_session_impl_service_routing_unittest.cc",
     "../browser/media/session/media_session_uma_helper_unittest.cc",
     "../browser/memory/memory_coordinator_impl_unittest.cc",
     "../browser/memory/memory_coordinator_unittest.cc",