Letting Flash join MediaSession (stack implementaion)

content/browser/media/session/media_session.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.h"
 
 #include "content/browser/media/session/media_session_delegate.h"
 #include "content/browser/media/session/media_session_observer.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/public/browser/web_contents.h"
@@ skipping 42 matching lines @@
     session->Initialize();
   }
   return session;
 }
 
 MediaSession::~MediaSession() {
   DCHECK(players_.empty());
   DCHECK(audio_focus_state_ == State::INACTIVE);
 }
 
+void MediaSession::WasShown() {
+  if (IsSuspended())
+    RequestSystemAudioFocus(audio_focus_type_);
+}
+
 void MediaSession::SetMetadata(const base::Optional<MediaMetadata>& metadata) {
   metadata_ = metadata;
   // TODO(zqzhang): On Android, the metadata is sent though JNI everytime the
   // media session play/pause state changes. Need to find a way to seprate the
   // state change and Metadata update. See https://crbug.com/621855.
   static_cast<WebContentsImpl*>(web_contents())->OnMediaSessionStateChanged();
 }
 
 bool MediaSession::AddPlayer(MediaSessionObserver* observer,
                              int player_id,
                              media::MediaContentType media_content_type) {
+  if (media_content_type == media::MediaContentType::Pepper)
+    return AddPepperPlayer(observer, player_id);
+
   observer->OnSetVolumeMultiplier(player_id, GetVolumeMultiplier());
 
   // Determine the audio focus type required for playing the new player.
   // TODO(zqzhang): handle duckable and uncontrollable.
   // See https://crbug.com/639277.
   AudioFocusManager::AudioFocusType required_audio_focus_type;
   if (media_content_type == media::MediaContentType::Persistent) {
     required_audio_focus_type = AudioFocusManager::AudioFocusType::Gain;
   } else {
     required_audio_focus_type =
@@ skipping 31 matching lines @@
 
   return true;
 }
 
 void MediaSession::RemovePlayer(MediaSessionObserver* observer,
                                 int player_id) {
   auto it = players_.find(PlayerIdentifier(observer, player_id));
   if (it != players_.end())
     players_.erase(it);
 
+  it = pepper_players_.find(PlayerIdentifier(observer, player_id));
+  if (it != pepper_players_.end())
+    pepper_players_.erase(it);
+
   AbandonSystemAudioFocusIfNeeded();
 }
 
 void MediaSession::RemovePlayers(MediaSessionObserver* observer) {
-  for (auto it = players_.begin(); it != players_.end();) {
+  for (auto it = players_.begin(); it != players_.end(); ) {
     if (it->observer == observer)
       players_.erase(it++);
     else
       ++it;
   }
 
+  for (auto it = pepper_players_.begin(); it != pepper_players_.end(); ) {
+    if (it->observer == observer)
+      pepper_players_.erase(it++);
+    else
+      ++it;
+  }
+
   AbandonSystemAudioFocusIfNeeded();
 }
 
 void MediaSession::RecordSessionDuck() {
   uma_helper_.RecordSessionSuspended(
       MediaSessionSuspendedSource::SystemTransientDuck);
 }
 
 void MediaSession::OnPlayerPaused(MediaSessionObserver* observer,
                                   int player_id) {
@@ skipping 51 matching lines @@
   if (suspend_type == SuspendType::SYSTEM) {
     OnSuspendInternal(suspend_type, State::INACTIVE);
     return;
   }
 
   if (audio_focus_state_ != State::SUSPENDED)
     OnSuspendInternal(suspend_type, State::SUSPENDED);
 
   DCHECK(audio_focus_state_ == State::SUSPENDED);
   players_.clear();
+
+  for (const auto& it : pepper_players_) {
+    it.observer->OnSetVolumeMultiplier(
+        it.player_id, GetPepperVolumeMultiplier());
+  }
+
   AbandonSystemAudioFocusIfNeeded();
 }
 
 void MediaSession::StartDucking() {
   if (is_ducking_)
     return;
   is_ducking_ = true;
   UpdateVolumeMultiplier();
 }
 
 void MediaSession::StopDucking() {
   if (!is_ducking_)
     return;
   is_ducking_ = false;
   UpdateVolumeMultiplier();
 }
 
 void MediaSession::UpdateVolumeMultiplier() {
   for (const auto& it : players_)
     it.observer->OnSetVolumeMultiplier(it.player_id, GetVolumeMultiplier());
 }
 
 double MediaSession::GetVolumeMultiplier() const {
   return is_ducking_ ? kDuckingVolumeMultiplier : kDefaultVolumeMultiplier;
 }
 
+double MediaSession::GetPepperVolumeMultiplier() const {
+  if (is_ducking_)
+    return kDuckingVolumeMultiplier;
+  if (!IsActive() && !allow_pepper_override_ducking_)
+    return kDuckingVolumeMultiplier;
+  return kDefaultVolumeMultiplier;
+}
+
 bool MediaSession::IsActive() const {
   return audio_focus_state_ == State::ACTIVE;
 }
 
 bool MediaSession::IsReallySuspended() const {
   return audio_focus_state_ == State::SUSPENDED;
 }
 
 bool MediaSession::IsSuspended() const {
   // TODO(mlamouri): should be == State::SUSPENDED.
   return audio_focus_state_ != State::ACTIVE;
 }
 
 bool MediaSession::IsControllable() const {
   // Only media session having focus Gain can be controllable unless it is
   // inactive.
   return audio_focus_state_ != State::INACTIVE &&
          audio_focus_type_ == AudioFocusManager::AudioFocusType::Gain;
 }
 
+bool MediaSession::HasPepper() const {
+  return !pepper_players_.empty();
+}
+
 std::unique_ptr<base::CallbackList<void(MediaSession::State)>::Subscription>
 MediaSession::RegisterMediaSessionStateChangedCallbackForTest(
     const StateChangedCallback& cb) {
   return media_session_state_listeners_.Add(cb);
 }
 
 void MediaSession::SetDelegateForTests(
     std::unique_ptr<MediaSessionDelegate> delegate) {
   delegate_ = std::move(delegate);
 }
@@ skipping 53 matching lines @@
   suspend_type_ = suspend_type;
 
   if (suspend_type != SuspendType::CONTENT) {
     // SuspendType::CONTENT happens when the suspend action came from
     // the page in which case the player is already paused.
     // Otherwise, the players need to be paused.
     for (const auto& it : players_)
       it.observer->OnSuspend(it.player_id);
   }
 
+  for (const auto& it : pepper_players_)
+    it.observer->OnSetVolumeMultiplier(it.player_id, kDuckingVolumeMultiplier);
+
   UpdateWebContents();
 }
 
 void MediaSession::OnResumeInternal(SuspendType suspend_type) {
   if (suspend_type == SuspendType::SYSTEM && suspend_type_ != suspend_type)
     return;
 
   SetAudioFocusState(State::ACTIVE);
 
   for (const auto& it : players_)
     it.observer->OnResume(it.player_id);
 
+  for (const auto& it : pepper_players_)
+    it.observer->OnSetVolumeMultiplier(
+        it.player_id, GetPepperVolumeMultiplier());
+
   UpdateWebContents();
 }
 
 MediaSession::MediaSession(WebContents* web_contents)
     : WebContentsObserver(web_contents),
       audio_focus_state_(State::INACTIVE),
       audio_focus_type_(
           AudioFocusManager::AudioFocusType::GainTransientMayDuck),
-      is_ducking_(false) {}
+      is_ducking_(false),
+      allow_pepper_override_ducking_(false) {}
 
 void MediaSession::Initialize() {
   delegate_ = MediaSessionDelegate::Create(this);
 }
 
 bool MediaSession::RequestSystemAudioFocus(
     AudioFocusManager::AudioFocusType audio_focus_type) {
   bool result = delegate_->RequestAudioFocus(audio_focus_type);
   uma_helper_.RecordRequestAudioFocusResult(result);
   return result;
 }
 
 void MediaSession::AbandonSystemAudioFocusIfNeeded() {
-  if (audio_focus_state_ == State::INACTIVE || !players_.empty())
+  if (audio_focus_state_ == State::INACTIVE || !players_.empty() ||
+      !pepper_players_.empty())
     return;
 
   delegate_->AbandonAudioFocus();
 
   SetAudioFocusState(State::INACTIVE);
   UpdateWebContents();
 }
 
 void MediaSession::UpdateWebContents() {
   media_session_state_listeners_.Notify(audio_focus_state_);
@@ skipping 11 matching lines @@
       break;
     case State::SUSPENDED:
       uma_helper_.OnSessionSuspended();
       break;
     case State::INACTIVE:
       uma_helper_.OnSessionInactive();
       break;
   }
 }
 
