Fixing naming issues in MediaSession

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/media/session/audio_focus_delegate.h"
+#include "content/browser/media/session/media_session_player_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)
-    : observer(observer),
-      player_id(player_id) {
-}
+MediaSession::PlayerIdentifier::PlayerIdentifier(
+    MediaSessionPlayerObserver* observer,
+    int player_id)
+    : observer(observer), player_id(player_id) {}
 
 bool MediaSession::PlayerIdentifier::operator==(
     const PlayerIdentifier& other) const {
   return this->observer == other.observer && this->player_id == other.player_id;
 }
 
 size_t MediaSession::PlayerIdentifier::Hash::operator()(
     const PlayerIdentifier& player_identifier) const {
-  size_t hash = BASE_HASH_NAMESPACE::hash<MediaSessionObserver*>()(
+  size_t hash = BASE_HASH_NAMESPACE::hash<MediaSessionPlayerObserver*>()(
       player_identifier.observer);
   hash += BASE_HASH_NAMESPACE::hash<int>()(player_identifier.player_id);
   return hash;
 }
 
 // static
 MediaSession* MediaSession::Get(WebContents* web_contents) {
   MediaSession* session = FromWebContents(web_contents);
   if (!session) {
     CreateForWebContents(web_contents);
@@ skipping 20 matching lines @@
   pepper_players_.clear();
   AbandonSystemAudioFocusIfNeeded();
 }
 
 void MediaSession::SetMetadata(const base::Optional<MediaMetadata>& metadata) {
   metadata_ = metadata;
   static_cast<WebContentsImpl*>(web_contents())
       ->OnMediaSessionMetadataChanged();
 }
 
-bool MediaSession::AddPlayer(MediaSessionObserver* observer,
+bool MediaSession::AddPlayer(MediaSessionPlayerObserver* 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.
@@ skipping 26 matching lines @@
   // suspended.
   if (old_audio_focus_state != State::ACTIVE)
     players_.clear();
 
   players_.insert(PlayerIdentifier(observer, player_id));
   UpdateWebContents();
 
   return true;
 }
 
-void MediaSession::RemovePlayer(MediaSessionObserver* observer,
+void MediaSession::RemovePlayer(MediaSessionPlayerObserver* 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) {
+void MediaSession::RemovePlayers(MediaSessionPlayerObserver* 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(); ) {
     if (it->observer == observer)
       pepper_players_.erase(it++);
     else
       ++it;
   }
 
   AbandonSystemAudioFocusIfNeeded();
 }
 
 void MediaSession::RecordSessionDuck() {
   uma_helper_.RecordSessionSuspended(
       MediaSessionSuspendedSource::SystemTransientDuck);
 }
 
-void MediaSession::OnPlayerPaused(MediaSessionObserver* observer,
+void MediaSession::OnPlayerPaused(MediaSessionPlayerObserver* observer,
                                   int player_id) {
   // If a playback is completed, BrowserMediaPlayerManager will call
   // OnPlayerPaused() after RemovePlayer(). This is a workaround.
   // Also, this method may be called when a player that is not added
   // to this session (e.g. a silent video) is paused. MediaSession
   // should ignore the paused player for this case.
   if (!players_.count(PlayerIdentifier(observer, player_id)))
     return;
 
   // If there is more than one observer, remove the paused one from the session.
@@ skipping 102 matching lines @@
   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) {
+    std::unique_ptr<AudioFocusDelegate> delegate) {
   delegate_ = std::move(delegate);
 }
 
 bool MediaSession::IsActiveForTest() const {
   return audio_focus_state_ == State::ACTIVE;
 }
 
 MediaSessionUmaHelper* MediaSession::uma_helper_for_test() {
   return &uma_helper_;
 }
@@ skipping 71 matching lines @@
 }
 
 MediaSession::MediaSession(WebContents* web_contents)
     : WebContentsObserver(web_contents),
       audio_focus_state_(State::INACTIVE),
       audio_focus_type_(
           AudioFocusManager::AudioFocusType::GainTransientMayDuck),
       is_ducking_(false) {}
 
 void MediaSession::Initialize() {
-  delegate_ = MediaSessionDelegate::Create(this);
+  delegate_ = AudioFocusDelegate::Create(this);
 }
 
 bool MediaSession::RequestSystemAudioFocus(
     AudioFocusManager::AudioFocusType audio_focus_type) {
   bool result = delegate_->RequestAudioFocus(audio_focus_type);
   uma_helper_.RecordRequestAudioFocusResult(result);
 
   // MediaSession must change its state & audio focus type AFTER requesting
   // audio focus.
   SetAudioFocusState(result ? State::ACTIVE : State::INACTIVE);
@@ skipping 28 matching lines @@
       break;
     case State::SUSPENDED:
       uma_helper_.OnSessionSuspended();
       break;
     case State::INACTIVE:
       uma_helper_.OnSessionInactive();
       break;
   }
 }
 
-bool MediaSession::AddPepperPlayer(MediaSessionObserver* observer,
+bool MediaSession::AddPepperPlayer(MediaSessionPlayerObserver* observer,
                                    int player_id) {
   bool success = RequestSystemAudioFocus(
       AudioFocusManager::AudioFocusType::Gain);
   DCHECK(success);
 
   pepper_players_.insert(PlayerIdentifier(observer, player_id));
 
   observer->OnSetVolumeMultiplier(player_id, GetVolumeMultiplier());
 
   return true;
 }
 
 }  // namespace content