media: Clean up MediaCodecBridge and remove subclasses

media/gpu/android_video_decode_accelerator.cc

 // 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.
 
 #include "media/gpu/android_video_decode_accelerator.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 289 matching lines @@
   }
 
   if (codec_config_->codec == kCodecH264) {
     codec_config_->csd0 = config.sps;
     codec_config_->csd1 = config.pps;
   }
 
   // Only use MediaCodec for VP8/9 if it's likely backed by hardware
   // or if the stream is encrypted.
   if (IsMediaCodecSoftwareDecodingForbidden() &&
-      VideoCodecBridge::IsKnownUnaccelerated(codec_config_->codec,
-                                             MEDIA_CODEC_DECODER)) {
-    DVLOG(1) << "Initialization failed: "
-             << (codec_config_->codec == kCodecVP8 ? "vp8" : "vp9")
+      MediaCodecUtil::IsKnownUnaccelerated(codec_config_->codec,
+                                           MediaCodecDirection::DECODER)) {
+    DVLOG(1) << "Initialization failed: " << GetCodecName(codec_config_->codec)
              << " is not hardware accelerated";
     return false;
   }
 
   auto gles_decoder = get_gles2_decoder_cb_.Run();
   if (!gles_decoder) {
     DLOG(ERROR) << "Failed to get gles2 decoder instance.";
     return false;
   }
 
@@ skipping 161 matching lines @@
 
   int input_buf_index = pending_input_buf_index_;
 
   // Do not dequeue a new input buffer if we failed with MEDIA_CODEC_NO_KEY.
   // That status does not return this buffer back to the pool of
   // available input buffers. We have to reuse it in QueueSecureInputBuffer().
   if (input_buf_index == -1) {
     MediaCodecStatus status =
         media_codec_->DequeueInputBuffer(NoWaitTimeOut, &input_buf_index);
     switch (status) {
-      case MEDIA_CODEC_DEQUEUE_INPUT_AGAIN_LATER:
+      case MEDIA_CODEC_TRY_AGAIN_LATER:
         return false;
       case MEDIA_CODEC_ERROR:
         NOTIFY_ERROR(PLATFORM_FAILURE, "DequeueInputBuffer failed");
         return false;
       case MEDIA_CODEC_OK:
         break;
       default:
         NOTREACHED();
         return false;
     }
@@ skipping 152 matching lines @@
         // Instead, signal completion of the drain.
         if (IsDrainingForResetOrDestroy()) {
           DVLOG(1) << __func__ << ": error while draining";
           state_ = ERROR;
           OnDrainCompleted();
         } else {
           NOTIFY_ERROR(PLATFORM_FAILURE, "DequeueOutputBuffer failed.");
         }
         return false;
 
-      case MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER:
+      case MEDIA_CODEC_TRY_AGAIN_LATER:
         return false;
 
       case MEDIA_CODEC_OUTPUT_FORMAT_CHANGED: {
         // An OUTPUT_FORMAT_CHANGED is not reported after flush() if the frame
         // size does not change. Therefore we have to keep track on the format
         // even if draining, unless we are draining for destroy.
         if (drain_type_ == DRAIN_FOR_DESTROY)
           return true;  // ignore
 
         if (media_codec_->GetOutputSize(&size_) != MEDIA_CODEC_OK) {
@@ skipping 296 matching lines @@
 
   base::Optional<TaskType> task_type =
       codec_allocator_->TaskTypeForAllocation();
   if (!task_type) {
     // If there is no free thread, then just fail.
     OnCodecConfigured(nullptr);
     return;
   }
 
   codec_config_->task_type = task_type.value();
-  std::unique_ptr<VideoCodecBridge> media_codec =
-      codec_allocator_->CreateMediaCodecSync(codec_config_);
+  std::unique_ptr<MediaCodecBridge> media_codec =
+      AVDACodecAllocator::Instance()->CreateMediaCodecSync(codec_config_);
   // Note that |media_codec| might be null, which will NotifyError.
   OnCodecConfigured(std::move(media_codec));
 }
 
 void AndroidVideoDecodeAccelerator::OnCodecConfigured(
-    std::unique_ptr<VideoCodecBridge> media_codec) {
+    std::unique_ptr<MediaCodecBridge> media_codec) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(state_ == WAITING_FOR_CODEC || state_ == SURFACE_DESTROYED);
 
   // If we are supposed to notify that initialization is complete, then do so
   // before returning.  Otherwise, this is a reconfiguration.
 
   // If |state_| changed to SURFACE_DESTROYED while we were configuring a codec,
   // then the codec is already invalid so we return early and drop it.
   // TODO(liberato): We're going to drop the codec when |media_codec| goes out
   // of scope, on this thread.  We really should post it to the proper thread
@@ skipping 450 matching lines @@
     // support for it.  Let libvpx decode it, and save a MediaCodec instance.
     // Note that we allow it anyway for encrypted content, since we push a
     // separate profile for that.
     profile.min_resolution.SetSize(480, 360);
     profile.max_resolution.SetSize(3840, 2160);
     // If we know MediaCodec will just create a software codec, prefer our
     // internal software decoder instead. It's more up to date and secured
     // within the renderer sandbox. However if the content is encrypted, we
     // must use MediaCodec anyways since MediaDrm offers no way to decrypt
     // the buffers and let us use our internal software decoders.
-    profile.encrypted_only =
-        VideoCodecBridge::IsKnownUnaccelerated(kCodecVP8, MEDIA_CODEC_DECODER);
+    profile.encrypted_only = MediaCodecUtil::IsKnownUnaccelerated(
+        kCodecVP8, MediaCodecDirection::DECODER);
     profiles.push_back(profile);
 
     // Always allow encrypted content, even at low resolutions.
     profile.min_resolution.SetSize(0, 0);
     profile.encrypted_only = true;
     profiles.push_back(profile);
   }
 
   if (MediaCodecUtil::IsVp9DecoderAvailable()) {
     const VideoCodecProfile profile_types[] = {
         VP9PROFILE_PROFILE0, VP9PROFILE_PROFILE1, VP9PROFILE_PROFILE2,
         VP9PROFILE_PROFILE3, VIDEO_CODEC_PROFILE_UNKNOWN};
-    const bool is_known_unaccelerated =
-        VideoCodecBridge::IsKnownUnaccelerated(kCodecVP9, MEDIA_CODEC_DECODER);
+    const bool is_known_unaccelerated = MediaCodecUtil::IsKnownUnaccelerated(
+        kCodecVP9, MediaCodecDirection::DECODER);
     for (int i = 0; profile_types[i] != VIDEO_CODEC_PROFILE_UNKNOWN; i++) {
       SupportedProfile profile;
       // Limit to 360p, like we do for vp8.  See above.
       profile.min_resolution.SetSize(480, 360);
       profile.max_resolution.SetSize(3840, 2160);
       // If we know MediaCodec will just create a software codec, prefer our
       // internal software decoder instead. It's more up to date and secured
       // within the renderer sandbox. However if the content is encrypted, we
       // must use MediaCodec anyways since MediaDrm offers no way to decrypt
       // the buffers and let us use our internal software decoders.
@@ skipping 96 matching lines @@
   if (!media_codec_)
     return;
 
   picture_buffer_manager_.CodecChanged(nullptr);
   codec_allocator_->ReleaseMediaCodec(
       std::move(media_codec_), codec_config_->task_type, config_.surface_id);
   last_release_task_type_ = codec_config_->task_type;
 }
 
 }  // namespace media