Implement MediaSession on top of the WebMediaPlayerDelegate.

content/browser/media/android/media_session_controller.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_session_controller.h"
+
+#include "content/browser/media/media_web_contents_observer.h"
+#include "content/common/media/media_player_delegate_messages.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/render_frame_host.h"
+
+namespace content {
+
+MediaSessionController::MediaSessionController(
+    const WebContentsObserver::MediaPlayerId& id,
+    MediaWebContentsObserver* media_web_contents_observer)
+    : id_(id),
+      media_web_contents_observer_(media_web_contents_observer),
+      media_session_(
+          MediaSession::Get(media_web_contents_observer_->web_contents())) {}
+
+MediaSessionController::~MediaSessionController() {
+  if (!has_session_)
+    return;
+  media_session_->RemovePlayer(this, player_id_);
+}
+
+bool MediaSessionController::Initialize(bool has_audio,
+                                        bool is_remote,
+                                        base::TimeDelta duration) {
+  // Don't generate a new id if one has already been set.
+  if (!has_session_) {
+    // These objects are only created on the UI thread, so this is safe.
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
+    static uint32_t player_id = 0;
+    player_id_ = static_cast<int>(player_id++);
+  } else {
+    // |has_audio| is sticky to workaround inconsistent audio presence signals
+    // between WebMediaPlayerAndroid and MediaPlayerManager.
+    // TODO(dalecurtis): Delete sticky audio once we're no longer using WMPA and
+    // the BrowserMediaPlayerManagers.  Tracked by http://crbug.com/580626

[mlamouri (slow - plz ping), 2016/01/26 21:02:50]

Maybe this comment needs some more explanations. Slow brains like mine might
have a hard time to follow. Now that I understand, maybe something like:
"WebMediaPlayerAndroid isn't aware of audio presence but MediaPlayerManager
knows and will provide the information when calling RequestPlay() which
ultimately will call ::Initialize(). Though, WebMediaPlayer will keep calling
::Initialize() with has_audio set to false so we assume has_audio is true if it
was once true which is the case when has_session_ is true."

[DaleCurtis, 2016/01/27 02:25:13]

Reworded. Let me know if it needs more work.

+    has_audio = has_session_;
+  }
+
+  // Don't bother with a MediaSession for remote players or without audio.  If
+  // we already have a session from a previous call, release it.
+  if (!has_audio || is_remote) {
+    if (has_session_) {
+      has_session_ = false;
+      media_session_->RemovePlayer(this, player_id_);
+    }
+    return true;
+  }
+
+  const MediaSession::Type media_session_type =
+      duration == base::TimeDelta() ||
+              duration >
+                  base::TimeDelta::FromSeconds(kMinimumDurationForContentSecs)
+          ? MediaSession::Type::Content
+          : MediaSession::Type::Transient;
+
+  if (has_session_) {
+    // If we were previously initialized and a different session type has been
+    // requested, release the existing session.
+    if (media_session_type != session_type_) {
+      has_session_ = false;
+      media_session_->RemovePlayer(this, player_id_);
+    } else {
+      // We already have a session of the correct type, so do nothing more.

[mlamouri (slow - plz ping), 2016/01/26 21:02:50]

I think this is might lead to bugs. `session_type_` might be the same as
`media_session_type`. Actually, it should most likely be the same unless the
media's length changed. However, that doesn't mean that the `media_session_`
current type is `session_type_`.

BrowserMediaPlayerManager isn't trying to do much logic before calling
`AddPlayer`. I think you should probably do the same here and call `AddPlayer()`
as often as possible and live it to it to decide if the type changed. The thing
changed a bit since it was designed. We used to assume that a player would be
added once but I think calling `AddPlayer()` for an already added player should
have no side effect.

Maybe you should add a unit test for this? :)

[DaleCurtis, 2016/01/26 21:23:33]

I think we want to be careful about having duplicate players in the session;
otherwise we can get duplicate pause/play events which can frustrate users if
they are delivered between a user interaction to the contrary.

I don't follow what's wrong with this code block. If we got to this point
there's already a MediaSession of the right type active (has_session_ must be
true), no? So this should be a no-op other than the fact that it doesn't insert
duplicate player_ids into the MediaSession. Can you elaborate more on what's
wrong here? Also the MediaSessionController::Reinitialize() test should be
covering this -- I'll extend it to include anything we discuss here :)

[DaleCurtis, 2016/01/26 21:35:08]

Sorted out offline. MediaSession is a stack type data structure. So even if the
session is of the same type we need to move it back up the stack once playback
starts.

[DaleCurtis, 2016/01/27 02:25:13]

Done.

+      return true;
+    }
+  }
+
+  // If a session can't be created, force a pause immediately.
+  if (!media_session_->AddPlayer(this, player_id_, media_session_type)) {
+    OnSuspend(player_id_);
+    return false;
+  }
+
+  session_type_ = media_session_type;
+  has_session_ = true;
+  return true;
+}
+
+void MediaSessionController::OnSuspend(int player_id) {
+  DCHECK_EQ(player_id_, player_id);
+  media_web_contents_observer_->Send(
+      new MediaPlayerDelegateMsg_Pause(id_.first->GetRoutingID(), id_.second));
+}
+
+void MediaSessionController::OnResume(int player_id) {
+  DCHECK_EQ(player_id_, player_id);
+  media_web_contents_observer_->Send(
+      new MediaPlayerDelegateMsg_Play(id_.first->GetRoutingID(), id_.second));
+}
+
+void MediaSessionController::OnSetVolumeMultiplier(int player_id,
+                                                   double volume_multiplier) {
+  DCHECK_EQ(player_id_, player_id);
+  media_web_contents_observer_->Send(
+      new MediaPlayerDelegateMsg_UpdateVolumeMultiplier(
+          id_.first->GetRoutingID(), id_.second, volume_multiplier));
+}
+
+void MediaSessionController::OnPlaybackPaused() {
+  // We check for suspension here since the renderer may issue its own pause
+  // in response to or while a pause from the browser is in flight.
+  if (!media_session_->IsSuspended())
+    media_session_->OnPlayerPaused(this, player_id_);
+}
+
+}  // namespace content