Enable SurfaceView fullscreen video on Android with WebMediaPlayerImpl

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 136 matching lines @@
       opaque_(false),
       playback_rate_(0.0),
       paused_(true),
       seeking_(false),
       pending_suspend_(false),
       pending_time_change_(false),
       pending_resume_(false),
       suspending_(false),
       suspended_(false),
       resuming_(false),
+      pending_suspend_resume_cycle_(false),
       ended_(false),
       pending_seek_(false),
       should_notify_time_changed_(false),
+      fullscreen_(false),
+      decoder_requires_restart_for_fullscreen_(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::MessageLoop::current()->task_runner()),
       compositor_(new VideoFrameCompositor(
           compositor_task_runner_,
           BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnNaturalSizeChanged),
           BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnOpacityChanged))),
       encrypted_media_support_(cdm_factory,
                                encrypted_client,
                                params.media_permission(),
                                base::Bind(&WebMediaPlayerImpl::SetCdm,
                                           AsWeakPtr(),
                                           base::Bind(&IgnoreCdmAttached))),
       is_cdm_attached_(false),
-#if defined(OS_ANDROID)  // WMPI_CAST
+#if defined(OS_ANDROID)
+      surface_manager_(nullptr),
+      // WMPI_CAST
       cast_impl_(this, client_, params.context_3d_cb()),
 #endif
       volume_(1.0),
       volume_multiplier_(1.0),
       renderer_factory_(std::move(renderer_factory)) {
   DCHECK(!adjust_allocated_memory_cb_.is_null());
   DCHECK(renderer_factory_);
 
   if (delegate_)
     delegate_id_ = delegate_->AddObserver(this);
@@ skipping 58 matching lines @@
   DVLOG(1) << __FUNCTION__ << "(" << load_type << ", " << url << ", "
            << cors_mode << ")";
   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);
 }
 
+void WebMediaPlayerImpl::enterFullscreen() {
+  fullscreen_ = true;
+  if (decoder_requires_restart_for_fullscreen_)
+    ScheduleRestart();
+}
+
+void WebMediaPlayerImpl::exitedFullscreen() {
+  fullscreen_ = false;
+  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());
 
   GURL gurl(url);
   ReportMetrics(
       load_type, gurl,
       blink::WebStringToGURL(frame_->document().securityOrigin().toString()));
@@ skipping 695 matching lines @@
 
 #if defined(OS_ANDROID)
   if (isRemote()) {
     scoped_refptr<VideoFrame> frame = cast_impl_.GetCastingBanner();
     if (frame) {
       compositor_->PaintFrameUsingOldRenderingPath(frame);
     }
   }
 #endif
 
-  if (pending_resume_) {
+  if (pending_resume_ || pending_suspend_resume_cycle_) {
     pending_resume_ = false;
+    pending_suspend_resume_cycle_ = false;
     Resume();
     return;
   }
 }
 
 void WebMediaPlayerImpl::OnPipelineEnded() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   // Ignore state changes until we've completed all outstanding seeks.
@@ skipping 245 matching lines @@
 
   if (chunk_demuxer_)
     chunk_demuxer_->StartWaitingForSeek(seek_time_);
 
   resuming_ = true;
   pipeline_.Resume(CreateRenderer(), seek_time_,
                    BIND_TO_RENDER_LOOP1(&WebMediaPlayerImpl::OnPipelineSeeked,
                                         time_changed));
 }
 
-#if defined(OS_ANDROID)  // WMPI_CAST
+void WebMediaPlayerImpl::ScheduleRestart() {
+  if (!suspended_ || resuming_) {
+    pending_suspend_resume_cycle_ = true;
+    ScheduleSuspend();
+  }
+}
 
