Link MediaSessionTabHelper with native MediaSession [CL is going to be split]

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/audio_focus_delegate.h"
+#include "content/browser/media/session/media_session_observer.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 {
 
@@ skipping 32 matching lines @@
     CreateForWebContents(web_contents);
     session = FromWebContents(web_contents);
     session->Initialize();
   }
   return session;
 }
 
 MediaSession::~MediaSession() {
   DCHECK(players_.empty());
   DCHECK(audio_focus_state_ == State::INACTIVE);
+  owned_observers_.clear();

[whywhat, 2016/10/21 18:28:14]

I think MediaSession should notify MediaSessionObservers it's about to be
destroyed so they could set their session_ to nullptr.
It's not MediaSessionDelegate's responsibility.

[derekjchow1, 2016/10/21 20:47:30]

+1. This is the pattern used in WebContentsObserver.

https://cs.chromium.org/chromium/src/content/public/browser/web_contents_obse...

You could add a MediaSessionDestroyed function to MediaSessionObserver. This
notification would be sent out in the destructor of MediaSession.
MediaSessionDelegate can then "own itself" and delete itself when it gets that
notification. This way a PassObserverOwnership function is no longer needed.

+}
+
+void MediaSession::AddObserver(MediaSessionObserver* observer) {
+  observers_.AddObserver(observer);
+}
+
+void MediaSession::RemoveObserver(MediaSessionObserver* observer) {
+  observers_.RemoveObserver(observer);
+  for (auto iter = owned_observers_.begin(); iter != owned_observers_.end();

[derekjchow1, 2016/10/21 20:47:30]

You could use std::find here.

+       ++iter) {
+    if (iter->get() == observer)
+      owned_observers_.erase(iter);
+    return;

[whywhat, 2016/10/21 18:28:14]

this return belongs to the if above

+  }
+}
+
+void MediaSession::PassObserverOwnership(
+    std::unique_ptr<MediaSessionObserver> observer) {
+  owned_observers_.push_back(std::move(observer));
 }
 
 void MediaSession::WebContentsDestroyed() {
   // This should only work for tests. In production, all the players should have
   // already been removed before WebContents is destroyed.
 
   // TODO(zqzhang): refactor MediaSession, maybe move the interface used to talk
   // with AudioFocusManager out to a seperate class. The AudioFocusManager unit
   // tests then could mock the interface and abandon audio focus when
   // WebContents is destroyed. See https://crbug.com/651069
   players_.clear();
   pepper_players_.clear();
   AbandonSystemAudioFocusIfNeeded();
 }
 
 void MediaSession::SetMetadata(const base::Optional<MediaMetadata>& metadata) {
   metadata_ = metadata;
-  static_cast<WebContentsImpl*>(web_contents())
-      ->OnMediaSessionMetadataChanged();
+
+  for (auto& observer : observers_)
+    observer.MediaSessionMetadataChanged(metadata_);
 }
 
 bool MediaSession::AddPlayer(MediaSessionPlayerObserver* observer,
                              int player_id,
                              media::MediaContentType media_content_type) {
   if (media_content_type == media::MediaContentType::Uncontrollable)
     return true;
   if (media_content_type == media::MediaContentType::Pepper)
     return AddPepperPlayer(observer, player_id);
 
@@ skipping 314 matching lines @@
     return;
   }
   delegate_->AbandonAudioFocus();
 
   SetAudioFocusState(State::INACTIVE);
   UpdateWebContents();
 }
 
 void MediaSession::UpdateWebContents() {
   media_session_state_listeners_.Notify(audio_focus_state_);
-  static_cast<WebContentsImpl*>(web_contents())->OnMediaSessionStateChanged();
+  for (auto& observer : observers_)
+    observer.MediaSessionStateChanged(IsControllable(), IsSuspended());
 }
 
 void MediaSession::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 14 matching lines @@
   DCHECK(success);
 
   pepper_players_.insert(PlayerIdentifier(observer, player_id));
 
   observer->OnSetVolumeMultiplier(player_id, GetVolumeMultiplier());
 
   return true;
 }
 
 }  // namespace content