Use AVDA copying strategy unless the unified pipeline flag is set.

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"
 #include "base/metrics/histogram.h"
 #include "base/trace_event/trace_event.h"
 #include "content/common/gpu/gpu_channel.h"
 #include "content/common/gpu/media/android_copying_backing_strategy.h"
 #include "content/common/gpu/media/android_deferred_rendering_backing_strategy.h"
 #include "content/common/gpu/media/avda_return_on_failure.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "media/base/bitstream_buffer.h"
 #include "media/base/limits.h"
+#include "media/base/media_switches.h"
 #include "media/base/timestamp_constants.h"
 #include "media/base/video_decoder_config.h"
 #include "media/video/picture.h"
 #include "ui/gl/android/scoped_java_surface.h"
 #include "ui/gl/android/surface_texture.h"
 #include "ui/gl/gl_bindings.h"
 
 #if defined(ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
 #include "media/base/media_keys.h"
 #include "media/mojo/services/mojo_cdm_service.h"
@@ skipping 23 matching lines @@
   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
 };
-
-#define BACKING_STRATEGY AndroidDeferredRenderingBackingStrategy
-#else
-#define BACKING_STRATEGY AndroidCopyingBackingStrategy
 #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
@@ skipping 14 matching lines @@
 AndroidVideoDecodeAccelerator::AndroidVideoDecodeAccelerator(
     const base::WeakPtr<gpu::gles2::GLES2Decoder> decoder,
     const base::Callback<bool(void)>& make_context_current)
     : client_(NULL),
       make_context_current_(make_context_current),
       codec_(media::kCodecH264),
       is_encrypted_(false),
       state_(NO_ERROR),
       picturebuffers_requested_(false),
       gl_decoder_(decoder),
-      strategy_(new BACKING_STRATEGY()),
-      weak_this_factory_(this) {}
+      weak_this_factory_(this) {
+  if (UseDeferredRenderingStrategy())
+    strategy_.reset(new AndroidDeferredRenderingBackingStrategy());
+  else
+    strategy_.reset(new AndroidCopyingBackingStrategy());
+}
 
 AndroidVideoDecodeAccelerator::~AndroidVideoDecodeAccelerator() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 bool AndroidVideoDecodeAccelerator::Initialize(const Config& config,
                                                Client* client) {
   DCHECK(!media_codec_);
   DCHECK(thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("media", "AVDA::Initialize");
@@ skipping 526 matching lines @@
 void AndroidVideoDecodeAccelerator::NotifyResetDone() {
   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);
@@ skipping 16 matching lines @@
     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
 
-  capabilities.flags = BACKING_STRATEGY::GetCapabilitiesFlags();
+  if (UseDeferredRenderingStrategy())

[DaleCurtis, 2015/12/15 23:42:57]

{}

[liberato (no reviews please), 2015/12/16 16:11:04]

Done.

+    capabilities.flags = media::VideoDecodeAccelerator::Capabilities::
+        NEEDS_ALL_PICTURE_BUFFERS_TO_DECODE;
 
   return capabilities;
 }
 
 }  // namespace content