media: Clean up MediaCodecBridge and remove subclasses

media/gpu/avda_codec_allocator.cc

 // 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.
 
 #include "media/gpu/avda_codec_allocator.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 16 matching lines @@
 namespace {
 
 // Give tasks 800ms before considering them hung. MediaCodec.configure() calls
 // typically take 100-200ms on a N5, so 800ms is expected to very rarely result
 // in false positives. Also, false positives have low impact because we resume
 // using the thread when the task completes.
 constexpr base::TimeDelta kHungTaskDetectionTimeout =
     base::TimeDelta::FromMilliseconds(800);
 
 // Delete |codec| and signal |done_event| if it's not null.
-void DeleteMediaCodecAndSignal(std::unique_ptr<VideoCodecBridge> codec,
+void DeleteMediaCodecAndSignal(std::unique_ptr<MediaCodecBridge> codec,
                                base::WaitableEvent* done_event) {
   codec.reset();
   if (done_event)
     done_event->Signal();
 }
 
 }  // namespace
 
 CodecConfig::CodecConfig() {}
 CodecConfig::~CodecConfig() {}
@@ skipping 179 matching lines @@
   // And in that case we don't want to hang the browser UI thread. Android ANRs
   // occur when the UI thread is blocked for 5 seconds, so waiting for 2 seconds
   // gives us leeway to avoid an ANR. Verified no ANR on a Nexus 7.
   base::WaitableEvent& released =
       pending_codec_releases_.find(surface_id)->second;
   released.TimedWait(base::TimeDelta::FromSeconds(2));
   if (!released.IsSignaled())
     DLOG(WARNING) << __func__ << ": timed out waiting for MediaCodec#release()";
 }
 
-std::unique_ptr<VideoCodecBridge> AVDACodecAllocator::CreateMediaCodecSync(
+std::unique_ptr<MediaCodecBridge> AVDACodecAllocator::CreateMediaCodecSync(
     scoped_refptr<CodecConfig> codec_config) {
   TRACE_EVENT0("media", "AVDA::CreateMediaCodecSync");
 
   jobject media_crypto =
       codec_config->media_crypto ? codec_config->media_crypto->obj() : nullptr;
 
   // |needs_protected_surface| implies encrypted stream.
   DCHECK(!codec_config->needs_protected_surface || media_crypto);
 
   const bool require_software_codec = codec_config->task_type == SW_CODEC;
-  std::unique_ptr<VideoCodecBridge> codec(VideoCodecBridge::CreateDecoder(
-      codec_config->codec, codec_config->needs_protected_surface,
-      codec_config->initial_expected_coded_size,
-      codec_config->surface.j_surface().obj(), media_crypto, codec_config->csd0,
-      codec_config->csd1, true, require_software_codec));
+  std::unique_ptr<MediaCodecBridge> codec(
+      MediaCodecBridgeImpl::CreateVideoDecoder(
+          codec_config->codec, codec_config->needs_protected_surface,
+          codec_config->initial_expected_coded_size,
+          codec_config->surface.j_surface().obj(), media_crypto,
+          codec_config->csd0, codec_config->csd1, true,
+          require_software_codec));
 
   return codec;
 }
 
 void AVDACodecAllocator::CreateMediaCodecAsync(
     base::WeakPtr<AVDACodecAllocatorClient> client,
     scoped_refptr<CodecConfig> codec_config) {
   base::PostTaskAndReplyWithResult(
       TaskRunnerFor(codec_config->task_type).get(), FROM_HERE,
       base::Bind(&AVDACodecAllocator::CreateMediaCodecSync,
                  base::Unretained(this), codec_config),
       base::Bind(&AVDACodecAllocatorClient::OnCodecConfigured, client));
 }
 
 void AVDACodecAllocator::ReleaseMediaCodec(
-    std::unique_ptr<VideoCodecBridge> media_codec,
+    std::unique_ptr<MediaCodecBridge> media_codec,
     TaskType task_type,
     int surface_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(media_codec);
 
   // No need to track the release if it's a SurfaceTexture.
   if (surface_id == SurfaceManager::kNoSurfaceID) {
     TaskRunnerFor(task_type)->PostTask(
         FROM_HERE, base::Bind(&DeleteMediaCodecAndSignal,
                               base::Passed(std::move(media_codec)), nullptr));
@@ skipping 79 matching lines @@
 void AVDACodecAllocator::StopThreadTask(size_t index) {
   threads_[index]->thread.Stop();
   // Signal the stop event after both threads are stopped.
   if (stop_event_for_testing_ && !threads_[AUTO_CODEC]->thread.IsRunning() &&
       !threads_[SW_CODEC]->thread.IsRunning()) {
     stop_event_for_testing_->Signal();
   }
 }
 
 }  // namespace media