Introduce GpuVideoDecodeAcceleratorFactory.

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 235 matching lines @@
   // Repeating timer responsible for draining pending IO to the codecs.
   base::RepeatingTimer io_timer_;
 
   DISALLOW_COPY_AND_ASSIGN(AVDATimerManager);
 };
 
 static base::LazyInstance<AVDATimerManager>::Leaky g_avda_timer =
     LAZY_INSTANCE_INITIALIZER;
 
 AndroidVideoDecodeAccelerator::AndroidVideoDecodeAccelerator(
-    const base::WeakPtr<gpu::gles2::GLES2Decoder> decoder,
-    const base::Callback<bool(void)>& make_context_current)
+    const MakeGLContextCurrentCallback& make_context_current_cb,
+    const GetGLES2DecoderCallback& get_gles2_decoder_cb)
     : client_(NULL),
-      make_context_current_(make_context_current),
+      make_context_current_cb_(make_context_current_cb),
+      get_gles2_decoder_cb_(get_gles2_decoder_cb),
       codec_(media::kCodecH264),
       is_encrypted_(false),
       needs_protected_surface_(false),
       state_(NO_ERROR),
       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());
-    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));
-  }
-}
+      weak_this_factory_(this) {}
 
 AndroidVideoDecodeAccelerator::~AndroidVideoDecodeAccelerator() {
   DCHECK(thread_checker_.CalledOnValidThread());
   g_avda_timer.Pointer()->StopTimer(this);
 
 #if defined(ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
   if (cdm_) {
     DCHECK(cdm_registration_id_);
     static_cast<media::MediaDrmBridge*>(cdm_.get())
         ->UnregisterPlayer(cdm_registration_id_);
   }
 #endif  // defined(ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
 }
 
 bool AndroidVideoDecodeAccelerator::Initialize(const Config& config,
                                                Client* client) {
   DCHECK(!media_codec_);
   DCHECK(thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("media", "AVDA::Initialize");
 
   DVLOG(1) << __FUNCTION__ << ": " << config.AsHumanReadableString();
 
+  if (make_context_current_cb_.is_null() || get_gles2_decoder_cb_.is_null()) {
+    NOTREACHED() << "GL callbacks are required for this VDA";
+    return false;
+  }
+
   DCHECK(client);
   client_ = client;
   codec_ = VideoCodecProfileToVideoCodec(config.profile);
   is_encrypted_ = config.is_encrypted;
 
   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
   // or if the stream is encrypted.
   if ((codec_ == media::kCodecVP8 || codec_ == media::kCodecVP9) &&
       !is_encrypted_) {
     if (media::VideoCodecBridge::IsKnownUnaccelerated(
             codec_, media::MEDIA_CODEC_DECODER)) {
       DVLOG(1) << "Initialization failed: "
                << (codec_ == media::kCodecVP8 ? "vp8" : "vp9")
                << " is not hardware accelerated";
       return false;
     }
   }
 
-  if (!make_context_current_.Run()) {
+  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.
+    auto gles_decoder = get_gles2_decoder_cb_.Run();
+    if (!gles_decoder) {
+      LOG(ERROR) << "Failed to get gles2 decoder instance.";
+      return false;
+    }
+    DCHECK(!gles_decoder->GetContextGroup()->mailbox_manager()->UsesSync());
+    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));
+  }
+
+  if (!make_context_current_cb_.Run()) {
     LOG(ERROR) << "Failed to make this decoder's GL context current.";
     return false;
   }
 
-  if (!gl_decoder_) {
-    LOG(ERROR) << "Failed to get gles2 decoder instance.";
-    return false;
-  }
-
   surface_ = strategy_->Initialize(config.surface_id);
   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();
