Split MediaContentType and AudioFocusType

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;
 
 }  // anonymous namespace
 
 using MediaSessionSuspendedSource =
@@ skipping 39 matching lines @@
 void MediaSession::SetMetadata(const 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,
-                             Type type) {
+                             media::MediaContentType media_content_type) {
   observer->OnSetVolumeMultiplier(player_id, volume_multiplier_);
 
+  // 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;
+  }
+
   // If the audio focus is already granted and is of type Content, there is
   // nothing to do. If it is granted of type Transient the requested type is
   // also transient, there is also nothing to do. Otherwise, the session needs
   // to request audio focus again.
   if (audio_focus_state_ == State::ACTIVE &&
-      (audio_focus_type_ == Type::Content || audio_focus_type_ == type)) {
+      (audio_focus_type_ == AudioFocusManager::AudioFocusType::Gain ||
+       audio_focus_type_ == required_audio_focus_type)) {
     players_.insert(PlayerIdentifier(observer, player_id));
     return true;
   }
 
   State old_audio_focus_state = audio_focus_state_;
-  State audio_focus_state = RequestSystemAudioFocus(type) ? State::ACTIVE
-                                                          : State::INACTIVE;
+  State audio_focus_state = RequestSystemAudioFocus(required_audio_focus_type)
+                                ? State::ACTIVE
+                                : State::INACTIVE;
   SetAudioFocusState(audio_focus_state);
-  audio_focus_type_ = type;
+  audio_focus_type_ = required_audio_focus_type;
 
   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)
     players_.clear();
 
   players_.insert(PlayerIdentifier(observer, player_id));
@@ skipping 41 matching lines @@
   if (players_.size() != 1) {
     RemovePlayer(observer, player_id);
     return;
   }
 
   // Otherwise, suspend the session.
   DCHECK(!IsSuspended());
   OnSuspendInternal(SuspendType::CONTENT, State::SUSPENDED);
 }
 
