Make MediaSession a runtime-enabled feature on Desktop.

content/browser/media/media_web_contents_observer.cc

 // Copyright 2014 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/media_web_contents_observer.h"
 
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "build/build_config.h"
 #include "content/browser/media/audible_metrics.h"
 #include "content/browser/media/audio_stream_monitor.h"
 #include "content/browser/power_save_blocker_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/common/media/media_player_delegate_messages.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "ipc/ipc_message_macros.h"
 
 namespace content {
 
 namespace {
 
 static base::LazyInstance<AudibleMetrics>::Leaky g_audible_metrics =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // anonymous namespace
 
 MediaWebContentsObserver::MediaWebContentsObserver(WebContents* web_contents)
-    : WebContentsObserver(web_contents) {}
+    : WebContentsObserver(web_contents),
+      session_controllers_manager_(this) {}
 
 MediaWebContentsObserver::~MediaWebContentsObserver() {}
 
 void MediaWebContentsObserver::WebContentsDestroyed() {
   g_audible_metrics.Get().UpdateAudibleWebContentsState(web_contents(), false);
 }
 
 void MediaWebContentsObserver::RenderFrameDeleted(
     RenderFrameHost* render_frame_host) {
   ClearPowerSaveBlockers(render_frame_host);
+  session_controllers_manager_.Clear(render_frame_host);

[DaleCurtis, 2016/02/17 20:16:54]

We are now mixing a pattern of a delegate, 2 managers, and a controller for
MediaSession. It has a bit of smell to it :( It seems these layers should be
folded away, not added too. I don't have a concrete suggestion though. My
thought at the start of this all was that MediaSessionManager should do more
than it does today.

[mlamouri (slow - plz ping), 2016/02/23 20:27:55]

The delegate is really because of platform dependant implementations. This thing
is the first "manager", though I guess you consider content::MediaSession as a
manager?

Otherwise, regarding MediaSessionControllersManager, I think it helps make the
code simpler in MediaWebContentsObserver. It also allow re-use in
MediaWebContentsObserverAndroid. This said, I would be willing to refactor that
if you have some ideas. Maybe in another CL though to not make this even larger.

 }
 
 void MediaWebContentsObserver::MaybeUpdateAudibleState() {
   if (!AudioStreamMonitor::monitoring_available())
     return;
 
   AudioStreamMonitor* audio_stream_monitor =
       static_cast<WebContentsImpl*>(web_contents())->audio_stream_monitor();
 
   if (audio_stream_monitor->WasRecentlyAudible()) {
@@ skipping 30 matching lines @@
     CreateVideoPowerSaveBlocker();
 }
 
 void MediaWebContentsObserver::WasHidden() {
   // If there are entities capturing screenshots or video (e.g., mirroring),
   // don't release the power save blocker.
   if (!web_contents()->GetCapturerCount())
     video_power_save_blocker_.reset();
 }
 
+#if defined(OS_ANDROID)
+bool MediaWebContentsObserver::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.

[DaleCurtis, 2016/02/17 20:16:54]

This no longer does quite the right thing, we don't want to force another
OnMediaPlaying() here since it will trip the power save blocker additions.
Previously it only ran the android variant of this code, now it runs both (power
save blocker + session controller addition).

[mlamouri (slow - plz ping), 2016/02/23 20:27:55]

This is actually neatly solved with the MediaSessionControllersManager: just
call .RequestPlay() instead of going back to ::OnMediayPlaying().

+  OnMediaPlaying(render_frame_host, delegate_id, true, has_audio, is_remote,
+                 duration);
+  return media_session_map_.find(MediaPlayerId(

[DaleCurtis, 2016/02/17 20:16:54]

No media_session_map_ anymore.

[mlamouri (slow - plz ping), 2016/02/23 20:27:55]

Done.

+             render_frame_host, delegate_id)) != media_session_map_.end();
+}
+#endif // OS_ANDROID
+
 void MediaWebContentsObserver::OnMediaDestroyed(
     RenderFrameHost* render_frame_host,
     int delegate_id) {
   OnMediaPaused(render_frame_host, delegate_id, true);
 }
 
-
 void MediaWebContentsObserver::OnMediaPaused(RenderFrameHost* render_frame_host,
                                              int delegate_id,
                                              bool reached_end_of_stream) {
   const MediaPlayerId id(render_frame_host, delegate_id);
   const bool removed_audio = RemoveMediaPlayerEntry(id, &active_audio_players_);
   const bool removed_video = RemoveMediaPlayerEntry(id, &active_video_players_);
   MaybeReleasePowerSaveBlockers();
 
   if (removed_audio || removed_video) {
     // Notify observers the player has been "paused".
     static_cast<WebContentsImpl*>(web_contents())->MediaStoppedPlaying(id);
   }
+
+  if (reached_end_of_stream)
+    session_controllers_manager_.OnEnd(id);
+  else
+    session_controllers_manager_.OnPause(id);
 }
 
 void MediaWebContentsObserver::OnMediaPlaying(
     RenderFrameHost* render_frame_host,
     int delegate_id,
     bool has_video,
     bool has_audio,
     bool is_remote,
     base::TimeDelta duration) {
   // Ignore the videos playing remotely and don't hold the wake lock for the
@@ skipping 17 matching lines @@
   if (has_video) {
     AddMediaPlayerEntry(id, &active_video_players_);
 
     // If we're not hidden and have just created a player, create a blocker.
     if (!video_power_save_blocker_ &&
         !static_cast<WebContentsImpl*>(web_contents())->IsHidden()) {
       CreateVideoPowerSaveBlocker();
     }
   }
 
+  if (!session_controllers_manager_.RequestPlay(
+      id, has_audio, is_remote, duration)) {
+    return;
+  }
+
   // Notify observers of the new player.
   DCHECK(has_audio || has_video);
   static_cast<WebContentsImpl*>(web_contents())->MediaStartedPlaying(id);
 }
 
 void MediaWebContentsObserver::ClearPowerSaveBlockers(
     RenderFrameHost* render_frame_host) {
   std::set<MediaPlayerId> removed_players;
   RemoveAllMediaPlayerEntries(render_frame_host, &active_audio_players_,
                               &removed_players);
@@ skipping 78 matching lines @@
   if (it == player_map->end())
     return;
 
   for (int delegate_id : it->second)
     removed_players->insert(MediaPlayerId(render_frame_host, delegate_id));
 
   player_map->erase(it);
 }
 
 }  // namespace content