Start using deferred rendering for WebView on L.

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 <stddef.h>
 
 #include "base/android/build_info.h"
 #include "base/auto_reset.h"
@@ skipping 109 matching lines @@
 // we take care that the AVDA that wants them still exists.  A WeakPtr to
 // the AVDA would be preferable, except that OnFrameAvailable callbacks can
 // occur off the gpu main thread.  We also can't guarantee when the
 // SurfaceTexture will quit sending callbacks to coordinate with the
 // destruction of the AVDA, so we have a separate object that the cb can own.
 class AndroidVideoDecodeAccelerator::OnFrameAvailableHandler
     : public base::RefCountedThreadSafe<OnFrameAvailableHandler> {
  public:
   // We do not retain ownership of |owner|.  It must remain valid until
   // after ClearOwner() is called.  This will register with
-  // |surface_texture| to receive OnFrameAvailable callbacks.
+  // |surface_texture| to receive OnFrameAvailable callbacks.  If
+  // |use_separate_thread| is true, then we'll request that the callback happens
+  // on a thread that is dedicated to SurfaceTexture callbacks.
   OnFrameAvailableHandler(
       AndroidVideoDecodeAccelerator* owner,
-      const scoped_refptr<gfx::SurfaceTexture>& surface_texture)
+      const scoped_refptr<gfx::SurfaceTexture>& surface_texture,
+      bool use_separate_thread)
       : owner_(owner) {
     // Note that the callback owns a strong ref to us.
-    surface_texture->SetFrameAvailableCallbackOnAnyThread(
-        base::Bind(&OnFrameAvailableHandler::OnFrameAvailable,
-                   scoped_refptr<OnFrameAvailableHandler>(this)));
+    base::Closure cb = base::Bind(&OnFrameAvailableHandler::OnFrameAvailable,
+                                  scoped_refptr<OnFrameAvailableHandler>(this));
+
+    if (use_separate_thread)
+      surface_texture->SetFrameAvailableCallbackOnSeparateThread(cb);
+    else
+      surface_texture->SetFrameAvailableCallbackOnAnyThread(cb);
   }
 
   // Forget about our owner, which is required before one deletes it.
   // No further callbacks will happen once this completes.
   void ClearOwner() {
     base::AutoLock lock(lock_);
     // No callback can happen until we release the lock.
     owner_ = nullptr;
   }
 
@@ skipping 101 matching lines @@
       picturebuffers_requested_(false),
       gl_decoder_(decoder),
       cdm_registration_id_(0),
       pending_input_buf_index_(-1),
       error_sequence_token_(0),
       defer_errors_(false),
       weak_this_factory_(this) {
   if (UseDeferredRenderingStrategy()) {
     // TODO(liberato, watk): Figure out what we want to do about zero copy for
     // fullscreen external SurfaceView in WebView.  http://crbug.com/582170.
-    DCHECK(!gl_decoder_->GetContextGroup()->mailbox_manager()->UsesSync());
+
+    // Make sure that we're making a copy in sync mode, to verify that our
+    // guess about whether we're in sync mode in NeedsBrowserCopy is correct.
+    // Also make sure that, if we're in sync mode, that we're using a threaded
+    // callback so that it doesn't deadlock with the main thread.
+    DCHECK(!gl_decoder_->GetContextGroup()->mailbox_manager()->UsesSync() ||
+           (DeferredStrategyNeedsBrowserCopy() && IsCallbackThreadable()));
+
     DVLOG(1) << __FUNCTION__ << ", using deferred rendering strategy.";
     strategy_.reset(new AndroidDeferredRenderingBackingStrategy(this));
   } else {
     DVLOG(1) << __FUNCTION__ << ", using copy back strategy.";
     strategy_.reset(new AndroidCopyingBackingStrategy(this));
   }
 }
 
 AndroidVideoDecodeAccelerator::~AndroidVideoDecodeAccelerator() {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 57 matching lines @@
   if (surface_.IsEmpty()) {
     LOG(ERROR) << "Failed to initialize the backing strategy. The returned "
                   "Java surface is empty.";
     return false;
   }
 
   // TODO(watk,liberato): move this into the strategy.
   scoped_refptr<gfx::SurfaceTexture> surface_texture =
       strategy_->GetSurfaceTexture();
   if (surface_texture) {
+    // The deferred strategy requires threading the callback if we're using
+    // the sync compositor.
+    bool use_separate_thread =
+        gl_decoder_->GetContextGroup()->mailbox_manager()->UsesSync() &&
+        UseDeferredRenderingStrategy();
+    DCHECK(!use_separate_thread || IsCallbackThreadable());
     on_frame_available_handler_ =
-        new OnFrameAvailableHandler(this, surface_texture);
+        new OnFrameAvailableHandler(this, surface_texture, use_separate_thread);
   }
 
   // For encrypted streams we postpone configuration until MediaCrypto is
   // available.
   if (is_encrypted_)
     return true;
 
   return ConfigureMediaCodec();
 }
 
