media: Clean up MediaCodecBridge and remove subclasses

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 61 matching lines @@
   // 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(
-      std::unique_ptr<VideoCodecBridge> media_codec) override;
+      std::unique_ptr<MediaCodecBridge> 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
     // surface arrives, we'll transition to WAITING_FOR_CODEC, NO_ERROR, or
@@ skipping 45 matching lines @@
   // |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(
+  static std::unique_ptr<MediaCodecBridge> 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);
@@ skipping 100 matching lines @@
   State state_;
 
   // The assigned picture buffers by picture buffer id.
   AVDAPictureBufferManager::PictureBufferMap output_picture_buffers_;
 
   // This keeps the free picture buffer ids which can be used for sending
   // decoded frames to the client.
   std::queue<int32_t> free_picture_ids_;
 
   // The low-level decoder which Android SDK provides.
-  std::unique_ptr<VideoCodecBridge> media_codec_;
+  std::unique_ptr<MediaCodecBridge> media_codec_;
 
   // Set to true after requesting picture buffers to the client.
   bool picturebuffers_requested_;
 
   // The resolution of the stream.
   gfx::Size size_;
 
   // Handy structure to remember a BitstreamBuffer and also its shared memory,
   // if any.  The goal is to prevent leaving a BitstreamBuffer's shared memory
   // handle open.
@@ skipping 82 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_