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_.RenderFrameDeleted(render_frame_host);
 }
 
 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 36 matching lines @@
   if (!web_contents()->GetCapturerCount())
     video_power_save_blocker_.reset();
 }
 
 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_);
+  const MediaPlayerId player_id(render_frame_host, delegate_id);
+  const bool removed_audio =
+      RemoveMediaPlayerEntry(player_id, &active_audio_players_);
+  const bool removed_video =
+      RemoveMediaPlayerEntry(player_id, &active_video_players_);
   MaybeReleasePowerSaveBlockers();
 
   if (removed_audio || removed_video) {
     // Notify observers the player has been "paused".
-    static_cast<WebContentsImpl*>(web_contents())->MediaStoppedPlaying(id);
+    static_cast<WebContentsImpl*>(web_contents())
+        ->MediaStoppedPlaying(player_id);
   }
+
+  if (reached_end_of_stream)
+    session_controllers_manager_.OnEnd(player_id);
+  else
+    session_controllers_manager_.OnPause(player_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