@@ skipping 745 matching lines @@
   }
 
   if (should_be_running)
     g_avda_timer.Pointer()->StartTimer(this);
   else
     g_avda_timer.Pointer()->StopTimer(this);
 }
 
 // static
 bool AndroidVideoDecodeAccelerator::UseDeferredRenderingStrategy() {
-  const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
   // TODO(liberato, watk): Figure out what we want to do about zero copy for
   // fullscreen external SurfaceView in WebView.  http://crbug.com/582170.
-  return !cmd_line->HasSwitch(switches::kEnableThreadedTextureMailboxes);
+  // If we are at API 21, we can use this any time.  Otherwise, we cannot use
+  // it for webview, since we cannot set the callback thread, causing a
+  // deadlock with the compositor.
+  return IsCallbackThreadable() || !DeferredStrategyNeedsBrowserCopy();
 }
 
 // static
+bool AndroidVideoDecodeAccelerator::DeferredStrategyNeedsBrowserCopy() {
+  // If we're using the synchronous mailbox mechanism and the deferred
+  // rendering strategy, then we need to force a copy before sending to
+  // the browser compositor.
+  // The copy is required because SurfaceTexture client textures can't be
+  // shared across unrelated GL contexts.  By deferring the copy until the
+  // frame is sent to the browser compositor, we can limit the number of
+  // outstanding copies to be ~2, regardless of how many the pipeline wants
+  // for better playback.
+  // In practice, all of that means "WebView requires a copy".
+
+  // We'd really like to check
+  // gl_decoder_->GetContextGroup()->mailbox_manager()->UsesSync() here, but
+  // we're called too early in start-up for that to be set properly.
+  // Instead, we use this switch and verify it later.
+  const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
+  return cmd_line->HasSwitch(switches::kEnableThreadedTextureMailboxes);
+}
+
+// static
+bool AndroidVideoDecodeAccelerator::IsCallbackThreadable() {
+  return base::android::BuildInfo::GetInstance()->sdk_int() >= 21;
+}
+
+// static
 media::VideoDecodeAccelerator::Capabilities
 AndroidVideoDecodeAccelerator::GetCapabilities() {
   Capabilities capabilities;
   SupportedProfiles& profiles = capabilities.supported_profiles;
 
   SupportedProfile profile;
 
   if (media::MediaCodecUtil::IsVp8DecoderAvailable()) {
     profile.profile = media::VP8PROFILE_ANY;
     profile.min_resolution.SetSize(0, 0);
@@ skipping 17 matching lines @@
     // software fallback for H264 on Android anyway.
     profile.max_resolution.SetSize(3840, 2160);
     profiles.push_back(profile);
   }
 
   if (UseDeferredRenderingStrategy()) {
     capabilities.flags = media::VideoDecodeAccelerator::Capabilities::
                              NEEDS_ALL_PICTURE_BUFFERS_TO_DECODE |
                          media::VideoDecodeAccelerator::Capabilities::
                              SUPPORTS_EXTERNAL_OUTPUT_SURFACE;
+    if (DeferredStrategyNeedsBrowserCopy())
+      capabilities.flags |=
+          media::VideoDecodeAccelerator::Capabilities::COPY_REQUIRED;
   }
 
   return capabilities;
 }
 
 }  // namespace content