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

media/filters/gpu_video_decoder.cc

Index: media/filters/gpu_video_decoder.cc
diff --git a/media/filters/gpu_video_decoder.cc b/media/filters/gpu_video_decoder.cc
index 7e7144f4ffa3acc832a9715bf10d78c5ba0faf67..60efc8d3b07b7bd3d424761324a2a8c33940d0ab 100644
--- a/media/filters/gpu_video_decoder.cc
+++ b/media/filters/gpu_video_decoder.cc
@@ -36,6 +36,10 @@
 #include "media/formats/mp4/box_definitions.h"
 #endif
 
+#if defined(OS_ANDROID)
+#include "base/android/build_info.h"
+#endif
+
 namespace media {
 namespace {
 
@@ -212,12 +216,16 @@ void GpuVideoDecoder::Initialize(const VideoDecoderConfig& config,
       base::Bind(&ReportGpuVideoDecoderInitializeStatusToUMAAndRunCB,
                  BindToCurrentLoop(init_cb), media_log_);
 
+  bool requires_restart_for_external_output_surface = false;
 #if !defined(OS_ANDROID)
   if (config.is_encrypted()) {
     DVLOG(1) << "Encrypted stream not supported.";
     bound_init_cb.Run(false);
     return;
   }
+#else
+  requires_restart_for_external_output_surface =
+      base::android::BuildInfo::GetInstance()->sdk_int() < 23;
 #endif
 
   bool previously_initialized = config_.IsValidConfig();
@@ -309,6 +317,7 @@ void GpuVideoDecoder::Initialize(const VideoDecoderConfig& config,
     // If we have a surface request callback we should call it and complete
     // initialization with the returned surface.
     request_surface_cb_.Run(
+        requires_restart_for_external_output_surface,
         BindToCurrentLoop(base::Bind(&GpuVideoDecoder::CompleteInitialization,
                                      weak_factory_.GetWeakPtr(), cdm_id)));
     return;
@@ -321,7 +330,6 @@ void GpuVideoDecoder::Initialize(const VideoDecoderConfig& config,
 
 void GpuVideoDecoder::CompleteInitialization(int cdm_id, int surface_id) {
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
-  DCHECK(!init_cb_.is_null());
 
   // It's possible for the vda to become null if NotifyError is called.
   if (!vda_) {
@@ -329,6 +337,12 @@ void GpuVideoDecoder::CompleteInitialization(int cdm_id, int surface_id) {
     return;
   }
 
+  // If initialization has already completed, then send the new surface id.

[liberato (no reviews please), 2016/10/29 18:57:20]

this is a little confusing.  it might be clearer if AVDA always defers init
until the first SetSurface() call instead.  that would also let us combine the
"codec config is in flight" case with "codec config hasn't started yet".  
something like:

// remove surface_id from VDA::Config.

AVDA::SetSurface() {
  if (WAITING_FOR_CODEC) {
    // we're restarting the codec for some reason.
    pending_surface_ = surface_id_;
    // OnCodecConfigured will notice and SetSurface.
    return;
  } else if (!codec) {
    // initial setup of VDA -- complete init now.
    set surface_id_ in codec_config_ and start async config;
  } else {
    codec->setSurface()
  }

then, we don't have two paths where the surface id is sent in, and it handles
one of the edge cases you mention in AVDA::SetSurface.

if the config specifies that deferred init is not possible, then AVDA might need
to call AVDA::SetSurface(kNoSurfaceId).  that's a little hacky, of a similar
type to what i'm trying to remove here.  :)

gvd would go back to doing the CompleteInitialization() work immediately.

i think that this also helps us make the AllocateSurface case not special.  it
would move out of AVDA::Initialize into setSurface, i think.  AllocateSurface
doesn't handle the "already own the codec" case correctly -- it should succeed
immediately as it does if there is no current owner.

+  if (init_cb_.is_null()) {
+    vda_->SetSurface(surface_id);
+    return;
+  }
+
   VideoDecodeAccelerator::Config vda_config;
   vda_config.profile = config_.profile();
   vda_config.cdm_id = cdm_id;
@@ -785,7 +799,7 @@ GpuVideoDecoder::~GpuVideoDecoder() {
   if (!init_cb_.is_null())
     base::ResetAndReturn(&init_cb_).Run(false);
   if (!request_surface_cb_.is_null())
-    base::ResetAndReturn(&request_surface_cb_).Run(SurfaceCreatedCB());
+    base::ResetAndReturn(&request_surface_cb_).Run(false, SurfaceCreatedCB());
 
   for (size_t i = 0; i < available_shm_segments_.size(); ++i) {
     delete available_shm_segments_[i];