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

media/video/video_decode_accelerator.h

 // Copyright (c) 2012 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.
 
 #ifndef MEDIA_VIDEO_VIDEO_DECODE_ACCELERATOR_H_
 #define MEDIA_VIDEO_VIDEO_DECODE_ACCELERATOR_H_
 
 #include <stdint.h>
 
 #include <memory>
@@ skipping 88 matching lines @@
     // A failure occurred at the browser layer or one of its dependencies.
     // Examples of such failures include GPU hardware failures, GPU driver
     // failures, GPU library failures, browser programming errors, and so on.
     PLATFORM_FAILURE,
     // Largest used enum. This should be adjusted when new errors are added.
     ERROR_MAX = PLATFORM_FAILURE,
   };
 
   // Config structure contains parameters required for the VDA initialization.
   struct MEDIA_EXPORT Config {
-    enum { kNoSurfaceID = SurfaceManager::kNoSurfaceID };
-
     // Specifies the allocation and handling mode for output PictureBuffers.
     // When set to ALLOCATE, the VDA is expected to allocate backing memory
     // for PictureBuffers at the time of AssignPictureBuffers() call.
     // When set to IMPORT, the VDA will not allocate, but after receiving
     // AssignPictureBuffers() call, it will expect a call to
     // ImportBufferForPicture() for each PictureBuffer before use.
     enum class OutputMode {
       ALLOCATE,
       IMPORT,
     };
@@ skipping 15 matching lines @@
     // Whether the stream is encrypted.
     bool is_encrypted = false;
 
     // The CDM that the VDA should use to decode encrypted streams. Must be
     // set to a valid ID if |is_encrypted|.
     int cdm_id = CdmContext::kInvalidCdmId;
 
     // Whether the client supports deferred initialization.
     bool is_deferred_initialization_allowed = false;
 
-    // An optional graphics surface that the VDA should render to. For setting
-    // an output SurfaceView on Android. It's only valid when not equal to
-    // |kNoSurfaceID|.
-    int surface_id = kNoSurfaceID;
-
     // Coded size of the video frame hint, subject to change.
     gfx::Size initial_expected_coded_size = gfx::Size(320, 240);
 
     OutputMode output_mode = OutputMode::ALLOCATE;
 
     // The list of picture buffer formats that the client knows how to use. An
     // empty list means any format is supported.
     std::vector<VideoPixelFormat> supported_output_formats;
 
     // The H264 SPS and PPS configuration data. Not all clients populate these
@@ skipping 123 matching lines @@
   // back to the client, followed by NotifyFlushDone() being called on the
   // client.  Can be used to implement "end of stream" notification.
   virtual void Flush() = 0;
 
   // Resets the decoder: all pending inputs are dropped immediately and the
   // decoder returned to a state ready for further Decode()s, followed by
   // NotifyResetDone() being called on the client.  Can be used to implement
   // "seek".
   virtual void Reset() = 0;
 
+  // An optional graphics surface that the VDA should render to. For setting
+  // an output SurfaceView on Android. Passing |kNoSurfaceID| will clear any
+  // previously set surface in favor of an internally generated texture.
+  virtual void SetSurface(int32_t surface_id);
+
   // Destroys the decoder: all pending inputs are dropped immediately and the
   // component is freed.  This call may asynchornously free system resources,
   // but its client-visible effects are synchronous.  After this method returns
   // no more callbacks will be made on the client.  Deletes |this|
   // unconditionally, so make sure to drop all pointers to it!
   virtual void Destroy() = 0;
 
   // TO BE CALLED IN THE SAME PROCESS AS THE VDA IMPLEMENTATION ONLY.
   //
   // A decode "task" is a sequence that includes a Decode() call from Client,
@@ skipping 46 matching lines @@
 // std::unique_ptr<VideoDecodeAccelerator> uses "Destroy()" instead of trying to
 // use the destructor.
 template <>
 struct MEDIA_EXPORT default_delete<media::VideoDecodeAccelerator> {
   void operator()(media::VideoDecodeAccelerator* vda) const;
 };
 
 }  // namespace std
 
 #endif  // MEDIA_VIDEO_VIDEO_DECODE_ACCELERATOR_H_