+bool MediaSession::AddPepperPlayer(MediaSessionObserver* observer,
+                                   int player_id) {
+  AudioFocusManager::AudioFocusType focus_type =
+      AudioFocusManager::AudioFocusType::Gain;
+  State audio_focus_state =
+      RequestSystemAudioFocus(focus_type) ? State::ACTIVE : State::INACTIVE;
+  SetAudioFocusState(audio_focus_state);
+  audio_focus_type_ = focus_type;
+  pepper_players_.insert(PlayerIdentifier(observer, player_id));
+
+  observer->OnSetVolumeMultiplier(player_id, GetPepperVolumeMultiplier());
+
+  return true;
+}
+
+void MediaSession::AllowPepperOverrideDucking() {

[whywhat, 2016/09/13 00:16:17]

nit: clear candidate to unification as AllowDisallowPepperOverrideDucking() :)
These two methods are twins.

[Zhiqiang Zhang (Slow), 2016/09/22 12:30:33]

This method is removed since there's no longer complex Pepper-specific ducking
logic in this CL.

+  if (allow_pepper_override_ducking_)
+    return;
+
+  allow_pepper_override_ducking_ = true;
+  for (const auto& it : pepper_players_) {
+    it.observer->OnSetVolumeMultiplier(
+        it.player_id, GetPepperVolumeMultiplier());
+  }
+}
+
+void MediaSession::DisallowPepperOverrideDucking() {
+  if (!allow_pepper_override_ducking_)
+    return;
+
+  allow_pepper_override_ducking_ = false;
+  for (const auto& it : pepper_players_) {
+    it.observer->OnSetVolumeMultiplier(
+        it.player_id, GetPepperVolumeMultiplier());
+  }
+}
+
 }  // namespace content