Use MediaCodec.setOutputSurface() for fullscreen transitions on M.

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 318 matching lines @@
     ScheduleRestart();
 }
 
 void WebMediaPlayerImpl::DisableOverlay() {
   overlay_enabled_ = false;
   surface_created_cb_.Cancel();
   overlay_surface_id_ = SurfaceManager::kNoSurfaceID;
 
   if (decoder_requires_restart_for_overlay_)
     ScheduleRestart();
+  else if (!pending_surface_request_cb_.is_null())
+    pending_surface_request_cb_.Run(overlay_surface_id_);
 }
 
 void WebMediaPlayerImpl::enteredFullscreen() {
   if (!force_video_overlays_ && !disable_fullscreen_video_overlays_)
     EnableOverlay();
   if (observer_)
     observer_->OnEnteredFullscreen();
 }
 
 void WebMediaPlayerImpl::exitedFullscreen() {
@@ skipping 1103 matching lines @@
       media_log_->CreateBooleanEvent(
           MediaLogEvent::NETWORK_ACTIVITY_SET,
           "is_downloading_data", is_downloading));
 }
 
 void WebMediaPlayerImpl::OnSurfaceCreated(int surface_id) {
   if (force_video_overlays_ && surface_id == SurfaceManager::kNoSurfaceID)
     LOG(ERROR) << "Create surface failed.";
 
   overlay_surface_id_ = surface_id;
-  if (!pending_surface_request_cb_.is_null())
-    base::ResetAndReturn(&pending_surface_request_cb_).Run(surface_id);
+  if (!pending_surface_request_cb_.is_null()) {
+    if (decoder_requires_restart_for_overlay_)
+      base::ResetAndReturn(&pending_surface_request_cb_).Run(surface_id);
+    else
+      pending_surface_request_cb_.Run(surface_id);
+  }
 }
 
 // TODO(watk): Move this state management out of WMPI.
 void WebMediaPlayerImpl::OnSurfaceRequested(

[watk, 2016/11/03 20:26:34]

Naming suggestion for when the time comes. This feels more like
"SetSurfaceChangeObserver" or something like that to me now. i.e., the decoder
is an observer of surface changes rather than a requester of surfaces.

This changed a while back when we started requesting the surface on fullscreen
transitions instead of in response to this call.

[DaleCurtis, 2016/11/04 01:07:22]

Agreed I don't like the name, but since the mechanism is double duty depending
on platform support it's not always an observer. Will see if I can come up with
a better name.

+    bool decoder_requires_restart_for_overlay,
     const SurfaceCreatedCB& surface_created_cb) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   DCHECK(surface_manager_);
   DCHECK(!use_fallback_path_);
 
   // A null callback indicates that the decoder is going away.
   if (surface_created_cb.is_null()) {
+    DCHECK(!decoder_requires_restart_for_overlay);
     decoder_requires_restart_for_overlay_ = 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_overlay_ = true;
+  decoder_requires_restart_for_overlay_ = decoder_requires_restart_for_overlay;
+  if (!decoder_requires_restart_for_overlay_)
+    pending_surface_request_cb_ = surface_created_cb;
   if (overlay_enabled_) {
     if (overlay_surface_id_ != SurfaceManager::kNoSurfaceID)
       surface_created_cb.Run(overlay_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);
   }
 }
@@ skipping 395 matching lines @@
       pipeline_metadata_.natural_size,
       base::Bind(&GetCurrentTimeInternal, this)));
   watch_time_reporter_->OnVolumeChange(volume_);
   if (delegate_ && delegate_->IsHidden())
     watch_time_reporter_->OnHidden();
   else
     watch_time_reporter_->OnShown();
 }
 
 }  // namespace media