Send enter / exit fullscreen signal to AVDA

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>
 #include <vector>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/optional.h"
 #include "base/unguessable_token.h"
 #include "media/base/bitstream_buffer.h"
 #include "media/base/cdm_context.h"
 #include "media/base/encryption_scheme.h"
+#include "media/base/overlay_info.h"
 #include "media/base/surface_manager.h"
 #include "media/base/video_decoder_config.h"
 #include "media/video/picture.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/gpu_memory_buffer.h"
 
 typedef unsigned int GLenum;
 
 namespace base {
 class SingleThreadTaskRunner;
@@ skipping 115 matching lines @@
     // Whether the stream is encrypted, and, if so, the scheme used.
     EncryptionScheme encryption_scheme;
 
     // 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|.
-    // TODO(liberato): should this be Optional<> instead?
-    int surface_id = SurfaceManager::kNoSurfaceID;
-
-    // An optional routing token for AndroidOverlay.
-    base::Optional<base::UnguessableToken> overlay_routing_token;
+    // Optional overlay info available at startup, rather than waiting for the
+    // VDA to receive a callback.
+    OverlayInfo overlay_info;
 
     // 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;
 
@@ skipping 135 matching lines @@
   // NotifyFlushDone() and VDA should cancel the flush. Note NotifyFlushDone()
   // may be on the way to the client. If client gets NotifyFlushDone(), it
   // should be before NotifyResetDone().
   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.
   // |routing_token| is an optional AndroidOverlay routing token.  At most one
   // should be non-empty.
-  virtual void SetSurface(
-      int32_t surface_id,
-      const base::Optional<base::UnguessableToken>& routing_token);
+  virtual void SetOverlayInfo(const OverlayInfo& overlay_info);
 
   // 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.
   //
@@ skipping 47 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_