Allow MediaSession in iframes to be routed

content/browser/media/session/media_session_impl.cc

 // Copyright 2015 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 <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"
 #include "content/public/browser/media_session.h"
 #include "content/public/browser/media_session_observer.h"
 #include "content/public/browser/web_contents.h"
 #include "media/base/media_content_type.h"
 
 #if defined(OS_ANDROID)
 #include "content/browser/media/session/media_session_android.h"
 #endif  // defined(OS_ANDROID)
 
 namespace content {
 
 namespace {
 
 const double kDefaultVolumeMultiplier = 1.0;
 const double kDuckingVolumeMultiplier = 0.2;
 
+size_t ComputeFrameDepth(RenderFrameHost* rfh) {
+  size_t depth = 0;
+  while (rfh) {
+    ++depth;
+    rfh = rfh->GetParent();
+  }
+  return depth;
+}
+
 }  // anonymous namespace
 
 using MediaSessionSuspendedSource =
     MediaSessionUmaHelper::MediaSessionSuspendedSource;
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(MediaSessionImpl);
 
 MediaSessionImpl::PlayerIdentifier::PlayerIdentifier(
     MediaSessionPlayerObserver* observer,
     int player_id)
@@ skipping 44 matching lines @@
   // TODO(zqzhang): refactor MediaSessionImpl, maybe move the interface used to
   // talk with AudioFocusManager out to a seperate class. The AudioFocusManager
   // unit tests then could mock the interface and abandon audio focus when
   // WebContents is destroyed. See https://crbug.com/651069
   normal_players_.clear();
   pepper_players_.clear();
   one_shot_players_.clear();
   AbandonSystemAudioFocusIfNeeded();
 }
 
-void MediaSessionImpl::SetMediaSessionService(
-    MediaSessionServiceImpl* service) {
-  service_ = service;
-}
-
 void MediaSessionImpl::AddObserver(MediaSessionObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 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) {
   if (media_content_type == media::MediaContentType::OneShot)
     return AddOneShotPlayer(observer, player_id);
   if (media_content_type == media::MediaContentType::Pepper)
     return AddPepperPlayer(observer, player_id);
 
   observer->OnSetVolumeMultiplier(player_id, GetVolumeMultiplier());
 
@@ skipping 21 matching lines @@
 
   if (audio_focus_state_ != State::ACTIVE)
     return false;
 
   // The session should be reset if a player is starting while all players are
   // suspended.
   if (old_audio_focus_state != State::ACTIVE)
     normal_players_.clear();
 
   normal_players_.insert(PlayerIdentifier(observer, player_id));
+
+  UpdateRoutedService();
   NotifyAboutStateChange();
-
   return true;
 }
 
 void MediaSessionImpl::RemovePlayer(MediaSessionPlayerObserver* observer,
                                     int player_id) {
   bool was_controllable = IsControllable();
 
   PlayerIdentifier identifier(observer, player_id);
 
   auto it = normal_players_.find(identifier);
   if (it != normal_players_.end())
     normal_players_.erase(it);
 
   it = pepper_players_.find(identifier);
   if (it != pepper_players_.end())
     pepper_players_.erase(it);
 
   it = one_shot_players_.find(identifier);
   if (it != one_shot_players_.end())
     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
   // about the state change.
   if (!was_controllable && IsControllable())
     NotifyAboutStateChange();
 }
 
 void MediaSessionImpl::RemovePlayers(MediaSessionPlayerObserver* observer) {
   bool was_controllable = IsControllable();
@@ skipping 13 matching lines @@
   }
 
   for (auto it = one_shot_players_.begin(); it != one_shot_players_.end();) {
     if (it->observer == observer)
       one_shot_players_.erase(it++);
     else
       ++it;
   }
 
   AbandonSystemAudioFocusIfNeeded();
