Reland: Introduce GpuVideoDecodeAcceleratorFactory.

content/common/gpu/media/fake_video_decode_accelerator.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 "content/common/gpu/media/fake_video_decode_accelerator.h"
 
 #include <stddef.h>
 #include <string.h>
 
 #include "base/bind.h"
@@ skipping 11 matching lines @@
 
 static const uint32_t kDefaultTextureTarget = GL_TEXTURE_2D;
 // Must be at least 2 since the rendering helper will switch between textures
 // and if there is only one, it will wait for the next one that will never come.
 // Must also be an even number as otherwise there won't be the same amount of
 // white and black frames.
 static const unsigned int kNumBuffers = media::limits::kMaxVideoFrames +
     (media::limits::kMaxVideoFrames & 1u);
 
 FakeVideoDecodeAccelerator::FakeVideoDecodeAccelerator(
-    gfx::GLContext* gl,
-    gfx::Size size,
-    const base::Callback<bool(void)>& make_context_current)
+    const gfx::Size& size,
+    const MakeGLContextCurrentCallback& make_context_current_cb)
     : child_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       client_(NULL),
-      make_context_current_(make_context_current),
-      gl_(gl),
+      make_context_current_cb_(make_context_current_cb),
       frame_buffer_size_(size),
       flushing_(false),
-      weak_this_factory_(this) {
-}
+      weak_this_factory_(this) {}
 
 FakeVideoDecodeAccelerator::~FakeVideoDecodeAccelerator() {
 }
 
 bool FakeVideoDecodeAccelerator::Initialize(const Config& config,
                                             Client* client) {
   DCHECK(child_task_runner_->BelongsToCurrentThread());
   if (config.profile == media::VIDEO_CODEC_PROFILE_UNKNOWN) {
     LOG(ERROR) << "unknown codec profile";
     return false;
@@ skipping 42 matching lines @@
                   4]);
   memset(white_data.get(),
          UINT8_MAX,
          frame_buffer_size_.width() * frame_buffer_size_.height() * 4);
   scoped_ptr<uint8_t[]> black_data(
       new uint8_t[frame_buffer_size_.width() * frame_buffer_size_.height() *
                   4]);
   memset(black_data.get(),
          0,
          frame_buffer_size_.width() * frame_buffer_size_.height() * 4);
-  if (!make_context_current_.Run()) {
+  if (!make_context_current_cb_.Run()) {
     LOG(ERROR) << "ReusePictureBuffer(): could not make context current";
     return;
   }
   for (size_t index = 0; index < buffers.size(); ++index) {
     DCHECK_LE(1u, buffers[index].texture_ids().size());
     glBindTexture(GL_TEXTURE_2D, buffers[index].texture_ids()[0]);
     // Every other frame white and the rest black.
     uint8_t* data = index % 2 ? white_data.get() : black_data.get();
     glTexImage2D(GL_TEXTURE_2D,
                  0,
@@ skipping 39 matching lines @@
 }
 
 void FakeVideoDecodeAccelerator::Destroy() {
   while (!queued_bitstream_ids_.empty()) {
     client_->NotifyEndOfBitstreamBuffer(queued_bitstream_ids_.front());
     queued_bitstream_ids_.pop();
   }
   delete this;
 }
 
-bool FakeVideoDecodeAccelerator::CanDecodeOnIOThread() {
-  return true;
+bool FakeVideoDecodeAccelerator::TryToSetupDecodeOnSeparateThread(
+    const base::WeakPtr<Client>& decode_client,
+    const scoped_refptr<base::SingleThreadTaskRunner>& decode_task_runner) {
+  return false;
 }
 
 void FakeVideoDecodeAccelerator::DoPictureReady() {
   if (flushing_ && queued_bitstream_ids_.empty()) {
     flushing_ = false;
     client_->NotifyFlushDone();
   }
   while (!free_output_buffers_.empty() && !queued_bitstream_ids_.empty()) {
     int bitstream_id = queued_bitstream_ids_.front();
     queued_bitstream_ids_.pop();
     int buffer_id = free_output_buffers_.front();
     free_output_buffers_.pop();
 
     const media::Picture picture =
         media::Picture(buffer_id,
                        bitstream_id,
                        gfx::Rect(frame_buffer_size_),
                        false);
     client_->PictureReady(picture);
     // Bitstream no longer needed.
     client_->NotifyEndOfBitstreamBuffer(bitstream_id);
     if (flushing_ && queued_bitstream_ids_.empty()) {
       flushing_ = false;
       client_->NotifyFlushDone();
     }
   }
 }
 
 }  // namespace content