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
@@ skipping 14 matching lines @@
       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 16 matching lines @@
     vda_ = gpu_channel_host_->CreateVideoDecoder(
         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_.get())
     return;
 
   gpu::gles2::GLES2Implementation* gles2 = context_->GetImplementation();
@@ skipping 53 matching lines @@
   gles2->ReadPixels(0, 0, size.width(), size.height(), GL_BGRA_EXT,
       GL_UNSIGNED_BYTE, read_pixels_bitmap_.pixelRef()->pixels());
   gles2->DeleteFramebuffers(1, &fb);
   gles2->DeleteTextures(1, &tmp_texture);
   DCHECK_EQ(gles2->GetError(), static_cast<GLenum>(GL_NO_ERROR));
   compositor_loop_async_waiter_.Signal();
 }
 
 base::SharedMemory* RendererGpuVideoDecoderFactories::CreateSharedMemory(
     size_t size) {
-  DCHECK_NE(base::MessageLoop::current(),
-            ChildThread::current()->message_loop());
+  if (base::MessageLoop::current() == ChildThread::current()->message_loop()) {
+    return ChildThread::current()->AllocateSharedMemory(size);
+  }
   ChildThread::current()->message_loop()->PostTask(FROM_HERE, base::Bind(
       &RendererGpuVideoDecoderFactories::AsyncCreateSharedMemory, this,
       size));
 
   base::WaitableEvent* objects[] = {&aborted_waiter_,
                                     &render_thread_async_waiter_};
   if (base::WaitableEvent::WaitMany(objects, arraysize(objects)) == 0)
     return NULL;
   return shared_memory_segment_.release();
 }
@@ skipping 20 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