Fix fullscreen video race condition.

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"
 
 // Maximum sizes for various EME message parameters. These are checks to
 // prevent unnecessarily large messages from being passed around, and the sizes
 // are somewhat arbitrary as the EME specification doesn't specify any limits.
 static const size_t kEmeWebSessionIdMaximum = 512;
 static const size_t kEmeMessageMaximum = 10240;  // 10 KB
 static const size_t kEmeDestinationUrlMaximum = 2048;  // 2 KB
 
 namespace content {
 
 RendererMediaPlayerManager::RendererMediaPlayerManager(RenderView* render_view)
     : RenderViewObserver(render_view),
       next_media_player_id_(0),
-      fullscreen_frame_(NULL) {}
+      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 178 matching lines @@
   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) {
+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) {
   Send(new MediaPlayerHostMsg_ExitFullscreen(routing_id(), player_id));
 }
 
 void RendererMediaPlayerManager::InitializeCDM(int media_keys_id,
                                                ProxyMediaKeys* media_keys,
                                                const std::vector<uint8>& uuid,
@@ skipping 141 matching lines @@
   std::map<int, ProxyMediaKeys*>::iterator iter =
       media_keys_.find(media_keys_id);
   return (iter != media_keys_.end()) ? iter->second : NULL;
 }
 
 bool RendererMediaPlayerManager::CanEnterFullscreen(blink::WebFrame* frame) {
   return !fullscreen_frame_ || IsInFullscreen(frame);
 }
 
 void RendererMediaPlayerManager::DidEnterFullscreen(blink::WebFrame* frame) {
+  pending_fullscreen_frame_ = NULL;

[qinmin, 2014/01/28 17:41:34]

what if ExitFullscreen() is called before this call? Since
pending_fullscreen_frame_ is non-null, if another video element calls
RequestFullscreen(), it wouldn't be able to do so immediately after we fix
CanEnterFullscreen().

   fullscreen_frame_ = frame;
 }
 
 void RendererMediaPlayerManager::DidExitFullscreen() {
   fullscreen_frame_ = NULL;
 }
 
 bool RendererMediaPlayerManager::IsInFullscreen(blink::WebFrame* frame) {
   return fullscreen_frame_ == frame;
 }
 
+bool RendererMediaPlayerManager::ShouldEnterFullscreen(blink::WebFrame* frame) {

[qinmin, 2014/01/28 17:41:34]

This logic is also needed for CanEnterFullscreen(), I think we should merge
these two functions.

+  return fullscreen_frame_ == frame || pending_fullscreen_frame_ == frame;
+}
+
 #if defined(VIDEO_HOLE)
 void RendererMediaPlayerManager::RequestExternalSurface(
     int player_id,
     const gfx::RectF& geometry) {
   Send(new MediaPlayerHostMsg_NotifyExternalSurface(
       routing_id(), player_id, true, geometry));
 }
 
 void RendererMediaPlayerManager::DidCommitCompositorFrame() {
   std::map<int, gfx::RectF> geometry_change;
@@ skipping 19 matching lines @@
       gfx::RectF rect;
       if (player->RetrieveGeometryChange(&rect)) {
         (*changes)[player_it->first] = rect;
       }
     }
   }
 }
 #endif  // defined(VIDEO_HOLE)
 
 }  // namespace content