Always create a ContentVideoView when entering fullscreen on Android

media/blink/webmediaplayer_impl.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 "media/blink/webmediaplayer_impl.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <string>
@@ skipping 159 matching lines @@
       load_type_(LoadTypeURL),
       opaque_(false),
       playback_rate_(0.0),
       paused_(true),
       seeking_(false),
       pending_suspend_resume_cycle_(false),
       ended_(false),
       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),
       delegate_id_(0),
       defer_load_cb_(params.defer_load_cb()),
       context_3d_cb_(params.context_3d_cb()),
       adjust_allocated_memory_cb_(params.adjust_allocated_memory_cb()),
       last_reported_memory_usage_(0),
       supports_save_(true),
       chunk_demuxer_(NULL),
       url_index_(url_index),
       // Threaded compositing isn't enabled universally yet.
       compositor_task_runner_(params.compositor_task_runner()
                                   ? params.compositor_task_runner()
                                   : base::ThreadTaskRunnerHandle::Get()),
       compositor_(new VideoFrameCompositor(compositor_task_runner_)),
       is_cdm_attached_(false),
 #if defined(OS_ANDROID)  // WMPI_CAST
       cast_impl_(this, client_, params.context_3d_cb()),
 #endif
       volume_(1.0),
       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());
   DCHECK(renderer_factory_);
   DCHECK(client_);
 
   if (delegate_)
     delegate_id_ = delegate_->AddObserver(this);
 
   media_log_->AddEvent(
@@ skipping 51 matching lines @@
   if (!defer_load_cb_.is_null()) {
     defer_load_cb_.Run(base::Bind(
         &WebMediaPlayerImpl::DoLoad, AsWeakPtr(), load_type, url, cors_mode));
     return;
   }
   DoLoad(load_type, url, cors_mode);
 }
 
 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
 }
 
 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();
 }
 
 void WebMediaPlayerImpl::DoLoad(LoadType load_type,
                                 const blink::WebURL& url,
                                 CORSMode cors_mode) {
   DVLOG(1) << __FUNCTION__;
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
@@ skipping 656 matching lines @@
   DVLOG(1) << __FUNCTION__;
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   pipeline_metadata_ = metadata;
 
   UMA_HISTOGRAM_ENUMERATION("Media.VideoRotation", metadata.video_rotation,
                             VIDEO_ROTATION_MAX + 1);
   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_);
     video_weblayer_->SetContentsOpaqueIsFixed(true);
     client_->setWebLayer(video_weblayer_.get());
   }
 
   UpdatePlayState();
 }
 
@@ skipping 237 matching lines @@
   if (!is_downloading && network_state_ == WebMediaPlayer::NetworkStateLoading)
     SetNetworkState(WebMediaPlayer::NetworkStateIdle);
   else if (is_downloading && network_state_ == WebMediaPlayer::NetworkStateIdle)
     SetNetworkState(WebMediaPlayer::NetworkStateLoading);
   media_log_->AddEvent(
       media_log_->CreateBooleanEvent(
           MediaLogEvent::NETWORK_ACTIVITY_SET,
           "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) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   DCHECK(surface_manager_);
 
   // 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;
   }
 
   // If we're getting a surface request it means GVD is initializing, so until
   // we get a null surface request, GVD is the active decoder. While that's the
   // case we should restart the pipeline on fullscreen transitions so that when
   // we create a new GVD it will request a surface again and get the right kind
   // of surface for the fullscreen state.
   // TODO(watk): Don't require a pipeline restart to switch surfaces for
   // 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);
   }
 }
 
 std::unique_ptr<Renderer> WebMediaPlayerImpl::CreateRenderer() {
   RequestSurfaceCB request_surface_cb;
 #if defined(OS_ANDROID)
   request_surface_cb =
@@ skipping 355 matching lines @@
   if (isRemote())
     return;
 #endif
 
   // Idle timeout chosen arbitrarily.
   background_pause_timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(5),
                                 this, &WebMediaPlayerImpl::OnPause);
 }
 
 }  // namespace media