Add ContentVideoViewOverlay to AVDA.

media/gpu/avda_codec_allocator.h

 // Copyright 2016 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_AVDA_CODEC_ALLOCATOR_H_
 #define MEDIA_GPU_AVDA_CODEC_ALLOCATOR_H_
 
 #include <stddef.h>
 
 #include <memory>
 
 #include "base/android/build_info.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/optional.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/sys_info.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/tick_clock.h"
 #include "base/trace_event/trace_event.h"
+#include "media/base/android/android_overlay.h"
 #include "media/base/android/media_codec_bridge_impl.h"
 #include "media/base/android/media_drm_bridge_cdm_context.h"
 #include "media/base/media.h"
 #include "media/base/surface_manager.h"
 #include "media/base/video_codecs.h"
 #include "media/gpu/avda_surface_bundle.h"
 #include "media/gpu/media_gpu_export.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gl/android/scoped_java_surface.h"
 
@@ skipping 41 matching lines @@
   std::vector<uint8_t> csd1;
 
  protected:
   friend class base::RefCountedThreadSafe<CodecConfig>;
   virtual ~CodecConfig();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CodecConfig);
 };
 
-class AVDACodecAllocatorClient {
+class AVDASurfaceAllocatorClient {
  public:
   // Called when the requested SurfaceView becomes available after a call to
   // AllocateSurface()
   virtual void OnSurfaceAvailable(bool success) = 0;
 
   // Called when the allocated surface is being destroyed. This must either
   // replace the surface with MediaCodec#setSurface, or release the MediaCodec
   // it's attached to. The client no longer owns the surface and doesn't
   // need to call DeallocateSurface();
   virtual void OnSurfaceDestroyed() = 0;
 
+ protected:
+  ~AVDASurfaceAllocatorClient() {}
+};
+
+class AVDACodecAllocatorClient {
+ public:
   // Called on the main thread when a new MediaCodec is configured.
   // |media_codec| will be null if configuration failed.
   virtual void OnCodecConfigured(
       std::unique_ptr<MediaCodecBridge> media_codec) = 0;
 
  protected:
   ~AVDACodecAllocatorClient() {}
 };
 
 // AVDACodecAllocator manages threads for allocating and releasing MediaCodec
@@ skipping 10 matching lines @@
 
   // Make sure the construction threads are started for |client|. Returns true
   // on success.
   bool StartThread(AVDACodecAllocatorClient* client);
 
   void StopThread(AVDACodecAllocatorClient* client);
 
   // Returns true if the caller now owns the surface, or false if someone else
   // owns the surface. |client| will be notified when the surface is available
   // via OnSurfaceAvailable().
-  bool AllocateSurface(AVDACodecAllocatorClient* client, int surface_id);
+  bool AllocateSurface(AVDASurfaceAllocatorClient* client, int surface_id);
 
   // Relinquish ownership of the surface or stop waiting for it to be available.
   // The caller must guarantee that when calling this the surface is either no
   // longer attached to a MediaCodec, or the MediaCodec it was attached to is
   // was released with ReleaseMediaCodec().
-  void DeallocateSurface(AVDACodecAllocatorClient* client, int surface_id);
+  void DeallocateSurface(AVDASurfaceAllocatorClient* client, int surface_id);
 
   // Create and configure a MediaCodec synchronously.
   std::unique_ptr<MediaCodecBridge> CreateMediaCodecSync(
       scoped_refptr<CodecConfig> codec_config);
 
   // Create and configure a MediaCodec asynchronously. The result is delivered
   // via OnCodecConfigured().
   virtual void CreateMediaCodecAsync(
       base::WeakPtr<AVDACodecAllocatorClient> client,
       scoped_refptr<CodecConfig> codec_config);
@@ skipping 41 matching lines @@
   // then drop our ref to |surface_bundle|.
   void ForwardOrDropCodec(base::WeakPtr<AVDACodecAllocatorClient> client,
                           TaskType task_type,
                           scoped_refptr<AVDASurfaceBundle> surface_bundle,
                           std::unique_ptr<MediaCodecBridge> media_codec);
 
  private:
   friend class AVDACodecAllocatorTest;
 
   struct OwnerRecord {
-    AVDACodecAllocatorClient* owner = nullptr;
-    AVDACodecAllocatorClient* waiter = nullptr;
+    AVDASurfaceAllocatorClient* owner = nullptr;
+    AVDASurfaceAllocatorClient* waiter = nullptr;
   };
 
   class HangDetector : public base::MessageLoop::TaskObserver {
    public:
     HangDetector(base::TickClock* tick_clock);
     void WillProcessTask(const base::PendingTask& pending_task) override;
     void DidProcessTask(const base::PendingTask& pending_task) override;
     bool IsThreadLikelyHung();
 
    private:
@@ skipping 43 matching lines @@
 
   // For canceling pending StopThreadTask()s.
   base::WeakPtrFactory<AVDACodecAllocator> weak_this_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(AVDACodecAllocator);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_GPU_AVDA_CODEC_ALLOCATOR_H_