Plumb audio focus support for spitzer clients.

content/browser/media/android/media_web_contents_observer_android.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/android/media_web_contents_observer_android.h"
 
+#include "base/callback.h"
 #include "content/browser/media/android/browser_media_player_manager.h"
 #include "content/browser/media/android/browser_media_session_manager.h"
 #include "content/browser/media/android/media_session.h"
 #include "content/browser/media/android/media_session_observer.h"
 #include "content/browser/media/cdm/browser_cdm_manager.h"
 #include "content/browser/web_contents/web_contents_impl.h"
+#include "content/common/frame_messages.h"
 #include "content/common/media/media_player_messages_android.h"
 #include "content/common/media/media_session_messages_android.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "ipc/ipc_message_macros.h"
 #include "media/base/android/media_player_android.h"
 
 namespace content {
 
 class MediaSessionController : public MediaSessionObserver {
@@ skipping 18 matching lines @@
             ? MediaSession::Type::Content
             : MediaSession::Type::Transient;
 
     // If a session can't be created, force a pause immediately.
     if (!MediaSession::Get(media_web_contents_observer_->web_contents())
              ->AddPlayer(this, player_id_, media_session_type)) {
       OnSuspend(player_id_);
       return false;
     }
 
+    initialized_ = true;
     return true;
   }
 
   ~MediaSessionController() {
-    MediaSession::Get(media_web_contents_observer_->web_contents())
-        ->RemovePlayer(this, player_id_);
+    if (initialized_) {
+      MediaSession::Get(media_web_contents_observer_->web_contents())
+          ->RemovePlayer(this, player_id_);
+    }
   }
 
   void OnSuspend(int player_id) {
     DCHECK_EQ(player_id_, player_id);
     media_web_contents_observer_->Send(
         new FrameMsg_MediaDelegatePause(id_.first->GetRoutingID(), id_.second));
   }
 
   void OnResume(int player_id) {
     DCHECK_EQ(player_id_, player_id);
     media_web_contents_observer_->Send(
         new FrameMsg_MediaDelegatePlay(id_.first->GetRoutingID(), id_.second));
   }
 
   void PausePlayback() {
     MediaSession* session =
         MediaSession::Get(media_web_contents_observer_->web_contents());
     // TODO(dalecurtis, mlamouri): This seems odd, if we don't check suspend of
     // the entire session, notifying a pause will DCHECK in mediasession.cc:146.
     if (!session->IsSuspended())
       session->OnPlayerPaused(this, player_id_);
   }
 
  private:
   const WebContentsObserver::MediaPlayerId id_;
   MediaWebContentsObserver* const media_web_contents_observer_;
   int player_id_ = 0;
-  bool initialize_failed_ = false;
+  bool initialized_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(MediaSessionController);
 };
 
 MediaWebContentsObserverAndroid::MediaWebContentsObserverAndroid(
     WebContents* web_contents)
     : MediaWebContentsObserver(web_contents) {}
 
-MediaWebContentsObserverAndroid::~MediaWebContentsObserverAndroid() {
-  // Clear active sessions before destructing the observer.
-  media_session_map_.clear();
-}
+MediaWebContentsObserverAndroid::~MediaWebContentsObserverAndroid() {}
 
 // static
 MediaWebContentsObserverAndroid*
 MediaWebContentsObserverAndroid::FromWebContents(WebContents* web_contents) {
   return static_cast<MediaWebContentsObserverAndroid*>(
       static_cast<WebContentsImpl*>(web_contents)
           ->media_web_contents_observer());
 }
 
 BrowserMediaPlayerManager*
@@ skipping 15 matching lines @@
   auto it = media_session_managers_.find(render_frame_host);
   if (it != media_session_managers_.end())
     return it->second;
 
   BrowserMediaSessionManager* manager =
       new BrowserMediaSessionManager(render_frame_host);
   media_session_managers_.set(render_frame_host, make_scoped_ptr(manager));
   return manager;
 }
 
