Provide a WebContents API to discover the playback of a fullscreen video.

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 <memory>
 
 #include "build/build_config.h"
 #include "content/browser/media/audible_metrics.h"
@@ skipping 13 matching lines @@
   static AudibleMetrics* metrics = new AudibleMetrics();
   return metrics;
 }
 
 }  // anonymous namespace
 
 MediaWebContentsObserver::MediaWebContentsObserver(WebContents* web_contents)
     : WebContentsObserver(web_contents),
       session_controllers_manager_(this) {}
 
-MediaWebContentsObserver::~MediaWebContentsObserver() {}
+MediaWebContentsObserver::~MediaWebContentsObserver() = default;
 
 void MediaWebContentsObserver::WebContentsDestroyed() {
   GetAudibleMetrics()->UpdateAudibleWebContentsState(web_contents(), false);
 }
 
 void MediaWebContentsObserver::RenderFrameDeleted(
     RenderFrameHost* render_frame_host) {
   ClearPowerSaveBlockers(render_frame_host);
   session_controllers_manager_.RenderFrameDeleted(render_frame_host);
+
+  if (fullscreen_dominant_video_.first.first == render_frame_host)
+    fullscreen_dominant_video_.first = MediaPlayerId(nullptr, 0);
 }
 
 void MediaWebContentsObserver::MaybeUpdateAudibleState() {
   AudioStreamMonitor* audio_stream_monitor =
       static_cast<WebContentsImpl*>(web_contents())->audio_stream_monitor();
 
   if (audio_stream_monitor->WasRecentlyAudible()) {
     if (!audio_power_save_blocker_)
       CreateAudioPowerSaveBlocker();
   } else {
     audio_power_save_blocker_.reset();
   }
 
   GetAudibleMetrics()->UpdateAudibleWebContentsState(
       web_contents(), audio_stream_monitor->IsCurrentlyAudible());
 }
 
+bool MediaWebContentsObserver::HasActiveFullscreenDominantVideo() const {
+  DCHECK(web_contents()->IsFullscreen());
+
+  // First check if there is a fullscreen or dominant video registered.
+  if (fullscreen_dominant_video_.first.first == nullptr)
+    return false;
+  if (!fullscreen_dominant_video_.second.fullscreen &&
+      !fullscreen_dominant_video_.second.dominant) {
+    return false;
+  }
+
+  // It has to be active.
+  const auto& players =
+      active_video_players_.find(fullscreen_dominant_video_.first.first);
+  if (players == active_video_players_.end())
+    return false;
+  if (players->second.find(fullscreen_dominant_video_.first.second) ==
+      players->second.end())
+    return false;
+
+  return true;
+}
+
 bool MediaWebContentsObserver::OnMessageReceived(
     const IPC::Message& msg,
     RenderFrameHost* render_frame_host) {
   bool handled = true;
   // TODO(dalecurtis): These should no longer be FrameHostMsg.
   IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(MediaWebContentsObserver, msg,
                                    render_frame_host)
     IPC_MESSAGE_HANDLER(MediaPlayerDelegateHostMsg_OnMediaDestroyed,
                         OnMediaDestroyed)
     IPC_MESSAGE_HANDLER(MediaPlayerDelegateHostMsg_OnMediaPaused, OnMediaPaused)
     IPC_MESSAGE_HANDLER(MediaPlayerDelegateHostMsg_OnMediaPlaying,
                         OnMediaPlaying)
+    IPC_MESSAGE_HANDLER(MediaPlayerDelegateHostMsg_OnMediaFullscreenChange,
+                        OnMediaFullscreenChange)
+    IPC_MESSAGE_HANDLER(MediaPlayerDelegateHostMsg_OnMediaDominantChange,
+                        OnMediaDominantChange)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void MediaWebContentsObserver::WasShown() {
   // Restore power save blocker if there are active video players running.
   if (!active_video_players_.empty() && !video_power_save_blocker_)
     CreateVideoPowerSaveBlocker();
 }
@@ skipping 66 matching lines @@
     return;
   }
 
   // Notify observers of the new player.
   DCHECK(has_audio || has_video);
   static_cast<WebContentsImpl*>(web_contents())
       ->MediaStartedPlaying(WebContentsObserver::MediaPlayerInfo(has_video),
                             id);
 }
 
+void MediaWebContentsObserver::OnMediaFullscreenChange(
+    RenderFrameHost* render_frame_host,
+    int delegate_id,
+    bool is_fullscreen) {
+  const MediaPlayerId id(render_frame_host, delegate_id);
+
+  if (fullscreen_dominant_video_.first == id) {
+    fullscreen_dominant_video_.second.fullscreen = is_fullscreen;
+  } else if (is_fullscreen) {
+    fullscreen_dominant_video_.first = id;
+    fullscreen_dominant_video_.second = FullscreenDominantInfo(true, false);
+  }
+}
+
+void MediaWebContentsObserver::OnMediaDominantChange(
+    RenderFrameHost* render_frame_host,
+    int delegate_id,
+    bool is_dominant) {
+  const MediaPlayerId id(render_frame_host, delegate_id);
+
+  if (fullscreen_dominant_video_.first == id) {
+    fullscreen_dominant_video_.second.dominant = is_dominant;
+  } else if (is_dominant) {
+    fullscreen_dominant_video_.first = id;
+    fullscreen_dominant_video_.second = FullscreenDominantInfo(false, true);
+  }
+}
+
 void MediaWebContentsObserver::ClearPowerSaveBlockers(
     RenderFrameHost* render_frame_host) {
   std::set<MediaPlayerId> removed_players;
   RemoveAllMediaPlayerEntries(render_frame_host, &active_video_players_,
                               &removed_players);
   std::set<MediaPlayerId> video_players(removed_players);
   RemoveAllMediaPlayerEntries(render_frame_host, &active_audio_players_,
                               &removed_players);
   MaybeReleasePowerSaveBlockers();
 
@@ skipping 71 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