Make RendererMediaPlayerManager a RenderFrameObserver.

content/renderer/media/android/renderer_media_player_manager.cc

 // Copyright 2013 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/renderer/media/android/renderer_media_player_manager.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "content/common/media/cdm_messages.h"
 #include "content/common/media/media_player_messages_android.h"
 #include "content/public/common/renderer_preferences.h"
 #include "content/renderer/media/android/proxy_media_keys.h"
 #include "content/renderer/media/android/renderer_media_player_manager.h"
 #include "content/renderer/media/android/webmediaplayer_android.h"
 #include "content/renderer/render_view_impl.h"
 #include "ui/gfx/rect_f.h"
 
 namespace content {
 
 // Maximum sizes for various EME API parameters. These are checks to prevent
 // unnecessarily large messages from being passed around, and the sizes
 // are somewhat arbitrary as the EME spec doesn't specify any limits.
 const size_t kMaxWebSessionIdLength = 512;
 const size_t kMaxSessionMessageLength = 10240;  // 10 KB
 
-RendererMediaPlayerManager::RendererMediaPlayerManager(RenderView* render_view)
-    : RenderViewObserver(render_view),
+RendererMediaPlayerManager::RendererMediaPlayerManager(
+    RenderFrame* render_frame)
+    : RenderFrameObserver(render_frame),
       next_media_player_id_(0),
       fullscreen_frame_(NULL),
-      pending_fullscreen_frame_(NULL) {}
+      pending_fullscreen_frame_(NULL) {
+}
 
 RendererMediaPlayerManager::~RendererMediaPlayerManager() {
   std::map<int, WebMediaPlayerAndroid*>::iterator player_it;
   for (player_it = media_players_.begin();
       player_it != media_players_.end(); ++player_it) {
     WebMediaPlayerAndroid* player = player_it->second;
     player->Detach();
   }
 
   Send(new MediaPlayerHostMsg_DestroyAllMediaPlayers(routing_id()));
@@ skipping 19 matching lines @@
     IPC_MESSAGE_HANDLER(MediaPlayerMsg_ConnectedToRemoteDevice,
                         OnConnectedToRemoteDevice)
     IPC_MESSAGE_HANDLER(MediaPlayerMsg_DisconnectedFromRemoteDevice,
                         OnDisconnectedFromRemoteDevice)
     IPC_MESSAGE_HANDLER(MediaPlayerMsg_RequestFullscreen,
                         OnRequestFullscreen)
     IPC_MESSAGE_HANDLER(MediaPlayerMsg_DidEnterFullscreen, OnDidEnterFullscreen)
     IPC_MESSAGE_HANDLER(MediaPlayerMsg_DidExitFullscreen, OnDidExitFullscreen)
     IPC_MESSAGE_HANDLER(MediaPlayerMsg_DidMediaPlayerPlay, OnPlayerPlay)
     IPC_MESSAGE_HANDLER(MediaPlayerMsg_DidMediaPlayerPause, OnPlayerPause)
+    IPC_MESSAGE_HANDLER(MediaPlayerMsg_PauseVideo, OnPauseVideo)
     IPC_MESSAGE_HANDLER(CdmMsg_SessionCreated, OnSessionCreated)
     IPC_MESSAGE_HANDLER(CdmMsg_SessionMessage, OnSessionMessage)
     IPC_MESSAGE_HANDLER(CdmMsg_SessionReady, OnSessionReady)
     IPC_MESSAGE_HANDLER(CdmMsg_SessionClosed, OnSessionClosed)
     IPC_MESSAGE_HANDLER(CdmMsg_SessionError, OnSessionError)
   IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
@@ skipping 144 matching lines @@
   if (player)
     player->OnMediaPlayerPause();
 }
 
 void RendererMediaPlayerManager::OnRequestFullscreen(int player_id) {
   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
   if (player)
     player->OnRequestFullscreen();
 }
 
+void RendererMediaPlayerManager::OnPauseVideo() {
+  ReleaseVideoResources();
+}
+
 void RendererMediaPlayerManager::EnterFullscreen(int player_id,
                                                  blink::WebFrame* frame) {
   pending_fullscreen_frame_ = frame;
   Send(new MediaPlayerHostMsg_EnterFullscreen(routing_id(), player_id));
 }
 
 void RendererMediaPlayerManager::ExitFullscreen(int player_id) {
   pending_fullscreen_frame_ = NULL;
   fullscreen_frame_ = NULL;
   Send(new MediaPlayerHostMsg_ExitFullscreen(routing_id(), player_id));
@@ skipping 110 matching lines @@
 void RendererMediaPlayerManager::RegisterMediaKeys(int cdm_id,
                                                    ProxyMediaKeys* media_keys) {
   // Only allowed to register once.
   DCHECK(media_keys_.find(cdm_id) == media_keys_.end());
 
   media_keys_[cdm_id] = media_keys;
 }
 
 void RendererMediaPlayerManager::ReleaseVideoResources() {
   std::map<int, WebMediaPlayerAndroid*>::iterator player_it;
-  for (player_it = media_players_.begin();
-      player_it != media_players_.end(); ++player_it) {
+  for (player_it = media_players_.begin(); player_it != media_players_.end();
+       ++player_it) {
     WebMediaPlayerAndroid* player = player_it->second;
 
     // Do not release if an audio track is still playing
     if (player && (player->paused() || player->hasVideo()))
       player->ReleaseMediaResources();
   }
 }
 
 WebMediaPlayerAndroid* RendererMediaPlayerManager::GetMediaPlayer(
     int player_id) {
@@ skipping 61 matching lines @@
 
     if (player && player->hasVideo()) {
       if (player->UpdateBoundaryRectangle())
         (*changes)[player_it->first] = player->GetBoundaryRectangle();
     }
   }
 }
 
 bool
 RendererMediaPlayerManager::ShouldUseVideoOverlayForEmbeddedEncryptedVideo() {
-  const RendererPreferences& prefs = static_cast<RenderViewImpl*>(
-      render_view())->renderer_preferences();
+  const RendererPreferences& prefs = static_cast<RenderFrameImpl*>(
+      render_frame())->render_view()->renderer_preferences();
   return prefs.use_video_overlay_for_embedded_encrypted_video;
 }
 #endif  // defined(VIDEO_HOLE)
 
 }  // namespace content