+// static
+void MediaWebContentsObserverAndroid::CheckFocus(
+    int render_frame_id,
+    const base::Closure& on_focus_cb) {
+  for (const auto& kv : media_session_map_) {
+    if (kv.first.first->GetRoutingID() == render_frame_id) {
+      on_focus_cb.Run();
+      return;
+    }
+  }
+
+  deferred_focus_cbs_[render_frame_id].push_back(on_focus_cb);
+}
+
 #if defined(VIDEO_HOLE)
 void MediaWebContentsObserverAndroid::OnFrameInfoUpdated() {
   for (auto it = media_player_managers_.begin();
        it != media_player_managers_.end(); ++it) {
     it->second->OnFrameInfoUpdated();
   }
 }
 #endif  // defined(VIDEO_HOLE)
 
 void MediaWebContentsObserverAndroid::RenderFrameDeleted(
     RenderFrameHost* render_frame_host) {
   MediaWebContentsObserver::RenderFrameDeleted(render_frame_host);
 
+  for (auto it = media_session_map_.begin(); it != media_session_map_.end();) {
+    if (it->first.first == render_frame_host)
+      it = media_session_map_.erase(it);
+    else
+      ++it;
+  }
+
   // Always destroy the media players before CDMs because we do not support
   // detaching CDMs from media players yet. See http://crbug.com/330324
   media_player_managers_.erase(render_frame_host);
   media_session_managers_.erase(render_frame_host);
 
   // TODO(xhwang): Currently MediaWebContentsObserver, BrowserMediaPlayerManager
   // and BrowserCdmManager all run on browser UI thread. So this call is okay.
-  // In the future we need to support the case where MediaWebContentsObserver
+  // In the future we need to support the ~case where MediaWebContentsObserver
   // get notified on browser UI thread, but BrowserMediaPlayerManager and
   // BrowserCdmManager run on a different thread.
   BrowserCdmManager* browser_cdm_manager =
       BrowserCdmManager::FromProcess(render_frame_host->GetProcess()->GetID());
   if (browser_cdm_manager)
     browser_cdm_manager->RenderFrameDeleted(render_frame_host->GetRoutingID());
 }
 
 bool MediaWebContentsObserverAndroid::OnMessageReceived(
     const IPC::Message& msg,
@@ skipping 121 matching lines @@
 
   // TODO(xhwang): This could possibly fail. In that case we should reject the
   // promise.
   media_player->SetCdm(cdm);
 }
 
 void MediaWebContentsObserverAndroid::OnMediaDestroyedNotification(
     RenderFrameHost* render_frame_host,
     int64_t player_cookie) {
   media_session_map_.erase(MediaPlayerId(render_frame_host, player_cookie));
+  deferred_focus_cbs_.erase(render_frame_host->GetRoutingID());
 }
 
 void MediaWebContentsObserverAndroid::OnMediaPlayingNotification(
     RenderFrameHost* render_frame_host,
     int64_t player_cookie,
     bool has_video,
     bool has_audio,
     bool is_remote,
     base::TimeDelta duration) {
   // Don't setup a media session for remote playback instances.
   if (is_remote)
     return;
 
   const MediaPlayerId id(render_frame_host, player_cookie);
   scoped_ptr<MediaSessionController> controller(
       new MediaSessionController(id, this));
 
   // If initialize fails, the controller should be destroyed and a new one
   // attempted later after another playback attempt occurs.
   if (!controller->Initialize(has_video, has_audio, duration))
     return;
 
   media_session_map_[id] = std::move(controller);
+
+  // Notify any deferred focus callbacks.
+  auto it = deferred_focus_cbs_.find(render_frame_host->GetRoutingID());
+  if (it != deferred_focus_cbs_.end()) {
+    for (const auto& cb : it->second)
+      cb.Run();
+    deferred_focus_cbs_.erase(it);
+  }
 }
 
 void MediaWebContentsObserverAndroid::OnMediaPausedNotification(
     RenderFrameHost* render_frame_host,
     int64_t player_cookie,
     bool reached_end_of_stream) {
   // Drop the session if playback completes normally.
   if (reached_end_of_stream) {
     OnMediaDestroyedNotification(render_frame_host, player_cookie);
     return;
   }
 
   auto it =
       media_session_map_.find(MediaPlayerId(render_frame_host, player_cookie));
   if (it == media_session_map_.end())
     return;
 
   it->second->PausePlayback();
 }
 
 }  // namespace content