Always create a ContentVideoView when entering fullscreen on Android

media/blink/webmediaplayer_impl.cc

Index: media/blink/webmediaplayer_impl.cc
diff --git a/media/blink/webmediaplayer_impl.cc b/media/blink/webmediaplayer_impl.cc
index 199636d3a32406ea11d0b781622d9346ea816404..e050c0868cb78bf922bbff204850be36f22ad666 100644
--- a/media/blink/webmediaplayer_impl.cc
+++ b/media/blink/webmediaplayer_impl.cc
@@ -177,7 +177,6 @@ WebMediaPlayerImpl::WebMediaPlayerImpl(
       should_notify_time_changed_(false),
       fullscreen_(false),
       decoder_requires_restart_for_fullscreen_(false),
-      supports_overlay_fullscreen_video_(false),
       client_(client),
       encrypted_client_(encrypted_client),
       delegate_(delegate),
@@ -202,6 +201,7 @@ WebMediaPlayerImpl::WebMediaPlayerImpl(
       volume_multiplier_(1.0),
       renderer_factory_(std::move(renderer_factory)),
       surface_manager_(params.surface_manager()),
+      fullscreen_surface_id_(SurfaceManager::kNoSurfaceID),
       suppress_destruction_errors_(false),
       can_suspend_state_(CanSuspendState::UNKNOWN) {
   DCHECK(!adjust_allocated_memory_cb_.is_null());
@@ -273,22 +273,7 @@ void WebMediaPlayerImpl::load(LoadType load_type,
 
 bool WebMediaPlayerImpl::supportsOverlayFullscreenVideo() {
 #if defined(OS_ANDROID)
-  // OverlayFullscreenVideo is only used when we're H/W decoding to an
-  // SurfaceView underlay on Android. It's possible that we haven't initialized
-  // any decoders before entering fullscreen, so we won't know whether to use
-  // OverlayFullscreenVideo. In that case we'll default to
-  // non-OverlayFullscreenVideo, which still works correctly, but has janky
-  // orientation changes.
-
-  // We return a consistent value while in fullscreen to avoid us getting into a
-  // state where some of the OverlayFullscreenVideo adjustments are applied and
-  // some aren't.
-  // TODO(watk): Implement dynamic OverlayFullscreenVideo switching in blink.
-  if (!fullscreen_) {
-    supports_overlay_fullscreen_video_ =
-        decoder_requires_restart_for_fullscreen_;
-  }
-  return supports_overlay_fullscreen_video_;
+  return true;
 #else
   return false;
 #endif
@@ -296,12 +281,18 @@ bool WebMediaPlayerImpl::supportsOverlayFullscreenVideo() {
 
 void WebMediaPlayerImpl::enteredFullscreen() {
   fullscreen_ = true;
+  if (surface_manager_) {
+    surface_manager_->CreateFullscreenSurface(
+        pipeline_metadata_.natural_size,
+        base::Bind(&WebMediaPlayerImpl::OnSurfaceCreated, AsWeakPtr()));
+  }
   if (decoder_requires_restart_for_fullscreen_)
     ScheduleRestart();
 }
 
 void WebMediaPlayerImpl::exitedFullscreen() {
   fullscreen_ = false;
+  fullscreen_surface_id_ = SurfaceManager::kNoSurfaceID;

[sandersd (OOO until July 31), 2016/06/23 22:50:51]

If we enter and exit fullscreen fast enough, it looks like this clearing might
be overwritten. In that case, the next time we fullscreen we could use the wrong
surface ID.

Ideally the surface request would be cancelable in some way.

[watk, 2016/06/24 20:26:17]

Done.

   if (decoder_requires_restart_for_fullscreen_)
     ScheduleRestart();
 }
@@ -978,14 +969,16 @@ void WebMediaPlayerImpl::OnMetadata(PipelineMetadata metadata) {
   SetReadyState(WebMediaPlayer::ReadyStateHaveMetadata);
 
   if (hasVideo()) {
-    DCHECK(!video_weblayer_);
-
     if (pipeline_metadata_.video_rotation == VIDEO_ROTATION_90 ||
         pipeline_metadata_.video_rotation == VIDEO_ROTATION_270) {
       gfx::Size size = pipeline_metadata_.natural_size;
       pipeline_metadata_.natural_size = gfx::Size(size.height(), size.width());
     }
 
+    if (fullscreen_ && surface_manager_)
+      surface_manager_->NaturalSizeChanged(pipeline_metadata_.natural_size);
+
+    DCHECK(!video_weblayer_);
     video_weblayer_.reset(new cc_blink::WebLayerImpl(cc::VideoLayer::Create(
         compositor_, pipeline_metadata_.video_rotation)));
     video_weblayer_->layer()->SetContentsOpaque(opaque_);
@@ -1243,6 +1236,12 @@ void WebMediaPlayerImpl::NotifyDownloading(bool is_downloading) {
           "is_downloading_data", is_downloading));
 }
 
+void WebMediaPlayerImpl::OnSurfaceCreated(int surface_id) {
+  fullscreen_surface_id_ = surface_id;
+  if (!pending_surface_request_cb_.is_null())
+    base::ResetAndReturn(&pending_surface_request_cb_).Run(surface_id);
+}
+
 // TODO(watk): Move this state management out of WMPI.
 void WebMediaPlayerImpl::OnSurfaceRequested(
     const SurfaceCreatedCB& surface_created_cb) {
@@ -1252,6 +1251,7 @@ void WebMediaPlayerImpl::OnSurfaceRequested(
   // A null callback indicates that the decoder is going away.
   if (surface_created_cb.is_null()) {
     decoder_requires_restart_for_fullscreen_ = false;
+    pending_surface_request_cb_.Reset();
     return;
   }
 
@@ -1264,8 +1264,10 @@ void WebMediaPlayerImpl::OnSurfaceRequested(
   // cases where it isn't necessary.
   decoder_requires_restart_for_fullscreen_ = true;
   if (fullscreen_) {
-    surface_manager_->CreateFullscreenSurface(pipeline_metadata_.natural_size,
-                                              surface_created_cb);
+    if (fullscreen_surface_id_ != SurfaceManager::kNoSurfaceID)
+      surface_created_cb.Run(fullscreen_surface_id_);
+    else
+      pending_surface_request_cb_ = surface_created_cb;
   } else {
     // Tell the decoder to create its own surface.
     surface_created_cb.Run(SurfaceManager::kNoSurfaceID);