Integrate VDA with WebRTC.

content/renderer/media/renderer_gpu_video_decoder_factories.cc

 // Copyright (c) 2012 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/renderer/media/renderer_gpu_video_decoder_factories.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 
 #include "base/bind.h"
@@ skipping 11 matching lines @@
     GpuChannelHost* gpu_channel_host,
     const scoped_refptr<base::MessageLoopProxy>& message_loop,
     WebGraphicsContext3DCommandBufferImpl* context)
     : message_loop_(message_loop),
       gpu_channel_host_(gpu_channel_host),
       aborted_waiter_(true, false),
       compositor_loop_async_waiter_(false, false),
       render_thread_async_waiter_(false, false) {
   if (message_loop_->BelongsToCurrentThread()) {
     AsyncGetContext(context);
+    compositor_loop_async_waiter_.Reset();
     return;
   }
   // Threaded compositor requires us to wait for the context to be acquired.
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &RendererGpuVideoDecoderFactories::AsyncGetContext,
       // Unretained to avoid ref/deref'ing |*this|, which is not yet stored in a
       // scoped_refptr.  Safe because the Wait() below keeps us alive until this
       // task completes.
       base::Unretained(this),
       // OK to pass raw because the pointee is only deleted on the compositor
       // thread, and only as the result of a PostTask from the render thread
       // which can only happen after this function returns, so our PostTask will
       // run first.
       context));
   compositor_loop_async_waiter_.Wait();
 }
 
+RendererGpuVideoDecoderFactories::RendererGpuVideoDecoderFactories(
+    scoped_refptr<base::MessageLoopProxy> message_loop,
+    scoped_refptr<GpuChannelHost> gpu_channel_host,
+    base::WeakPtr<WebGraphicsContext3DCommandBufferImpl> context)
+    : message_loop_(message_loop),
+      gpu_channel_host_(gpu_channel_host),
+      context_(context),
+      aborted_waiter_(true, false),
+      compositor_loop_async_waiter_(false, false),
+      render_thread_async_waiter_(false, false) {
+}
+
+RendererGpuVideoDecoderFactories* RendererGpuVideoDecoderFactories::Copy() {
+  return new RendererGpuVideoDecoderFactories(
+      message_loop_, gpu_channel_host_, context_);
+}
+
 void RendererGpuVideoDecoderFactories::AsyncGetContext(
     WebGraphicsContext3DCommandBufferImpl* context) {
   context_ = context->AsWeakPtr();
   if (context_) {
     if (context_->makeContextCurrent()) {
       // Called once per media player, but is a no-op after the first one in
       // each renderer.
       context_->insertEventMarkerEXT("GpuVDAContext3D");
     }
   }
   compositor_loop_async_waiter_.Signal();
 }
 
 media::VideoDecodeAccelerator*
 RendererGpuVideoDecoderFactories::CreateVideoDecodeAccelerator(
     media::VideoCodecProfile profile,
     media::VideoDecodeAccelerator::Client* client) {
-  DCHECK(!message_loop_->BelongsToCurrentThread());
+  if (message_loop_->BelongsToCurrentThread()) {
+    AsyncCreateVideoDecodeAccelerator(profile, client);
+    compositor_loop_async_waiter_.Reset();
+    return vda_.release();
+  }
   // The VDA is returned in the vda_ member variable by the
   // AsyncCreateVideoDecodeAccelerator() function.
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &RendererGpuVideoDecoderFactories::AsyncCreateVideoDecodeAccelerator,
       this, profile, client));
 
   base::WaitableEvent* objects[] = {&aborted_waiter_,
                                     &compositor_loop_async_waiter_};
   if (base::WaitableEvent::WaitMany(objects, arraysize(objects)) == 0) {
     // If we are aborting and the VDA is created by the
@@ skipping 17 matching lines @@
         context_->GetCommandBufferProxy()->GetRouteID(),
         profile, client);
   }
   compositor_loop_async_waiter_.Signal();
 }
 
 bool RendererGpuVideoDecoderFactories::CreateTextures(
     int32 count, const gfx::Size& size,
     std::vector<uint32>* texture_ids,
     uint32 texture_target) {
-  DCHECK(!message_loop_->BelongsToCurrentThread());
+  if (message_loop_->BelongsToCurrentThread()) {
+    AsyncCreateTextures(count, size, texture_target);
+    texture_ids->swap(created_textures_);
+    compositor_loop_async_waiter_.Reset();
+    return true;
+  }
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &RendererGpuVideoDecoderFactories::AsyncCreateTextures, this,
       count, size, texture_target));
 
   base::WaitableEvent* objects[] = {&aborted_waiter_,
                                     &compositor_loop_async_waiter_};
   if (base::WaitableEvent::WaitMany(objects, arraysize(objects)) == 0)
     return false;
   texture_ids->swap(created_textures_);
   return true;
@@ skipping 26 matching lines @@
   }
   // We need a glFlush here to guarantee the decoder (in the GPU process) can
   // use the texture ids we return here.  Since textures are expected to be
   // reused, this should not be unacceptably expensive.
   gles2->Flush();
   DCHECK_EQ(gles2->GetError(), static_cast<GLenum>(GL_NO_ERROR));
   compositor_loop_async_waiter_.Signal();
 }
 
 void RendererGpuVideoDecoderFactories::DeleteTexture(uint32 texture_id) {
-  DCHECK(!message_loop_->BelongsToCurrentThread());
+  if (message_loop_->BelongsToCurrentThread()) {
+    AsyncDeleteTexture(texture_id);
+    return;
+  }
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &RendererGpuVideoDecoderFactories::AsyncDeleteTexture, this, texture_id));
 }
 
 void RendererGpuVideoDecoderFactories::AsyncDeleteTexture(uint32 texture_id) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   if (!context_)
     return;
 
   gpu::gles2::GLES2Implementation* gles2 = context_->GetImplementation();
@@ skipping 95 matching lines @@
   return aborted_waiter_.IsSignaled();
 }
 
 void RendererGpuVideoDecoderFactories::AsyncDestroyVideoDecodeAccelerator() {
   // OK to release because Destroy() will delete the VDA instance.
   if (vda_)
     vda_.release()->Destroy();
 }
 
 }  // namespace content