Switch from build-time to run-time flags for Project Spitzer.

content/common/gpu/media/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 "content/common/gpu/media/android_video_decode_accelerator.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 25 matching lines @@
 // playback if we lower this.  Previously (crbug.com/176036), a deadlock
 // could occur during preroll.  More recent tests have shown some
 // instability with kNumPictureBuffers==2 with similar symptoms
 // during playback.  crbug.com/531588 .
 enum { kNumPictureBuffers = media::limits::kMaxVideoFrames + 1 };
 
 // Max number of bitstreams notified to the client with
 // NotifyEndOfBitstreamBuffer() before getting output from the bitstream.
 enum { kMaxBitstreamsNotifiedInAdvance = 32 };
 
-#if defined(ENABLE_MEDIA_PIPELINE_ON_ANDROID)
 // MediaCodec is only guaranteed to support baseline, but some devices may
 // support others. Advertise support for all H264 profiles and let the
 // MediaCodec fail when decoding if it's not actually supported. It's assumed
 // that consumers won't have software fallback for H264 on Android anyway.
 static const media::VideoCodecProfile kSupportedH264Profiles[] = {
   media::H264PROFILE_BASELINE,
   media::H264PROFILE_MAIN,
   media::H264PROFILE_EXTENDED,
   media::H264PROFILE_HIGH,
   media::H264PROFILE_HIGH10PROFILE,
   media::H264PROFILE_HIGH422PROFILE,
   media::H264PROFILE_HIGH444PREDICTIVEPROFILE,
   media::H264PROFILE_SCALABLEBASELINE,
   media::H264PROFILE_SCALABLEHIGH,
   media::H264PROFILE_STEREOHIGH,
   media::H264PROFILE_MULTIVIEWHIGH
 };
-#endif
 
 // Because MediaCodec is thread-hostile (must be poked on a single thread) and
 // has no callback mechanism (b/11990118), we must drive it by polling for
 // complete frames (and available input buffers, when the codec is fully
 // saturated).  This function defines the polling delay.  The value used is an
 // arbitrary choice that trades off CPU utilization (spinning) against latency.
 // Mirrors android_video_encode_accelerator.cc:EncodePollDelay().
 static inline const base::TimeDelta DecodePollDelay() {
   // An alternative to this polling scheme could be to dedicate a new thread
   // (instead of using the ChildThread) to run the MediaCodec, and make that
@@ skipping 37 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("media", "AVDA::Initialize");
 
   DVLOG(1) << __FUNCTION__ << ": profile:" << config.profile
            << " is_encrypted:" << config.is_encrypted;
 
   client_ = client;
   codec_ = VideoCodecProfileToVideoCodec(config.profile);
   is_encrypted_ = config.is_encrypted;
 
-  bool profile_supported = codec_ == media::kCodecVP8;
-#if defined(ENABLE_MEDIA_PIPELINE_ON_ANDROID)
-  profile_supported |=
-      (codec_ == media::kCodecVP9 || codec_ == media::kCodecH264);
-#endif
+  bool profile_supported = codec_ == media::kCodecVP8 ||
+                           codec_ == media::kCodecVP9 ||
+                           codec_ == media::kCodecH264;
 
   if (!profile_supported) {
     LOG(ERROR) << "Unsupported profile: " << config.profile;
     return false;
   }
 
   // Only use MediaCodec for VP8/9 if it's likely backed by hardware.
   if ((codec_ == media::kCodecVP8 || codec_ == media::kCodecVP9) &&
       media::VideoCodecBridge::IsKnownUnaccelerated(
           codec_, media::MEDIA_CODEC_DECODER)) {
@@ skipping 504 matching lines @@
   client_->NotifyResetDone();
 }
 
 void AndroidVideoDecodeAccelerator::NotifyError(
     media::VideoDecodeAccelerator::Error error) {
   client_->NotifyError(error);
 }
 
 // static
 bool AndroidVideoDecodeAccelerator::UseDeferredRenderingStrategy() {
-#if defined(ENABLE_MEDIA_PIPELINE_ON_ANDROID)
   return base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableUnifiedMediaPipeline);
-#endif
-
-  return false;
 }
 
 // static
 media::VideoDecodeAccelerator::Capabilities
 AndroidVideoDecodeAccelerator::GetCapabilities() {
   Capabilities capabilities;
   SupportedProfiles& profiles = capabilities.supported_profiles;
 
   if (!media::VideoCodecBridge::IsKnownUnaccelerated(
           media::kCodecVP8, media::MEDIA_CODEC_DECODER)) {
     SupportedProfile profile;
     profile.profile = media::VP8PROFILE_ANY;
     profile.min_resolution.SetSize(0, 0);
     profile.max_resolution.SetSize(1920, 1088);
     profiles.push_back(profile);
   }
 
-#if defined(ENABLE_MEDIA_PIPELINE_ON_ANDROID)
   if (!media::VideoCodecBridge::IsKnownUnaccelerated(
           media::kCodecVP9, media::MEDIA_CODEC_DECODER)) {
     SupportedProfile profile;
     profile.profile = media::VP9PROFILE_ANY;
     profile.min_resolution.SetSize(0, 0);
     profile.max_resolution.SetSize(1920, 1088);
     profiles.push_back(profile);
   }
 
   for (const auto& supported_profile : kSupportedH264Profiles) {
     SupportedProfile profile;
     profile.profile = supported_profile;
     profile.min_resolution.SetSize(0, 0);
     // Advertise support for 4k and let the MediaCodec fail when decoding if it
     // doesn't support the resolution. It's assumed that consumers won't have
     // software fallback for H264 on Android anyway.
     profile.max_resolution.SetSize(3840, 2160);
     profiles.push_back(profile);
   }
-#endif
 
   if (UseDeferredRenderingStrategy()) {
     capabilities.flags = media::VideoDecodeAccelerator::Capabilities::
         NEEDS_ALL_PICTURE_BUFFERS_TO_DECODE;
   }
 
   return capabilities;
 }
 
 }  // namespace content