-void MediaSession::Resume(SuspendType type) {
+void MediaSession::Resume(SuspendType suspend_type) {
   DCHECK(IsReallySuspended());
 
   // When the resume requests comes from another source than system, audio focus
   // must be requested.
-  if (type != SuspendType::SYSTEM) {
+  if (suspend_type != SuspendType::SYSTEM) {
     // Request audio focus again in case we lost it because another app started
     // playing while the playback was paused.
     State audio_focus_state = RequestSystemAudioFocus(audio_focus_type_)
                                   ? State::ACTIVE
                                   : State::INACTIVE;
     SetAudioFocusState(audio_focus_state);
 
     if (audio_focus_state_ != State::ACTIVE)
       return;
   }
 
-  OnResumeInternal(type);
+  OnResumeInternal(suspend_type);
 }
 
-void MediaSession::Suspend(SuspendType type) {
+void MediaSession::Suspend(SuspendType suspend_type) {
   DCHECK(!IsSuspended());
 
-  OnSuspendInternal(type, State::SUSPENDED);
+  OnSuspendInternal(suspend_type, State::SUSPENDED);
 }
 
-void MediaSession::Stop(SuspendType type) {
+void MediaSession::Stop(SuspendType suspend_type) {
   DCHECK(audio_focus_state_ != State::INACTIVE);
 
-  DCHECK(type != SuspendType::CONTENT);
+  DCHECK(suspend_type != SuspendType::CONTENT);
 
   // TODO(mlamouri): merge the logic between UI and SYSTEM.
-  if (type == SuspendType::SYSTEM) {
-    OnSuspendInternal(type, State::INACTIVE);
+  if (suspend_type == SuspendType::SYSTEM) {
+    OnSuspendInternal(suspend_type, State::INACTIVE);
     return;
   }
 
   if (audio_focus_state_ != State::SUSPENDED)
-    OnSuspendInternal(type, State::SUSPENDED);
+    OnSuspendInternal(suspend_type, State::SUSPENDED);
 
   DCHECK(audio_focus_state_ == State::SUSPENDED);
   players_.clear();
   AbandonSystemAudioFocusIfNeeded();
 }
 
 void MediaSession::SetVolumeMultiplier(double volume_multiplier) {
   volume_multiplier_ = volume_multiplier;
   for (const auto& it : players_)
     it.observer->OnSetVolumeMultiplier(it.player_id, volume_multiplier_);
 }
 
 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 content type media session can be controllable unless it is inactive.
+  // Only media session having focus Gain can be controllable unless it is
+  // inactive.
   return audio_focus_state_ != State::INACTIVE &&
-         audio_focus_type_ == Type::Content;
+         audio_focus_type_ == AudioFocusManager::AudioFocusType::Gain;
 }
 
 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);
 }
 
 bool MediaSession::IsActiveForTest() const {
   return audio_focus_state_ == State::ACTIVE;
 }
 
-MediaSession::Type MediaSession::audio_focus_type_for_test() const {
+AudioFocusManager::AudioFocusType MediaSession::audio_focus_type_for_test()
+    const {
   return audio_focus_type_;
 }
 
 MediaSessionUmaHelper* MediaSession::uma_helper_for_test() {
   return &uma_helper_;
 }
 
 void MediaSession::RemoveAllPlayersForTest() {
   players_.clear();
   AbandonSystemAudioFocusIfNeeded();
 }
 
-void MediaSession::OnSuspendInternal(SuspendType type, State new_state) {
+void MediaSession::OnSuspendInternal(SuspendType suspend_type,
+                                     State new_state) {
   DCHECK(new_state == State::SUSPENDED || new_state == State::INACTIVE);
   // UI suspend cannot use State::INACTIVE.
-  DCHECK(type == SuspendType::SYSTEM || new_state == State::SUSPENDED);
+  DCHECK(suspend_type == SuspendType::SYSTEM || new_state == State::SUSPENDED);
 
   if (audio_focus_state_ != State::ACTIVE)
     return;
 
-  switch (type) {
+  switch (suspend_type) {
     case SuspendType::UI:
       uma_helper_.RecordSessionSuspended(MediaSessionSuspendedSource::UI);
       break;
     case SuspendType::SYSTEM:
       switch (new_state) {
         case State::SUSPENDED:
           uma_helper_.RecordSessionSuspended(
               MediaSessionSuspendedSource::SystemTransient);
           break;
         case State::INACTIVE:
           uma_helper_.RecordSessionSuspended(
               MediaSessionSuspendedSource::SystemPermanent);
           break;
         case State::ACTIVE:
           NOTREACHED();
           break;
       }
       break;
     case SuspendType::CONTENT:
       uma_helper_.RecordSessionSuspended(MediaSessionSuspendedSource::CONTENT);
       break;
   }
 
   SetAudioFocusState(new_state);
-  suspend_type_ = type;
+  suspend_type_ = suspend_type;
 
-  if (type != SuspendType::CONTENT) {
+  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);
   }
 
   UpdateWebContents();
 }
 
-void MediaSession::OnResumeInternal(SuspendType type) {
-  if (type == SuspendType::SYSTEM && suspend_type_ != type)
+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);
 
   UpdateWebContents();
 }
 
 MediaSession::MediaSession(WebContents* web_contents)
     : WebContentsObserver(web_contents),
       audio_focus_state_(State::INACTIVE),
-      audio_focus_type_(Type::Transient),
-      volume_multiplier_(kDefaultVolumeMultiplier) {
-}
+      audio_focus_type_(
+          AudioFocusManager::AudioFocusType::GainTransientMayDuck),
+      volume_multiplier_(kDefaultVolumeMultiplier) {}
 
 void MediaSession::Initialize() {
   delegate_ = MediaSessionDelegate::Create(this);
 }
 
-bool MediaSession::RequestSystemAudioFocus(Type type) {
-  bool result = delegate_->RequestAudioFocus(type);
+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())
     return;
 
   delegate_->AbandonAudioFocus();
 
@@ skipping 18 matching lines @@
     case State::SUSPENDED:
       uma_helper_.OnSessionSuspended();
       break;
     case State::INACTIVE:
       uma_helper_.OnSessionInactive();
       break;
   }
 }
 
 }  // namespace content