Introduce GpuVideoDecodeAcceleratorFactory.

content/common/gpu/media/vt_video_decode_accelerator_mac.cc

 // Copyright 2014 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 <algorithm>
 
 #include <CoreVideo/CoreVideo.h>
 #include <OpenGL/CGLIOSurface.h>
 #include <OpenGL/gl.h>
 #include <stddef.h>
@@ skipping 277 matching lines @@
   if (lhs->pic_order_cnt != rhs->pic_order_cnt)
     return lhs->pic_order_cnt > rhs->pic_order_cnt;
   // If |pic_order_cnt| is the same, fall back on using the bitstream order.
   // TODO(sandersd): Assign a sequence number in Decode() and use that instead.
   // TODO(sandersd): Using the sequence number, ensure that frames older than
   // |kMaxReorderQueueSize| are ordered first, regardless of |pic_order_cnt|.
   return lhs->bitstream_id > rhs->bitstream_id;
 }
 
 VTVideoDecodeAccelerator::VTVideoDecodeAccelerator(
-    const base::Callback<bool(void)>& make_context_current,
-    const base::Callback<void(uint32_t, uint32_t, scoped_refptr<gl::GLImage>)>&
-        bind_image)
-    : make_context_current_(make_context_current),
-      bind_image_(bind_image),
+    const MakeGLContextCurrentCallback& make_context_current_cb,
+    const BindGLImageCallback& bind_image_cb)
+    : make_context_current_cb_(make_context_current_cb),
+      bind_image_cb_(bind_image_cb),
       client_(nullptr),
       state_(STATE_DECODING),
       format_(nullptr),
       session_(nullptr),
       last_sps_id_(-1),
       last_pps_id_(-1),
       config_changed_(false),
       missing_idr_logged_(false),
       gpu_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       decoder_thread_("VTDecoderThread"),
       weak_this_factory_(this) {
-  DCHECK(!make_context_current_.is_null());
   callback_.decompressionOutputCallback = OutputThunk;
   callback_.decompressionOutputRefCon = this;
   weak_this_ = weak_this_factory_.GetWeakPtr();
 }
 
 VTVideoDecodeAccelerator::~VTVideoDecodeAccelerator() {
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
 }
 
 bool VTVideoDecodeAccelerator::Initialize(const Config& config,
                                           Client* client) {
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
 
+  if (make_context_current_cb_.is_null() || bind_image_cb_.is_null()) {
+    NOTREACHED() << "GL callbacks are required for this VDA";
+    return false;
+  }
+
   if (config.is_encrypted) {
     NOTREACHED() << "Encrypted streams are not supported for this VDA";
     return false;
   }
 
   client_ = client;
 
   if (!InitializeVideoToolbox())
     return false;
 
@@ skipping 690 matching lines @@
 
   if (available_picture_ids_.empty())
     return false;
 
   int32_t picture_id = available_picture_ids_.back();
   DCHECK(picture_info_map_.count(picture_id));
   PictureInfo* picture_info = picture_info_map_.find(picture_id)->second.get();
   DCHECK(!picture_info->cv_image);
   DCHECK(!picture_info->gl_image);
 
-  if (!make_context_current_.Run()) {
+  if (!make_context_current_cb_.Run()) {
     DLOG(ERROR) << "Failed to make GL context current";
     NotifyError(PLATFORM_FAILURE, SFT_PLATFORM_ERROR);
     return false;
   }
 
   IOSurfaceRef surface = CVPixelBufferGetIOSurface(frame.image.get());
   if (gfx::GetGLImplementation() != gfx::kGLImplementationDesktopGLCoreProfile)
     glEnable(GL_TEXTURE_RECTANGLE_ARB);
   gfx::ScopedTextureBinder texture_binder(GL_TEXTURE_RECTANGLE_ARB,
                                           picture_info->service_texture_id);
@@ skipping 18 matching lines @@
 
   bool allow_overlay = false;
   scoped_refptr<gl::GLImageIOSurface> gl_image(
       new gl::GLImageIOSurface(frame.coded_size, GL_BGRA_EXT));
   if (gl_image->Initialize(surface, gfx::GenericSharedMemoryId(),
                            gfx::BufferFormat::BGRA_8888)) {
     allow_overlay = true;
   } else {
     gl_image = nullptr;
   }
-  bind_image_.Run(picture_info->client_texture_id, GL_TEXTURE_RECTANGLE_ARB,
-                  gl_image);
+  if (!bind_image_cb_.Run(picture_info->client_texture_id,
+                          GL_TEXTURE_RECTANGLE_ARB, gl_image)) {
+    DLOG(ERROR) << "Failed to bind image";
+    NotifyError(PLATFORM_FAILURE, SFT_PLATFORM_ERROR);
+    return false;
+  }
 
   // Assign the new image(s) to the the picture info.
   picture_info->gl_image = gl_image;
   picture_info->cv_image = frame.image;
   available_picture_ids_.pop_back();
 
   // TODO(sandersd): Currently, the size got from
   // CMVideoFormatDescriptionGetDimensions is visible size. We pass it to
   // GpuVideoDecoder so that GpuVideoDecoder can use correct visible size in
   // resolution changed. We should find the correct API to get the real
@@ skipping 56 matching lines @@
   // destructing |this|.
   // TODO(sandersd): Prevent the decoder from reading buffers before discarding
   // them.
   for (int32_t bitstream_id : assigned_bitstream_ids_)
     client_->NotifyEndOfBitstreamBuffer(bitstream_id);
   assigned_bitstream_ids_.clear();
   state_ = STATE_DESTROYING;
   QueueFlush(TASK_DESTROY);
 }
 
-bool VTVideoDecodeAccelerator::CanDecodeOnIOThread() {
+bool VTVideoDecodeAccelerator::TryToSetupDecodeOnSeparateThread(
+    const base::WeakPtr<Client>& decode_client,
+    const scoped_refptr<base::SingleThreadTaskRunner>& decode_task_runner) {
   return false;
 }
 
 // static
 media::VideoDecodeAccelerator::SupportedProfiles
 VTVideoDecodeAccelerator::GetSupportedProfiles() {
   SupportedProfiles profiles;
   for (const auto& supported_profile : kSupportedProfiles) {
     SupportedProfile profile;
     profile.profile = supported_profile;
     profile.min_resolution.SetSize(16, 16);
     profile.max_resolution.SetSize(4096, 2160);
     profiles.push_back(profile);
   }
   return profiles;
 }
 
 }  // namespace content