Remove kDisableUnifiedMediaPipeline

media/base/mime_util_internal.cc

 // Copyright 2012 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/base/mime_util_internal.h"
 
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
@@ skipping 104 matching lines @@
   // multiplied by ten, e.g. level_idc==32 corresponds to level==3.2
   return ((level_idc >= 10 && level_idc <= 13) ||
           (level_idc >= 20 && level_idc <= 22) ||
           (level_idc >= 30 && level_idc <= 32) ||
           (level_idc >= 40 && level_idc <= 42) ||
           (level_idc >= 50 && level_idc <= 51));
 }
 
 MimeUtil::MimeUtil() : allow_proprietary_codecs_(false) {
 #if defined(OS_ANDROID)
-  platform_info_.is_unified_media_pipeline_enabled =
-      IsUnifiedMediaPipelineEnabled();
   // When the unified media pipeline is enabled, we need support for both GPU
   // video decoders and MediaCodec; indicated by HasPlatformDecoderSupport().
   // When the Android pipeline is used, we only need access to MediaCodec.
-  platform_info_.has_platform_decoders = ArePlatformDecodersAvailable();
+  platform_info_.has_platform_decoders = HasPlatformDecoderSupport();
   platform_info_.has_platform_vp8_decoder =
       MediaCodecUtil::IsVp8DecoderAvailable();
   platform_info_.has_platform_vp9_decoder =
       MediaCodecUtil::IsVp9DecoderAvailable();
   platform_info_.supports_opus = PlatformHasOpusSupport();
 #endif
 
   InitializeMimeTypeMaps();
 }
 
@@ skipping 316 matching lines @@
       return true;
 
     case MPEG2_AAC:
       // MPEG-2 variants of AAC are not supported on Android unless the unified
       // media pipeline can be used and the container is not HLS. These codecs
       // will be decoded in software. See https://crbug.com/544268 for details.
       if (base::EndsWith(mime_type_lower_case, "mpegurl",
                          base::CompareCase::SENSITIVE)) {
         return false;
       }
-      return !is_encrypted && platform_info.is_unified_media_pipeline_enabled;
+      return !is_encrypted;
 
     case OPUS:
       // If clear, the unified pipeline can always decode Opus in software.
-      if (!is_encrypted && platform_info.is_unified_media_pipeline_enabled)
+      if (!is_encrypted)
         return true;
 
       // Otherwise, platform support is required.
       if (!platform_info.supports_opus)
         return false;
 
       // MediaPlayer does not support Opus in ogg containers.
       if (base::EndsWith(mime_type_lower_case, "ogg",
                          base::CompareCase::SENSITIVE)) {
         return false;
       }
 
       DCHECK(!is_encrypted || platform_info.has_platform_decoders);
       return true;
 
     case H264:
       // When content is not encrypted we fall back to MediaPlayer, thus we
       // always support H264. For EME we need MediaCodec.
       return !is_encrypted || platform_info.has_platform_decoders;
 
     case HEVC:
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
-      if (platform_info.is_unified_media_pipeline_enabled &&
-          !platform_info.has_platform_decoders) {
+      if (!platform_info.has_platform_decoders)
         return false;
-      }
 
 #if defined(OS_ANDROID)
       // HEVC/H.265 is supported in Lollipop+ (API Level 21), according to
       // http://developer.android.com/reference/android/media/MediaFormat.html
       return base::android::BuildInfo::GetInstance()->sdk_int() >= 21;
 #else
       return true;
 #endif  // defined(OS_ANDROID)
 #else
       return false;
 #endif  // BUILDFLAG(ENABLE_HEVC_DEMUXING)
 
     case VP8:
       // If clear, the unified pipeline can always decode VP8 in software.
-      if (!is_encrypted && platform_info.is_unified_media_pipeline_enabled)
+      if (!is_encrypted)
         return true;
 
       if (is_encrypted)
         return platform_info.has_platform_vp8_decoder;
 
       // MediaPlayer can always play VP8. Note: This is incorrect for MSE, but
       // MSE does not use this code. http://crbug.com/587303.
       return true;
 
     case VP9: {
       if (base::CommandLine::ForCurrentProcess()->HasSwitch(
               switches::kReportVp9AsAnUnsupportedMimeType)) {
         return false;
       }
 
       // If clear, the unified pipeline can always decode VP9 in software.
-      if (!is_encrypted && platform_info.is_unified_media_pipeline_enabled)
+      if (!is_encrypted)
         return true;
 
       if (!platform_info.has_platform_vp9_decoder)
         return false;
 
       // Encrypted content is demuxed so the container is irrelevant.
       if (is_encrypted)
         return true;
 
       // MediaPlayer only supports VP9 in WebM.
@@ skipping 150 matching lines @@
     const std::string& mime_type_lower_case,
     bool is_encrypted) const {
   Codec default_codec = Codec::INVALID_CODEC;
   if (!GetDefaultCodecLowerCase(mime_type_lower_case, &default_codec))
     return false;
   return IsCodecSupported(default_codec, mime_type_lower_case, is_encrypted);
 }
 
 }  // namespace internal
 }  // namespace media