+#if defined(OS_ANDROID)
+// TODO(watk): Move the SurfaceManager and associated state out of WMPI.
+void WebMediaPlayerImpl::SetSurfaceManager(SurfaceManager* surface_manager) {
+  surface_manager_ = surface_manager;
+}
+
+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;
+    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 use the right kind
+  // of surface for the new 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);
+  } else {
+    // Tell the decoder to create its own surface.
+    surface_created_cb.Run(SurfaceManager::kNoSurfaceID);
+  }
+}
+
+// WMPI_CAST
 bool WebMediaPlayerImpl::isRemote() const {
   return cast_impl_.isRemote();
 }
 
 void WebMediaPlayerImpl::SetMediaPlayerManager(
     RendererMediaPlayerManagerInterface* media_player_manager) {
   cast_impl_.SetMediaPlayerManager(media_player_manager);
 }
 
 void WebMediaPlayerImpl::requestRemotePlayback() {
@@ skipping 40 matching lines @@
 gfx::Size WebMediaPlayerImpl::GetCanvasSize() const {
   if (!video_weblayer_)
     return pipeline_metadata_.natural_size;
 
   return video_weblayer_->bounds();
 }
 
 void WebMediaPlayerImpl::SetDeviceScaleFactor(float scale_factor) {
   cast_impl_.SetDeviceScaleFactor(scale_factor);
 }
-#endif  // defined(OS_ANDROID)  // WMPI_CAST
+#endif  // defined(OS_ANDROID)
 
 void WebMediaPlayerImpl::DataSourceInitialized(bool success) {
   DVLOG(1) << __FUNCTION__;
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   if (!success) {
     SetNetworkState(WebMediaPlayer::NetworkStateFormatError);
     return;
   }
 
   StartPipeline();
 }
 
 void WebMediaPlayerImpl::NotifyDownloading(bool is_downloading) {
   DVLOG(1) << __FUNCTION__;
   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));
 }
 
 scoped_ptr<Renderer> WebMediaPlayerImpl::CreateRenderer() {
+  RequestSurfaceCB request_surface_cb;
+#if defined(OS_ANDROID)
+  request_surface_cb =
+      BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnSurfaceRequested);
+#endif
   return renderer_factory_->CreateRenderer(
       media_task_runner_, worker_task_runner_, audio_source_provider_.get(),
-      compositor_);
+      compositor_, request_surface_cb);
 }
 
 void WebMediaPlayerImpl::StartPipeline() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   Demuxer::EncryptedMediaInitDataCB encrypted_media_init_data_cb =
       BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnEncryptedMediaInitData);
 
   // Figure out which demuxer to use.
   if (load_type_ != LoadTypeMediaSource) {
@@ skipping 77 matching lines @@
   client_->durationChanged();
 }
 
 void WebMediaPlayerImpl::OnNaturalSizeChanged(gfx::Size size) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   DCHECK_NE(ready_state_, WebMediaPlayer::ReadyStateHaveNothing);
   TRACE_EVENT0("media", "WebMediaPlayerImpl::OnNaturalSizeChanged");
 
   media_log_->AddEvent(
       media_log_->CreateVideoSizeSetEvent(size.width(), size.height()));
+
+#if defined(OS_ANDROID)
+  if (fullscreen_ && surface_manager_ &&
+      pipeline_metadata_.natural_size != size) {
+    surface_manager_->FullscreenVideoSizeChanged(size);
+  }
+#endif
+
   pipeline_metadata_.natural_size = size;
-
   client_->sizeChanged();
 }
 
 void WebMediaPlayerImpl::OnOpacityChanged(bool opaque) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   DCHECK_NE(ready_state_, WebMediaPlayer::ReadyStateHaveNothing);
 
   opaque_ = opaque;
   // Modify content opaqueness of cc::Layer directly so that
   // SetContentsOpaqueIsFixed is ignored.
@@ skipping 100 matching lines @@
            << ", Video: " << stats.video_memory_usage << ", DataSource: "
            << (data_source_ ? data_source_->GetMemoryUsage() : 0)
            << ", Demuxer: " << demuxer_memory_usage;
 
   const int64_t delta = current_memory_usage - last_reported_memory_usage_;
   last_reported_memory_usage_ = current_memory_usage;
   adjust_allocated_memory_cb_.Run(delta);
 }
 
 }  // namespace media