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_player_observer.h"
 #include "content/browser/media/session/media_session_service_impl.h"
+#include "content/browser/media/session/media_session_service_router.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)
 
@@ skipping 61 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;
+MediaSessionPlayerObserver*
+MediaSessionImpl::GetMostMeaningfulPlayerObserver() {
+  MediaSessionPlayerObserver* player_observer = nullptr;
+  // TODO(zqzhang): improve the selection of most-meaningful player. See
+  // https://crbug.com/xxxxxx
+  if (!normal_players_.empty())
+    return player_observer = normal_players_.begin()->observer;
+  if (!one_shot_players_.empty())
+    return player_observer = one_shot_players_.begin()->observer;
+  if (!pepper_players_.empty())
+    return player_observer = pepper_players_.begin()->observer;
+
+  return nullptr;
 }
 
 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));
+
+  service_router_->MostMeaningfulPlayerObserverMayHaveChanged();
   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();
+  service_router_->MostMeaningfulPlayerObserverMayHaveChanged();
 
   // 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();
+  service_router_->MostMeaningfulPlayerObserverMayHaveChanged();
 
   // 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 74 matching lines @@
     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);
+  GetMediaSessionServiceRouter()->DidReceiveAction(action);
 }
 
-void MediaSessionImpl::OnMediaSessionEnabledAction(
-    blink::mojom::MediaSessionAction action) {
+void MediaSessionImpl::OnMediaSessionActionsChanged(
+    const std::set<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);
+    observer.MediaSessionActionsChanged(action);
 }
 
 void MediaSessionImpl::StartDucking() {
   if (is_ducking_)
     return;
   is_ducking_ = true;
   UpdateVolumeMultiplier();
 }
 
 void MediaSessionImpl::StopDucking() {
@@ skipping 135 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) {
+      service_router_(new MediaSessionServiceRouter(this)) {
 #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 62 matching lines @@
   if (!RequestSystemAudioFocus(AudioFocusManager::AudioFocusType::Gain))
     return false;
 
   one_shot_players_.insert(PlayerIdentifier(observer, player_id));
   NotifyAboutStateChange();
 
   return true;
 }
 
 }  // namespace content