Clean up MediaSessionImpl state interfaces

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"
@@ skipping 273 matching lines @@
   }
 
   // If the player is a one-shot player, just remove it since it is not expected
   // to resume a one-shot player via resuming MediaSession.
   if (one_shot_players_.count(identifier)) {
     RemovePlayer(observer, player_id);
     return;
   }
 
   // Otherwise, suspend the session.
-  DCHECK(!IsSuspended());
+  DCHECK(IsActive());
   OnSuspendInternal(SuspendType::CONTENT, State::SUSPENDED);
 }
 
 void MediaSessionImpl::Resume(SuspendType suspend_type) {
-  DCHECK(IsReallySuspended());
+  DCHECK(IsSuspended());
 
   // When the resume requests comes from another source than system, audio focus
   // must be requested.
   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(suspend_type);
 }
 
 void MediaSessionImpl::Suspend(SuspendType suspend_type) {
-  if (IsSuspended())
+  if (!IsActive())
     return;
 
   OnSuspendInternal(suspend_type, State::SUSPENDED);
 }
 
 void MediaSessionImpl::Stop(SuspendType suspend_type) {
   DCHECK(audio_focus_state_ != State::INACTIVE);
   DCHECK(suspend_type != SuspendType::CONTENT);
   DCHECK(!HasPepper());
 
@@ skipping 34 matching lines @@
 }
 
 double MediaSessionImpl::GetVolumeMultiplier() const {
   return is_ducking_ ? kDuckingVolumeMultiplier : kDefaultVolumeMultiplier;
 }
 
 bool MediaSessionImpl::IsActive() const {
   return audio_focus_state_ == State::ACTIVE;
 }
 
-bool MediaSessionImpl::IsReallySuspended() const {
+bool MediaSessionImpl::IsSuspended() const {
   return audio_focus_state_ == State::SUSPENDED;
 }
 
-bool MediaSessionImpl::IsSuspended() const {
-  // TODO(mlamouri): should be == State::SUSPENDED.
-  return audio_focus_state_ != State::ACTIVE;
+bool MediaSessionImpl::IsActuallyPaused() const {
+  if (routed_service_ && routed_service_->playback_state() ==
+                             blink::mojom::MediaSessionPlaybackState::PLAYING) {
+    return false;
+  }
+  return !IsActive();
 }
 
 bool MediaSessionImpl::IsControllable() const {
   // Only media session having focus Gain can be controllable unless it is
   // inactive. Also, the session will be uncontrollable if it contains one-shot
   // players.
   return audio_focus_state_ != State::INACTIVE &&
          audio_focus_type_ == AudioFocusManager::AudioFocusType::Gain &&
          one_shot_players_.empty();
 }
 
 bool MediaSessionImpl::HasPepper() const {
   return !pepper_players_.empty();
 }
 
 std::unique_ptr<base::CallbackList<void(MediaSessionImpl::State)>::Subscription>
 MediaSessionImpl::RegisterMediaSessionStateChangedCallbackForTest(
     const StateChangedCallback& cb) {
   return media_session_state_listeners_.Add(cb);
 }
 
 void MediaSessionImpl::SetDelegateForTests(
     std::unique_ptr<AudioFocusDelegate> delegate) {
   delegate_ = std::move(delegate);
 }
 
-bool MediaSessionImpl::IsActiveForTest() const {
-  return audio_focus_state_ == State::ACTIVE;
-}
-
 MediaSessionUmaHelper* MediaSessionImpl::uma_helper_for_test() {
   return &uma_helper_;
 }
 
 void MediaSessionImpl::RemoveAllPlayersForTest() {
   normal_players_.clear();
   pepper_players_.clear();
   one_shot_players_.clear();
   AbandonSystemAudioFocusIfNeeded();
 }
@@ skipping 101 matching lines @@
       !pepper_players_.empty() || !one_shot_players_.empty()) {
     return;
   }
   delegate_->AbandonAudioFocus();
 
   SetAudioFocusState(State::INACTIVE);
   NotifyAboutStateChange();
 }
 
 void MediaSessionImpl::NotifyAboutStateChange() {
-  bool is_actually_suspended = IsSuspended();
-  // Compute the actual playback state using both the MediaSessionService state
-  // and real state.
-  //
-  // TODO(zqzhang): Maybe also compute for IsControllable()? See
-  // https://crbug.com/674983
-  if (routed_service_ &&
-      routed_service_->playback_state() ==
-          blink::mojom::MediaSessionPlaybackState::PLAYING) {
-    is_actually_suspended = false;
-  }
+  bool is_actually_paused = IsActuallyPaused();
 
   media_session_state_listeners_.Notify(audio_focus_state_);
   for (auto& observer : observers_)
-    observer.MediaSessionStateChanged(IsControllable(), is_actually_suspended);
+    observer.MediaSessionStateChanged(IsControllable(), is_actually_paused);
 }
 
 void MediaSessionImpl::SetAudioFocusState(State audio_focus_state) {
   if (audio_focus_state == audio_focus_state_)
     return;
 
   audio_focus_state_ = audio_focus_state;
   switch (audio_focus_state_) {
     case State::ACTIVE:
       uma_helper_.OnSessionActive();
@@ skipping 165 matching lines @@
     if (!IsServiceActiveForRenderFrameHost(frame))
       continue;
     best_frame = frame;
     min_depth = depth;
   }
 
   return best_frame ? services_[best_frame] : nullptr;
 }
 
 }  // namespace content