Implement MediaSession on top of the WebMediaPlayerDelegate.

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 "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_controller.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/media/media_player_delegate_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 {
 
 MediaWebContentsObserverAndroid::MediaWebContentsObserverAndroid(
@@ skipping 29 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;
 }
 
+bool MediaWebContentsObserverAndroid::RequestPlay(
+    RenderFrameHost* render_frame_host,
+    int delegate_id,
+    bool has_audio,
+    bool is_remote,
+    base::TimeDelta duration) {
+  // |has_video| forced to true since the value doesn't matter at present.
+  OnMediaPlaying(render_frame_host, delegate_id, true, has_audio, is_remote,
+                 duration);
+  return media_session_map_.find(MediaPlayerId(
+             render_frame_host, delegate_id)) != media_session_map_.end();
+}
+
 #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
   // 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,
     RenderFrameHost* render_frame_host) {
+  // Receive play/pause/destroyed messages, but don't mark as processed so they
+  // are also handled by MediaWebContentsObserver.
+  OnMediaPlayerDelegateMessageReceived(msg, render_frame_host);
+
   if (MediaWebContentsObserver::OnMessageReceived(msg, render_frame_host))
     return true;
 
   if (OnMediaPlayerMessageReceived(msg, render_frame_host))
     return true;
 
   if (OnMediaPlayerSetCdmMessageReceived(msg, render_frame_host))
     return true;
 
   if (OnMediaSessionMessageReceived(msg, render_frame_host))
     return true;
 
   return false;
 }
 
+void MediaWebContentsObserverAndroid::OnMediaPlayerDelegateMessageReceived(
+    const IPC::Message& msg,
+    RenderFrameHost* render_frame_host) {
+  IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(MediaWebContentsObserverAndroid, msg,
+                                   render_frame_host)
+    IPC_MESSAGE_HANDLER(MediaPlayerDelegateHostMsg_OnMediaDestroyed,
+                        OnMediaDestroyed)
+    IPC_MESSAGE_HANDLER(MediaPlayerDelegateHostMsg_OnMediaPaused, OnMediaPaused)
+    IPC_MESSAGE_HANDLER(MediaPlayerDelegateHostMsg_OnMediaPlaying,
+                        OnMediaPlaying)
+  IPC_END_MESSAGE_MAP()
+}
+
 bool MediaWebContentsObserverAndroid::OnMediaPlayerMessageReceived(
     const IPC::Message& msg,
     RenderFrameHost* render_frame_host) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(MediaWebContentsObserverAndroid, msg)
     IPC_MESSAGE_FORWARD(MediaPlayerHostMsg_EnterFullscreen,
                         GetMediaPlayerManager(render_frame_host),
                         BrowserMediaPlayerManager::OnEnterFullscreen)
     IPC_MESSAGE_FORWARD(MediaPlayerHostMsg_Initialize,
                         GetMediaPlayerManager(render_frame_host),
@@ skipping 93 matching lines @@
   if (!cdm) {
     NOTREACHED() << "OnSetCdm: CDM not found for " << cdm_id;
     return;
   }
 
   // TODO(xhwang): This could possibly fail. In that case we should reject the
   // promise.
   media_player->SetCdm(cdm);
 }
 
+void MediaWebContentsObserverAndroid::OnMediaDestroyed(
+    RenderFrameHost* render_frame_host,
+    int delegate_id) {
+  media_session_map_.erase(MediaPlayerId(render_frame_host, delegate_id));
+}
+
+void MediaWebContentsObserverAndroid::OnMediaPaused(
+    RenderFrameHost* render_frame_host,
+    int delegate_id,
+    bool reached_end_of_stream) {
+  // Drop the session if playback completes normally.
+  if (reached_end_of_stream) {
+    OnMediaDestroyed(render_frame_host, delegate_id);
+    return;
+  }
+
+  auto it =
+      media_session_map_.find(MediaPlayerId(render_frame_host, delegate_id));
+  if (it == media_session_map_.end())
+    return;
+
+  it->second->OnPlaybackPaused();
+}
+
+void MediaWebContentsObserverAndroid::OnMediaPlaying(
+    RenderFrameHost* render_frame_host,
+    int delegate_id,
+    bool has_video,
+    bool has_audio,
+    bool is_remote,
+    base::TimeDelta duration) {
+  const MediaPlayerId id(render_frame_host, delegate_id);
+
+  // Since we don't remove session instances on pause, there may be an existing
+  // instance for this playback attempt.
+  //
+  // In this case, try to reinitialize it with the new settings.  If they are
+  // the same, this is a no-op.  If the reinitialize fails, destroy the
+  // controller. A later playback attempt will create a new controller.
+  auto it = media_session_map_.find(id);
+  if (it != media_session_map_.end()) {
+    if (!it->second->Initialize(has_audio, is_remote, duration))
+      media_session_map_.erase(it);
+    return;
+  }
+
+  scoped_ptr<MediaSessionController> controller(
+      new MediaSessionController(id, this));
+
+  if (!controller->Initialize(has_audio, is_remote, duration))
+    return;
+
+  media_session_map_[id] = std::move(controller);
+}
+
 }  // namespace content