media: Clean up MediaCodecBridge and remove subclasses

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>
@@ skipping 81 matching lines @@
 
   // 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;
 
   // 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<VideoCodecBridge> media_codec) = 0;
+      std::unique_ptr<MediaCodecBridge> media_codec) = 0;
 
  protected:
   ~AVDACodecAllocatorClient() {}
 };
 
 // AVDACodecAllocator manages threads for allocating and releasing MediaCodec
 // instances.  These activities can hang, depending on android version, due
 // to mediaserver bugs.  AVDACodecAllocator detects these cases, and reports
 // on them to allow software fallback if the HW path is hung up.
 class MEDIA_GPU_EXPORT AVDACodecAllocator {
@@ skipping 15 matching lines @@
   // via OnSurfaceAvailable().
   bool AllocateSurface(AVDACodecAllocatorClient* 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);
 
   // Create and configure a MediaCodec synchronously.
-  std::unique_ptr<VideoCodecBridge> CreateMediaCodecSync(
+  std::unique_ptr<MediaCodecBridge> CreateMediaCodecSync(
       scoped_refptr<CodecConfig> codec_config);
 
   // Create and configure a MediaCodec asynchronously. The result is delivered
   // via OnCodecConfigured().
   void CreateMediaCodecAsync(base::WeakPtr<AVDACodecAllocatorClient> client,
                              scoped_refptr<CodecConfig> codec_config);
 
   // Asynchronously release |media_codec| with the attached surface.
   // TODO(watk): Bundle the MediaCodec and surface together so you can't get
   // this pairing wrong.
-  void ReleaseMediaCodec(std::unique_ptr<VideoCodecBridge> media_codec,
+  void ReleaseMediaCodec(std::unique_ptr<MediaCodecBridge> media_codec,
                          TaskType task_type,
                          int surface_id);
 
   // Returns a hint about whether the construction thread has hung for
   // |task_type|.  Note that if a thread isn't started, then we'll just return
   // "not hung", since it'll run on the current thread anyway.  The hang
   // detector will see no pending jobs in that case, so it's automatic.
   bool IsThreadLikelyHung(TaskType task_type);
 
   // Return true if and only if there is any AVDA registered.
@@ skipping 74 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_