+  UpdateRoutedService();
 
   // The session may become controllable after removing a one-shot player.
   // However AbandonSystemAudioFocusIfNeeded will short-return and won't notify
   // about the state change.
   if (!was_controllable && IsControllable())
     NotifyAboutStateChange();
 }
 
 void MediaSessionImpl::RecordSessionDuck() {
   uma_helper_.RecordSessionSuspended(
@@ skipping 72 matching lines @@
 
   if (audio_focus_state_ != State::SUSPENDED)
     OnSuspendInternal(suspend_type, State::SUSPENDED);
 
   DCHECK(audio_focus_state_ == State::SUSPENDED);
   normal_players_.clear();
 
   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;
   is_ducking_ = true;
   UpdateVolumeMultiplier();
 }
 
 void MediaSessionImpl::StopDucking() {
   if (!is_ducking_)
     return;
@@ skipping 133 matching lines @@
 
   NotifyAboutStateChange();
 }
 
 MediaSessionImpl::MediaSessionImpl(WebContents* web_contents)
     : WebContentsObserver(web_contents),
       audio_focus_state_(State::INACTIVE),
       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)
 }
 
 void MediaSessionImpl::Initialize() {
   delegate_ = AudioFocusDelegate::Create(this);
 }
 
 bool MediaSessionImpl::RequestSystemAudioFocus(
@@ skipping 61 matching lines @@
                                         int player_id) {
   if (!RequestSystemAudioFocus(AudioFocusManager::AudioFocusType::Gain))
     return false;
 
   one_shot_players_.insert(PlayerIdentifier(observer, player_id));
   NotifyAboutStateChange();
 
   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

[whywhat, 2016/11/30 22:16:41]

is there a test possible for this?

[Zhiqiang Zhang (Slow), 2016/12/01 16:34:41]

Added unit tests.

+  // player and has a corresponding MediaSessionService and return the
+  // corresponding MediaSessionService. If multiple frames satisfy the criteria,
+  // prefer the top-most frame.
+  MediaSessionServiceImpl* best_service = nullptr;
+  size_t min_depth = std::numeric_limits<size_t>::max();
+
+  for (const auto& player : normal_players_) {

[whywhat, 2016/11/30 22:16:41]

I wonder if there's a potential bottleneck - ideally we would collect all RFH we
want to compare by depth first and maybe even memoirize the depth to avoid
recalculating it over and over again. Some edge case with many players in many
nested iframes and these loops will run forever :)

[Zhiqiang Zhang (Slow), 2016/12/01 16:34:41]

Done. Now we collect all the frames first and then compare them in batch.

+    ComputeServiceForRoutingInternal(
+        player.observer, &best_service, &min_depth);
+  }
+
+  for (const auto& player : one_shot_players_) {
+    ComputeServiceForRoutingInternal(
+        player.observer, &best_service, &min_depth);
+  }
+
+  for (const auto& player : pepper_players_) {
+    ComputeServiceForRoutingInternal(
+        player.observer, &best_service, &min_depth);
+  }
+
+  return best_service;
+}
+
+void MediaSessionImpl::ComputeServiceForRoutingInternal(
+    MediaSessionPlayerObserver* player_observer,
+    MediaSessionServiceImpl** best_service,
+    size_t* min_depth) {
+  MediaSessionController* controller =
+      static_cast<MediaSessionController*>(player_observer);

[whywhat, 2016/11/30 22:16:41]

nit: could we avoid this assumption that MSC is the implementation of MSPO?
if that assumption ever changes, the potential breakage could be pretty bad imo

[Zhiqiang Zhang (Slow), 2016/12/01 16:34:41]

Added a `GetRenderFrameHost()` method to MediaSessionPlayerObserver. Though we
are now assuming MediaSessionPlayerObserver is related to RFH.

+  if (!controller)
+    return;
+
+  RenderFrameHost* rfh = controller->GetFrameOrientedId().first;
+  if (!services_.count(rfh))
+    return;
+
+  size_t depth = ComputeFrameDepth(rfh);
+  if (depth < *min_depth) {
+    *best_service = services_[rfh];
+    *min_depth = depth;
+  }
+}
+
 }  // namespace content