Implement MediaSession on top of the WebMediaPlayerDelegate.

content/browser/media/android/media_web_contents_observer_android.cc

Index: content/browser/media/android/media_web_contents_observer_android.cc
diff --git a/content/browser/media/android/media_web_contents_observer_android.cc b/content/browser/media/android/media_web_contents_observer_android.cc
index 1b48959e9bad9ae15030a60b37bcce87c4d49bd8..dce0b2fe710338266fb05e413d25c710a1a05954 100644
--- a/content/browser/media/android/media_web_contents_observer_android.cc
+++ b/content/browser/media/android/media_web_contents_observer_android.cc
@@ -6,9 +6,12 @@
 
 #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/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"
@@ -58,6 +61,26 @@ MediaWebContentsObserverAndroid::GetMediaSessionManager(
   return manager;
 }
 
+bool MediaWebContentsObserverAndroid::RequestPlay(
+    RenderFrameHost* render_frame_host,
+    int64_t player_cookie,
+    bool has_audio,
+    bool is_remote,
+    base::TimeDelta duration) {
+  const MediaPlayerId id(render_frame_host, player_cookie);
+
+  // Remove any existing entry if it has a different audio parameter; when WMPA
+  // is used, the value of |has_audio| may not be initially known.
+  auto it = media_session_map_.find(id);
+  if (it != media_session_map_.end() && it->second->has_audio() != has_audio)
+    media_session_map_.erase(it);
+
+  // |has_video| forced to true since the value doesn't matter at present.
+  OnMediaPlayingNotification(render_frame_host, player_cookie, true, has_audio,
+                             is_remote, duration);
+  return media_session_map_.find(id) != media_session_map_.end();
+}
+
 #if defined(VIDEO_HOLE)
 void MediaWebContentsObserverAndroid::OnFrameInfoUpdated() {
   for (auto it = media_player_managers_.begin();
@@ -71,6 +94,13 @@ 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);
@@ -90,6 +120,10 @@ void MediaWebContentsObserverAndroid::RenderFrameDeleted(
 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;
 
@@ -99,6 +133,21 @@ bool MediaWebContentsObserverAndroid::OnMessageReceived(
   return OnMediaPlayerSetCdmMessageReceived(msg, render_frame_host);
 }
 
+void MediaWebContentsObserverAndroid::OnMediaPlayerDelegateMessageReceived(
+    const IPC::Message& msg,
+    RenderFrameHost* render_frame_host) {
+  // TODO(dalecurtis): These should no longer be FrameHostMsg.

[nasko, 2016/01/22 17:28:32]

Well, you are adding some new messages. Why make them FrameHostMsg when you can
make them the right type you have in mind?

[DaleCurtis, 2016/01/23 02:11:00]

Figured it would grow the CL too much, but it's not that bad. Done. Took the
opportunity to clean them up a bit too naming and parameter wise.

+  IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(MediaWebContentsObserverAndroid, msg,
+                                   render_frame_host)
+    IPC_MESSAGE_HANDLER(FrameHostMsg_MediaDestroyedNotification,
+                        OnMediaDestroyedNotification)
+    IPC_MESSAGE_HANDLER(FrameHostMsg_MediaPlayingNotification,
+                        OnMediaPlayingNotification)
+    IPC_MESSAGE_HANDLER(FrameHostMsg_MediaPausedNotification,
+                        OnMediaPausedNotification)
+  IPC_END_MESSAGE_MAP()
+}
+
 bool MediaWebContentsObserverAndroid::OnMediaPlayerMessageReceived(
     const IPC::Message& msg,
     RenderFrameHost* render_frame_host) {
@@ -197,4 +246,52 @@ void MediaWebContentsObserverAndroid::OnSetCdm(
   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));
+}
+
+void MediaWebContentsObserverAndroid::OnMediaPlayingNotification(
+    RenderFrameHost* render_frame_host,
+    int64_t player_cookie,
+    bool has_video,
+    bool has_audio,
+    bool is_remote,
+    base::TimeDelta duration) {
+  // Since we don't remove session instances on pause, there may be an existing
+  // instance for this playback attempt.

[mlamouri (slow - plz ping), 2016/01/22 16:58:31]

I think this is going to lead to bugs. If you play a media then pause it, the
session stays active indeed. However, it can be suspended from the UI in which
case I think you will not reactivate it. I believe this can be tested easily.
Calling ::Initialize() for a player that is already part of the media session
should be a no-op and will work around this problem.

[DaleCurtis, 2016/01/23 02:11:00]

I think this actually makes things a bit more complicated, but since the
complexity is contained to the MediaSessionController (where it's nicely
testable) it's preferable.

+  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);
+}
+
+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