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),
       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
       cast_impl_(this, client_, params.context_3d_cb(), delegate),
 #endif
-      renderer_factory_(std::move(renderer_factory)) {
+      renderer_factory_(std::move(renderer_factory)),
+      surface_manager_(params.surface_manager()) {
   DCHECK(!adjust_allocated_memory_cb_.is_null());
   DCHECK(renderer_factory_);
 
   if (delegate)
     delegate->AddObserver(this);
 
   media_log_->AddEvent(
       media_log_->CreateEvent(MediaLogEvent::WEBMEDIAPLAYER_CREATED));
 
   if (params.initial_cdm()) {
@@ skipping 53 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 689 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 230 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));
 }
 
+void WebMediaPlayerImpl::ScheduleRestart() {
+  pending_suspend_resume_cycle_ = true;

[DaleCurtis, 2016/02/02 01:01:33]

Why not just use |pending_resume| ?

[watk, 2016/02/02 20:38:14]

I wish I wrote a comment because I've already forgotten the details :P 

This should change after Dan's pipeline controller CL lands anyway.

[watk, 2016/02/05 03:42:30]

Added some comments for this.

+  ScheduleSuspend();
+}
+
 #if defined(OS_ANDROID)  // WMPI_CAST
 
 bool WebMediaPlayerImpl::isRemote() const {
   return cast_impl_.isRemote();
 }
 
 void WebMediaPlayerImpl::SetMediaPlayerManager(
     RendererMediaPlayerManagerInterface* media_player_manager) {
   cast_impl_.SetMediaPlayerManager(media_player_manager);
 }
@@ skipping 68 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::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;
+  }
+
+  decoder_requires_restart_for_fullscreen_ = true;

[liberato (no reviews please), 2016/02/02 22:46:57]

is this being set unconditionally so that EnterFullscreen knows to restart?  in
other words, when we start in non-fullscreen, GVD will request a surface, and
get NoSurface but cause |decoder_requires...| to be set.

then, when we enter full screen, WMPI will remember and restart the GVD so that
it can ask for a surface again (this time, successfully).

we don't want to have this sort of state in wmpi for too long.  as a follow-up
to this CL, let's figure out how to put it into at least GVD.  there, it has
access to the VDA config flags.  since WMPI<->GVD communication is easy, it
shouldn't be too hard to move this out of WMPI.

replacing |request_surface_cb| with an interface that exposes
SetEnterFullScreenCB, and RequestRestart that GVD can call will greatly clean up
WMPI, i believe.

but, again, i'm talking about the next CL.

[watk, 2016/02/05 03:42:30]

Yep, your assessment was correct. I tried to comment it clearly now.

Also I totally agree with the future direction.

+  if (fullscreen_)
+    surface_manager_->CreateFullscreenSurface(surface_created_cb);
+  else
+    surface_created_cb.Run(SurfaceManager::kNoSurfaceID);
+}
+
 scoped_ptr<Renderer> WebMediaPlayerImpl::CreateRenderer() {
   return renderer_factory_->CreateRenderer(
       media_task_runner_, worker_task_runner_, audio_source_provider_.get(),
-      compositor_);
+      compositor_,
+      BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnSurfaceRequested));

[liberato (no reviews please), 2016/02/02 22:46:57]

should this be #if android?  otherwise, it looks like the gvd always gets a
|request_surface_cb|, which causes it to always request a surface, which causes
|decoder_requires_restart_for_fullscreen_|, which causes badness.

[watk, 2016/02/05 03:42:30]

Done.

 }
 
 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 197 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