Add ContentVideoViewOverlay to AVDA.

media/gpu/android_video_decode_accelerator.h

 // Copyright (c) 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.
 
 #ifndef MEDIA_GPU_ANDROID_VIDEO_DECODE_ACCELERATOR_H_
 #define MEDIA_GPU_ANDROID_VIDEO_DECODE_ACCELERATOR_H_
 
 #include <stdint.h>
 
 #include <list>
@@ skipping 58 matching lines @@
   // AVDAStateProvider implementation:
   const gfx::Size& GetSize() const override;
   base::WeakPtr<gpu::gles2::GLES2Decoder> GetGlDecoder() const override;
   // Notifies the client about the error and sets |state_| to |ERROR|.  If we're
   // in the middle of Initialize, we guarantee that Initialize will return
   // failure.  If deferred init is pending, then we'll fail deferred init.
   // Otherwise, we'll signal errors normally.
   void NotifyError(Error error) override;
 
   // AVDACodecAllocatorClient implementation:
-  void OnSurfaceAvailable(bool success) override;
-  void OnSurfaceDestroyed() override;
   void OnCodecConfigured(
+      scoped_refptr<CodecConfig> codec_config,
       std::unique_ptr<VideoCodecBridge> media_codec) override;
 
  private:
   friend class AVDAManager;
 
   // TODO(timav): evaluate the need for more states in the AVDA state machine.
   enum State {
     NO_ERROR,
     ERROR,
     // We have requested a surface, but haven't allocated it yet.  When the
@@ skipping 18 matching lines @@
   };
 
   // Entry point for configuring / reconfiguring a codec with a new surface.
   // Start surface creation by trying to allocate the surface id.  Will either
   // InitializePictureBufferManager if the surface is available immediately, or
   // will wait for OnSurfaceAvailable to do it.  This will transition |state_|
   // to WAITING_FOR_SURFACE or WAITING_FOR_CODEC, as needed (or NO_ERROR if it
   // gets the surface and the codec without waiting).
   void StartSurfaceCreation();
 
+  // Called by AndroidOverlay when a surface becomes available.
+  void OnSurfaceAvailable();
+
+  // Called by AndroidOverlay when a surface is lost or initialization failed.
+  void OnSurfaceDestroyed();
+
   // Initialize of the picture buffer manager to use the current surface, once
   // it is available.  This is not normally called directly, but rather via
   // StartSurfaceCreation.  If we have a media codec already, then this will
   // attempt to setSurface the new surface.  Otherwise, it will start codec
   // config using the new surface.  In that case, there might not be a codec
   // ready even if this succeeds, but async config will be started.  If
   // setSurface fails, this will not replace the codec.  On failure, this will
   // transition |state_| to ERROR.
   void InitializePictureBufferManager();
 
   // A part of destruction process that is sometimes postponed after the drain.
   void ActualDestroy();
 
   // Configures |media_codec_| with the given codec parameters from the client.
   // This configuration will (probably) not be complete before this call
   // returns.  Multiple calls before completion will be ignored.  |state_|
   // must be NO_ERROR or WAITING_FOR_CODEC.  Note that, once you call this,
   // you should be careful to avoid modifying members of |codec_config_| until
   // |state_| is no longer WAITING_FOR_CODEC.
   void ConfigureMediaCodecAsynchronously();
 
   // Like ConfigureMediaCodecAsynchronously, but synchronous.  Will NotifyError
   // on failure.  Since all configuration is done synchronously, there is no
   // concern with modifying |codec_config_| after this returns.
   void ConfigureMediaCodecSynchronously();
 
-  // Instantiate a media codec using |codec_config|.
-  // This may be called on any thread.
-  static std::unique_ptr<VideoCodecBridge> ConfigureMediaCodecOnAnyThread(
-      scoped_refptr<CodecConfig> codec_config);
-
   // Sends the decoded frame specified by |codec_buffer_index| to the client.
   void SendDecodedFrameToClient(int32_t codec_buffer_index,
                                 int32_t bitstream_id);
 
   // Does pending IO tasks if any. Once this is called, it polls |media_codec_|
   // until it finishes pending tasks. For the polling, |kDecodePollDelay| is
   // used.
   void DoIOTask(bool start_timer);
 
   // Feeds buffers in |pending_bitstream_records_| to |media_codec_|. Returns
@@ skipping 201 matching lines @@
 
   // WeakPtrFactory for posting tasks back to |this|.
   base::WeakPtrFactory<AndroidVideoDecodeAccelerator> weak_this_factory_;
 
   friend class AndroidVideoDecodeAcceleratorTest;
 };
 
 }  // namespace media
 
 #endif  // MEDIA_GPU_ANDROID_VIDEO_DECODE_ACCELERATOR_H_