@@ skipping 360 matching lines @@
 }
 
 void AndroidVideoDecodeAccelerator::SendDecodedFrameToClient(
     int32_t codec_buffer_index,
     int32_t bitstream_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_NE(bitstream_id, -1);
   DCHECK(!free_picture_ids_.empty());
   TRACE_EVENT0("media", "AVDA::SendDecodedFrameToClient");
 
-  if (!make_context_current_.Run()) {
+  if (!make_context_current_cb_.Run()) {
     POST_ERROR(PLATFORM_FAILURE, "Failed to make the GL context current.");
     return;
   }
 
   int32_t picture_buffer_id = free_picture_ids_.front();
   free_picture_ids_.pop();
   TRACE_COUNTER1("media", "AVDA::FreePictureIds", free_picture_ids_.size());
 
   const auto& i = output_picture_buffers_.find(picture_buffer_id);
   if (i == output_picture_buffers_.end()) {
@@ skipping 257 matching lines @@
   ResetCodecState();
 
   base::MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(&AndroidVideoDecodeAccelerator::NotifyResetDone,
                             weak_this_factory_.GetWeakPtr()));
 }
 
 void AndroidVideoDecodeAccelerator::Destroy() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  bool have_context = make_context_current_.Run();
+  bool have_context = make_context_current_cb_.Run();
   if (!have_context)
     LOG(WARNING) << "Failed make GL context current for Destroy, continuing.";
 
   strategy_->Cleanup(have_context, output_picture_buffers_);
 
   // If we have an OnFrameAvailable handler, tell it that we're going away.
   if (on_frame_available_handler_) {
     on_frame_available_handler_->ClearOwner();
     on_frame_available_handler_ = nullptr;
   }
 
   weak_this_factory_.InvalidateWeakPtrs();
   if (media_codec_) {
     g_avda_timer.Pointer()->StopTimer(this);
     media_codec_.reset();
   }
   delete this;
 }
 
-bool AndroidVideoDecodeAccelerator::CanDecodeOnIOThread() {
+bool AndroidVideoDecodeAccelerator::TryToSetupDecodeOnSeparateThread(
+    const base::WeakPtr<Client>& decode_client,
+    const scoped_refptr<base::SingleThreadTaskRunner>& decode_task_runner) {
   return false;
 }
 
 const gfx::Size& AndroidVideoDecodeAccelerator::GetSize() const {
   return size_;
 }
 
 const base::ThreadChecker& AndroidVideoDecodeAccelerator::ThreadChecker()
     const {
   return thread_checker_;
 }
 
 base::WeakPtr<gpu::gles2::GLES2Decoder>
 AndroidVideoDecodeAccelerator::GetGlDecoder() const {
-  return gl_decoder_;
+  return get_gles2_decoder_cb_.Run();
 }
 
 gpu::gles2::TextureRef* AndroidVideoDecodeAccelerator::GetTextureForPicture(
     const media::PictureBuffer& picture_buffer) {
-  RETURN_ON_FAILURE(this, gl_decoder_, "Null gl_decoder_", ILLEGAL_STATE,
-                    nullptr);
-  RETURN_ON_FAILURE(this, gl_decoder_->GetContextGroup(),
-                    "Null gl_decoder_->GetContextGroup()", ILLEGAL_STATE,
+  auto gles_decoder = GetGlDecoder();
+  RETURN_ON_FAILURE(this, gles_decoder, "Failed to get GL decoder",
+                    ILLEGAL_STATE, nullptr);
+  RETURN_ON_FAILURE(this, gles_decoder->GetContextGroup(),
+                    "Null gles_decoder->GetContextGroup()", ILLEGAL_STATE,
                     nullptr);
   gpu::gles2::TextureManager* texture_manager =
-      gl_decoder_->GetContextGroup()->texture_manager();
+      gles_decoder->GetContextGroup()->texture_manager();
   RETURN_ON_FAILURE(this, texture_manager, "Null texture_manager",
                     ILLEGAL_STATE, nullptr);
   gpu::gles2::TextureRef* texture_ref =
       texture_manager->GetTexture(picture_buffer.internal_texture_id());
   RETURN_ON_FAILURE(this, texture_manager, "Null texture_ref", ILLEGAL_STATE,
                     nullptr);
 
   return texture_ref;
 }
 
@@ skipping 144 matching lines @@
     capabilities.flags = media::VideoDecodeAccelerator::Capabilities::
                              NEEDS_ALL_PICTURE_BUFFERS_TO_DECODE |
                          media::VideoDecodeAccelerator::Capabilities::
                              SUPPORTS_EXTERNAL_OUTPUT_SURFACE;
   }
 
   return capabilities;
 }
 
 }  // namespace content