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"
 #include "content/public/browser/web_contents_delegate.h"
 #include "media/base/media_content_type.h"
 
 namespace content {
 
 namespace {
 
 const double kDefaultVolumeMultiplier = 1.0;
+const double kDuckingVolumeMultiplier = 0.2;
 
 }  // anonymous namespace
 
 using MediaSessionSuspendedSource =
     MediaSessionUmaHelper::MediaSessionSuspendedSource;
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(MediaSession);
 
 MediaSession::PlayerIdentifier::PlayerIdentifier(MediaSessionObserver* observer,
                                                  int player_id)
@@ skipping 34 matching lines @@
   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) {
-  observer->OnSetVolumeMultiplier(player_id, volume_multiplier_);
+  if (media_content_type == media::MediaContentType::Pepper)
+    return AddPepperPlayer(observer, player_id);
+
+  observer->OnSetVolumeMultiplier(player_id, GetVolumeMultiplier());

[whywhat, 2016/08/30 21:09:37]

seems like this change should be rebased on top of the Duck change to only show
new diffs?

 
   // 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 =
         AudioFocusManager::AudioFocusType::GainTransientMayDuck;
@@ skipping 30 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();) {
     if (it->observer == observer)
       players_.erase(it++);
     else
       ++it;
   }
 
+  for (auto it = pepper_players_.begin(); it != pepper_players_.end();) {

[whywhat, 2016/08/30 21:09:37]

nit: extract a helper function or a predicate and use an erase(remove_if())
idiom?

+    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(

[whywhat, 2016/08/30 21:09:37]

nit: not a one-liner, use {}

+        it.player_id, GetPepperVolumeMultiplier());
+
   AbandonSystemAudioFocusIfNeeded();
 }
 
-void MediaSession::SetVolumeMultiplier(double volume_multiplier) {
-  volume_multiplier_ = volume_multiplier;
+void MediaSession::Duck() {
+  if (is_ducking_)
+    return;
+
+  is_ducking_ = true;
   for (const auto& it : players_)
-    it.observer->OnSetVolumeMultiplier(it.player_id, volume_multiplier_);
+    it.observer->OnSetVolumeMultiplier(it.player_id, GetVolumeMultiplier());
+  for (const auto& it : pepper_players_)
+    it.observer->OnSetVolumeMultiplier(
+        it.player_id, GetPepperVolumeMultiplier());
+}
+
+void MediaSession::Unduck() {
+  if (!is_ducking_)
+    return;
+
+  is_ducking_ = false;
+  for (const auto& it : players_)
+    it.observer->OnSetVolumeMultiplier(it.player_id, GetVolumeMultiplier());
+  for (const auto& it : pepper_players_) {
+    it.observer->OnSetVolumeMultiplier(
+        it.player_id, GetPepperVolumeMultiplier());
+  }
 }
 
 bool MediaSession::IsActive() const {
   return audio_focus_state_ == State::ACTIVE;
 }
 
 bool MediaSession::IsReallySuspended() const {
   return audio_focus_state_ == State::SUSPENDED;
 }
 
@@ skipping 75 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_)

[whywhat, 2016/08/30 21:09:37]

it seems like with a couple of exceptions we handle the pepper players in a
similar way as normal players. would it be a good candidate to polymorphism?

for (const auto& it : players_)
  it->Resume();  // either calls observer->OnResume(player_id) or
observer->OnSetVM(player_id, ...);

+    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),
-      volume_multiplier_(kDefaultVolumeMultiplier) {}
+      is_ducking_(false),
+      is_on_top_(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;
   }
 }
 
+double MediaSession::GetVolumeMultiplier() const {
+  return is_ducking_ ? kDuckingVolumeMultiplier : kDefaultVolumeMultiplier;
+}
+
+double MediaSession::GetPepperVolumeMultiplier() const {
+  if (is_on_top_)
+    return kDefaultVolumeMultiplier;
+  if (!IsActive() || is_ducking_)

[whywhat, 2016/08/30 21:09:37]

nit: is this equivalent to

if (!is_on_top_ && (!IsActive() || is_ducking_)) return
kDuckingVolumeMultiplier;

return kDefaultVolumeMultiplier;

+    return kDuckingVolumeMultiplier;
+  return kDefaultVolumeMultiplier;
+}
+
+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::SetOnTop(bool is_on_top) {

[whywhat, 2016/08/30 21:09:37]

isn't it equivalent to got audio focus / active just for the pepper players?

[Zhiqiang Zhang (Slow), 2016/08/31 14:37:34]

Yeah, I agree that SetOnTop() sounds like a dirty hack. Maybe renaming it to
Start/StopPepperDucking is more proper?

Also, I'm thinking of exposing a helper function like
MediaSession::HasActivePepper() if we need some more complex control of Flash.

[whywhat, 2016/08/31 18:37:09]

It sounds as a dirty hack because it exposes the fact that the sessions are kept
on the stack to the sessions and also that it's hard to maintain (e.g. I believe
I commented on some spot where I believe this property is not updated
correctly).

A better name is welcome. Is it only Pepper related? Is this method to notify
the session it's now should get audio focus if needed since it's the most
current one atm?

+  if (is_on_top_ == is_on_top)
+    return;
+
+  is_on_top_ = is_on_top;
+  for (const auto& it : pepper_players_) {
+    it.observer->OnSetVolumeMultiplier(
+        it.player_id, GetPepperVolumeMultiplier());
+  }
+}
+
 }  // namespace content