Plumb audio focus support for spitzer clients.

content/browser/media/android/media_web_contents_observer_android.cc

 // Copyright 2016 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"
@@ skipping 25 matching lines @@
         base::TimeDelta::FromSeconds(5);
 
     const MediaSession::Type media_session_type =
         duration == base::TimeDelta() || duration > kMinimumDurationForContent
             ? 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_);

[mlamouri (slow - plz ping), 2016/01/19 17:18:17]

I guess that would no longer be needed?

       return false;
     }
 
     initialized_ = true;
     return true;
   }
 
   ~MediaSessionController() {
     if (initialized_) {
       MediaSession::Get(media_web_contents_observer_->web_contents())
@@ skipping 129 matching lines @@
 
   if (MediaWebContentsObserver::OnMessageReceived(msg, render_frame_host))
     return true;
 
   if (OnMediaPlayerMessageReceived(msg, render_frame_host))
     return true;
 
   return OnMediaPlayerSetCdmMessageReceived(msg, render_frame_host);
 }
 
+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);
+}
+
 void MediaWebContentsObserverAndroid::OnMediaPlayerDelegateMessageReceived(
     const IPC::Message& msg,
     RenderFrameHost* render_frame_host) {
   // TODO(dalecurtis): These should no longer be FrameHostMsg.
   IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(MediaWebContentsObserverAndroid, msg,
                                    render_frame_host)
     IPC_MESSAGE_HANDLER(FrameHostMsg_MediaDestroyedNotification,
                         OnMediaDestroyedNotification)
     IPC_MESSAGE_HANDLER(FrameHostMsg_MediaPlayingNotification,
                         OnMediaPlayingNotification)
@@ skipping 97 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) {
   // TODO(dalecurtis): Remove this allowance once RequestPlay() is deleted.
   const MediaPlayerId id(render_frame_host, player_cookie);
   if (media_session_map_.find(id) != media_session_map_.end())
     return;
 
   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_audio, is_remote, 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