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 12 matching lines @@
     const scoped_refptr<base::MessageLoopProxy>& compositor_message_loop,
     WebGraphicsContext3DCommandBufferImpl* context)
     : compositor_message_loop_(compositor_message_loop),
       main_message_loop_(base::MessageLoopProxy::current()),
       gpu_channel_host_(gpu_channel_host),
       aborted_waiter_(true, false),
       compositor_loop_async_waiter_(false, false),
       render_thread_async_waiter_(false, false) {
   if (compositor_message_loop_->BelongsToCurrentThread()) {
     AsyncGetContext(context);
+    compositor_loop_async_waiter_.Reset();
     return;
   }
   // Threaded compositor requires us to wait for the context to be acquired.
   compositor_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 15 matching lines @@
     }
   }
   compositor_loop_async_waiter_.Signal();
 }
 
 media::VideoDecodeAccelerator*
 RendererGpuVideoDecoderFactories::CreateVideoDecodeAccelerator(
     media::VideoCodecProfile profile,
     media::VideoDecodeAccelerator::Client* client) {
   DCHECK(!compositor_message_loop_->BelongsToCurrentThread());
+  if (compositor_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.
   compositor_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 19 matching lines @@
   compositor_loop_async_waiter_.Signal();
 }
 
 uint32 RendererGpuVideoDecoderFactories::CreateTextures(
     int32 count, const gfx::Size& size,
     std::vector<uint32>* texture_ids,
     std::vector<gpu::Mailbox>* texture_mailboxes,
     uint32 texture_target) {
   uint32 sync_point = 0;
 
-  DCHECK(!compositor_message_loop_->BelongsToCurrentThread());
+  if (compositor_message_loop_->BelongsToCurrentThread()) {
+    AsyncCreateTextures(count, size, texture_target, &sync_point);
+    texture_ids->swap(created_textures_);
+    texture_mailboxes->swap(created_texture_mailboxes_);
+    compositor_loop_async_waiter_.Reset();
+    return sync_point;
+  }
   compositor_message_loop_->PostTask(FROM_HERE, base::Bind(
       &RendererGpuVideoDecoderFactories::AsyncCreateTextures, this,
       count, size, texture_target, &sync_point));
 
   base::WaitableEvent* objects[] = {&aborted_waiter_,
                                     &compositor_loop_async_waiter_};
   if (base::WaitableEvent::WaitMany(objects, arraysize(objects)) == 0)
     return 0;
   texture_ids->swap(created_textures_);
   texture_mailboxes->swap(created_texture_mailboxes_);
@@ skipping 35 matching lines @@
   // 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));
 
   *sync_point = gles2->InsertSyncPointCHROMIUM();
   compositor_loop_async_waiter_.Signal();
 }
 
 void RendererGpuVideoDecoderFactories::DeleteTexture(uint32 texture_id) {
-  DCHECK(!compositor_message_loop_->BelongsToCurrentThread());
+  if (compositor_message_loop_->BelongsToCurrentThread()) {
+    AsyncDeleteTexture(texture_id);
+    return;
+  }
   compositor_message_loop_->PostTask(FROM_HERE, base::Bind(
       &RendererGpuVideoDecoderFactories::AsyncDeleteTexture, this, texture_id));
 }
 
 void RendererGpuVideoDecoderFactories::AsyncDeleteTexture(uint32 texture_id) {
   DCHECK(compositor_message_loop_->BelongsToCurrentThread());
   if (!context_.get())
     return;
 
   gpu::gles2::GLES2Implementation* gles2 = context_->GetImplementation();
@@ skipping 80 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(!main_message_loop_->BelongsToCurrentThread());
+  if (main_message_loop_->BelongsToCurrentThread()) {
+    return ChildThread::current()->AllocateSharedMemory(size);
+  }
   main_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