Restart fullscreen video playback when switching back from background

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/media_player_messages_android.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 "ui/gfx/rect_f.h"
 
 namespace content {
 
 RendererMediaPlayerManager::RendererMediaPlayerManager(RenderView* render_view)
     : RenderViewObserver(render_view),
       next_media_player_id_(0),
+      fullscreen_player_id_(-1),
+      paused_fullscreen_player_id_(-1),
       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();
   }
 
@@ skipping 151 matching lines @@
 }
 
 void RendererMediaPlayerManager::OnDisconnectedFromRemoteDevice(int player_id) {
   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
   if (player)
     player->OnDisconnectedFromRemoteDevice();
 }
 
 void RendererMediaPlayerManager::OnDidEnterFullscreen(int player_id) {
   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
-  if (player)
+  if (player) {
+    fullscreen_player_id_ = player_id;
     player->OnDidEnterFullscreen();
+  }
 }
 
 void RendererMediaPlayerManager::OnDidExitFullscreen(int player_id) {
   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
-  if (player)
+  if (player) {
+    fullscreen_player_id_ = -1;
     player->OnDidExitFullscreen();
+  }
 }
 
 void RendererMediaPlayerManager::OnPlayerPlay(int player_id) {
   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
   if (player)
     player->OnMediaPlayerPlay();
 }
 
 void RendererMediaPlayerManager::OnPlayerPause(int player_id) {
   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
   if (player)
     player->OnMediaPlayerPause();
 }
 
 void RendererMediaPlayerManager::OnRequestFullscreen(int player_id) {
   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
   if (player)
     player->OnRequestFullscreen();
 }
 
 void RendererMediaPlayerManager::EnterFullscreen(int player_id) {
   Send(new MediaPlayerHostMsg_EnterFullscreen(routing_id(), player_id));
 }
 
 void RendererMediaPlayerManager::ExitFullscreen(int player_id) {
+  DCHECK(player_id == fullscreen_player_id_);
   Send(new MediaPlayerHostMsg_ExitFullscreen(routing_id(), player_id));
 }
 
 void RendererMediaPlayerManager::InitializeCDM(int media_keys_id,
                                                ProxyMediaKeys* media_keys,
                                                const std::vector<uint8>& uuid,
                                                const GURL& frame_url) {
   RegisterMediaKeys(media_keys_id, media_keys);
   Send(new MediaKeysHostMsg_InitializeCDM(
       routing_id(), media_keys_id, uuid, frame_url));
@@ skipping 82 matching lines @@
   // |media_keys_id|. For now |media_keys_id| is the same as player_id
   // used in other methods.
   DCHECK(media_players_.find(media_keys_id) != media_players_.end());
 
   // Only allowed to register once.
   DCHECK(media_keys_.find(media_keys_id) == media_keys_.end());
 
   media_keys_[media_keys_id] = media_keys;
 }
 
-void RendererMediaPlayerManager::ReleaseVideoResources() {

[qinmin, 2013/12/05 23:02:34]

I don't think this is right. This function is not only for fullscreen video, it
also works for embedded video. After your change, now it only pauses the
fullscreen video， and not actually releasing the MediaPlayer resources. This
will cause issues for other apps.
We should still release the media player, and reacquire the resource when we
restart the app. Calling MediaPlayerBridge.SetVideoSurface() will automatically
create the new MediaPlayer, so the only thing we need to do is call
enterfullscreen() when app restarts.

[kbalazs, 2013/12/05 23:36:22]

I think you misread it, there is no early return for the fullscreen player, it
will still be released in the loop below :)

[qinmin, 2013/12/06 00:10:13]

ah...sorry, i thought you were removing the original function.  But we should
not rename this function to PauseVideo(). All the video resources are freed by
this funtion, and we have a separate pause() function inside
WebMediaPlayerAndroid and MediaPlayerBridge, we should not mix the usage of
these two. 

On 2013/12/05 23:36:22, kbalazs wrote:

[kbalazs, 2013/12/06 19:15:03]

Done, I moved the new code into SuspendFullscreenVideo.

On 2013/12/06 00:10:13, qinmin wrote:

+void RendererMediaPlayerManager::PauseVideo() {
+  if (fullscreen_player_id_ != -1) {
+    ExitFullscreen(fullscreen_player_id_);
+    paused_fullscreen_player_id_ = fullscreen_player_id_;
+  }
+
   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;
 
     // Do not release if an audio track is still playing
     if (player && (player->paused() || player->hasVideo()))
       player->ReleaseMediaResources();
   }
 }
 
+void RendererMediaPlayerManager::ResumeVideo() {
+  if (paused_fullscreen_player_id_ != -1) {
+    EnterFullscreen(paused_fullscreen_player_id_);
+    paused_fullscreen_player_id_ = -1;
+  }
+}
+
 WebMediaPlayerAndroid* RendererMediaPlayerManager::GetMediaPlayer(
     int player_id) {
   std::map<int, WebMediaPlayerAndroid*>::iterator iter =
       media_players_.find(player_id);
   if (iter != media_players_.end())
     return iter->second;
   return NULL;
 }
 
 ProxyMediaKeys* RendererMediaPlayerManager::GetMediaKeys(int media_keys_id) {
@@ skipping 50 matching lines @@
       gfx::RectF rect;
       if (player->RetrieveGeometryChange(&rect)) {
         (*changes)[player_it->first] = rect;
       }
     }
   }
 }
 #endif
 
 }  // namespace content