Implement MediaSession on top of the WebMediaPlayerDelegate.

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/memory/scoped_ptr.h"
 #include "base/stl_util.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 {

[mlamouri (slow - plz ping), 2016/01/14 15:43:08]

Maybe this could be in a separate file?

[DaleCurtis, 2016/01/14 18:21:18]

Yeah, I was thinking the same since it ended up larger than expected.

+ public:
+  MediaSessionController(const WebContentsObserver::MediaPlayerId& id,
+                         MediaWebContentsObserver* media_web_contents_observer)
+      : id_(id), media_web_contents_observer_(media_web_contents_observer) {}
+
+  // Clients must call this after construction and destroy the controller if it
+  // returns false.
+  bool Initialize(bool has_video, bool has_audio, base::TimeDelta duration) {
+    // These objects are only created on the UI thread, so this is safe.
+    static uint32_t player_id = 0;
+    player_id_ = static_cast<int>(player_id++);
+
+    // Minimal duration of a player in order to be considered as Content type.
+    const base::TimeDelta kMinimumDurationForContent =
+        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_);
+      return false;
+    }
+
+    return true;
+  }
+
+  ~MediaSessionController() {
+    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())

[mlamouri (slow - plz ping), 2016/01/14 15:43:08]

How do you end up with a suspended session that pauses a player?

[DaleCurtis, 2016/01/14 18:21:18]

This is due to the delegate sending a "pause" ack back from the renderer after
the session pauses.  It's a bit convoluted to avoid it on the renderer side
since each impl calls DidPause differently.

[mlamouri (slow - plz ping), 2016/01/19 16:59:11]

zqzhang@ has been working on issues related to that. We are still DCHECK-ing for
!IsSuspended but we no longer DCHECK if the player isn't part of the session
(but early return instead).

+      session->OnPlayerPaused(this, player_id_);
+  }
+
+ private:
+  const WebContentsObserver::MediaPlayerId id_;
+  MediaWebContentsObserver* const media_web_contents_observer_;
+  int player_id_ = 0;
+  bool initialize_failed_ = false;
+
+  DISALLOW_COPY_AND_ASSIGN(MediaSessionController);
+};
+
 MediaWebContentsObserverAndroid::MediaWebContentsObserverAndroid(
     WebContents* web_contents)
     : MediaWebContentsObserver(web_contents) {}
 
-MediaWebContentsObserverAndroid::~MediaWebContentsObserverAndroid() {}
+MediaWebContentsObserverAndroid::~MediaWebContentsObserverAndroid() {
+  // Clear active sessions before destructing the observer.
+  media_session_map_.clear();
+}
 
 // static
 MediaWebContentsObserverAndroid*
 MediaWebContentsObserverAndroid::FromWebContents(WebContents* web_contents) {
   return static_cast<MediaWebContentsObserverAndroid*>(
       static_cast<WebContentsImpl*>(web_contents)
           ->media_web_contents_observer());
 }
 
 BrowserMediaPlayerManager*
@@ skipping 47 matching lines @@
   // 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;
 
   return false;
 }
 
+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)
+    IPC_MESSAGE_HANDLER(FrameHostMsg_MediaPausedNotification,
+                        OnMediaPausedNotification)
+  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 78 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::OnMediaDestroyedNotification(

[mlamouri (slow - plz ping), 2016/01/14 15:43:08]

Do we destroy the media as soon as it reached the end?

[DaleCurtis, 2016/01/14 18:21:18]

No, this is only called when the WMP is being destructed which only occurs in
teardown or when the htmlmediaelement object is gc'd/takes a clearing action.

+    RenderFrameHost* render_frame_host,
+    int64_t player_cookie) {
+  media_session_map_.erase(MediaPlayerId(render_frame_host, player_cookie));
+}
+
+void MediaWebContentsObserverAndroid::OnMediaPlayingNotification(

[mlamouri (slow - plz ping), 2016/01/14 15:43:08]

Are we going to call this when the media _starts_ or when it changes status to
play? Something important is that we don't take audio focus until we are
actually starting playback. I would like to not regress that.

[DaleCurtis, 2016/01/14 18:21:18]

This is only called when status changes to play.

[mlamouri (slow - plz ping), 2016/01/19 16:59:11]

Does that match the 'playing' event?

[DaleCurtis, 2016/01/20 00:43:58]

Yes

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