Make VEA client of command buffer; move sync. IPC to VDA/VEA::Initialize()

content/common/gpu/media/gpu_video_decode_accelerator.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/common/gpu/media/gpu_video_decode_accelerator.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 24 matching lines @@
 #elif defined(OS_ANDROID)
 #include "content/common/gpu/media/android_video_decode_accelerator.h"
 #endif
 
 #include "ui/gfx/size.h"
 
 namespace content {
 
 static bool MakeDecoderContextCurrent(
     const base::WeakPtr<GpuCommandBufferStub> stub) {
-  if (!stub.get()) {
+  if (!stub) {
     DLOG(ERROR) << "Stub is gone; won't MakeCurrent().";
     return false;
   }
 
   if (!stub->decoder()->MakeCurrent()) {
     DLOG(ERROR) << "Failed to MakeCurrent()";
     return false;
   }
 
   return true;
@@ skipping 57 matching lines @@
   GpuVideoDecodeAccelerator* owner_;
   int32 host_route_id_;
   // The channel to which this filter was added.
   IPC::Channel* channel_;
 };
 
 GpuVideoDecodeAccelerator::GpuVideoDecodeAccelerator(
     int32 host_route_id,
     GpuCommandBufferStub* stub,
     const scoped_refptr<base::MessageLoopProxy>& io_message_loop)
-    : init_done_msg_(NULL),
-      host_route_id_(host_route_id),
+    : host_route_id_(host_route_id),
       stub_(stub),
       texture_target_(0),
       filter_removed_(true, false),
       io_message_loop_(io_message_loop),
       weak_factory_for_io_(this) {
   DCHECK(stub_);
   stub_->AddDestructionObserver(this);
   stub_->channel()->AddRoute(host_route_id_, this);
   child_message_loop_ = base::MessageLoopProxy::current();
   make_context_current_ =
       base::Bind(&MakeDecoderContextCurrent, stub_->AsWeakPtr());
 }
 
 GpuVideoDecodeAccelerator::~GpuVideoDecodeAccelerator() {
   // This class can only be self-deleted from OnWillDestroyStub(), which means
   // the VDA has already been destroyed in there.
-  CHECK(!video_decode_accelerator_.get());
+  DCHECK(!video_decode_accelerator_);
 }
 
 bool GpuVideoDecodeAccelerator::OnMessageReceived(const IPC::Message& msg) {
   if (!video_decode_accelerator_)
     return false;
 
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(GpuVideoDecodeAccelerator, msg)
     IPC_MESSAGE_HANDLER(AcceleratedVideoDecoderMsg_Decode, OnDecode)
     IPC_MESSAGE_HANDLER(AcceleratedVideoDecoderMsg_AssignPictureBuffers,
@@ skipping 58 matching lines @@
   if (!Send(new AcceleratedVideoDecoderHostMsg_PictureReady(
           host_route_id_,
           picture.picture_buffer_id(),
           picture.bitstream_buffer_id()))) {
     DLOG(ERROR) << "Send(AcceleratedVideoDecoderHostMsg_PictureReady) failed";
   }
 }
 
 void GpuVideoDecodeAccelerator::NotifyError(
     media::VideoDecodeAccelerator::Error error) {
-  if (init_done_msg_) {
-    // If we get an error while we're initializing, NotifyInitializeDone won't
-    // be called, so we need to send the reply (with an error) here.
-    GpuCommandBufferMsg_CreateVideoDecoder::WriteReplyParams(
-        init_done_msg_, -1);
-    if (!Send(init_done_msg_))
-      DLOG(ERROR) << "Send(init_done_msg_) failed";
-    init_done_msg_ = NULL;
-    return;
-  }
   if (!Send(new AcceleratedVideoDecoderHostMsg_ErrorNotification(
           host_route_id_, error))) {
     DLOG(ERROR) << "Send(AcceleratedVideoDecoderHostMsg_ErrorNotification) "
                 << "failed";
   }
 }
 
 void GpuVideoDecodeAccelerator::Initialize(
     const media::VideoCodecProfile profile,
     IPC::Message* init_done_msg) {
   DCHECK(!video_decode_accelerator_.get());
-  DCHECK(!init_done_msg_);
-  DCHECK(init_done_msg);
-  init_done_msg_ = init_done_msg;
 
 #if !defined(OS_WIN)
   // Ensure we will be able to get a GL context at all before initializing
   // non-Windows VDAs.
   if (!make_context_current_.Run()) {
-    NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
+    SendCreateDecoderReply(init_done_msg, MSG_ROUTING_NONE);
     return;
   }
 #endif
 
 #if defined(OS_WIN)
   if (base::win::GetVersion() < base::win::VERSION_WIN7) {
     NOTIMPLEMENTED() << "HW video decode acceleration not available.";
-    NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
+    SendCreateDecoderReply(init_done_msg, MSG_ROUTING_NONE);
     return;
   }
   DVLOG(0) << "Initializing DXVA HW decoder for windows.";
   video_decode_accelerator_.reset(
       new DXVAVideoDecodeAccelerator(make_context_current_));
 #elif defined(OS_CHROMEOS) && defined(ARCH_CPU_ARMEL) && defined(USE_X11)
   scoped_ptr<V4L2Device> device =
       V4L2Device::Create(stub_->decoder()->GetGLContext()->GetHandle());
   if (!device.get()) {
-    NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
+    SendCreateDecoderReply(init_done_msg, MSG_ROUTING_NONE);
     return;
   }
   video_decode_accelerator_.reset(
       new V4L2VideoDecodeAccelerator(gfx::GLSurfaceEGL::GetHardwareDisplay(),
                                      weak_factory_for_io_.GetWeakPtr(),
                                      make_context_current_,
                                      device.Pass(),
                                      io_message_loop_));
 #elif defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY) && defined(USE_X11)
   if (gfx::GetGLImplementation() != gfx::kGLImplementationDesktopGL) {
     VLOG(1) << "HW video decode acceleration not available without "
                "DesktopGL (GLX).";
-    NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
+    SendCreateDecoderReply(init_done_msg, MSG_ROUTING_NONE);
     return;
   }
   gfx::GLContextGLX* glx_context =
       static_cast<gfx::GLContextGLX*>(stub_->decoder()->GetGLContext());
   video_decode_accelerator_.reset(new VaapiVideoDecodeAccelerator(
       glx_context->display(), make_context_current_));
 #elif defined(OS_ANDROID)
   video_decode_accelerator_.reset(new AndroidVideoDecodeAccelerator(
       stub_->decoder()->AsWeakPtr(),
       make_context_current_));
 #else
   NOTIMPLEMENTED() << "HW video decode acceleration not available.";
-  NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
+  SendCreateDecoderReply(init_done_msg, MSG_ROUTING_NONE);
   return;
 #endif
 
   if (video_decode_accelerator_->CanDecodeOnIOThread()) {
     filter_ = new MessageFilter(this, host_route_id_);
     stub_->channel()->AddFilter(filter_.get());
   }
 
-  if (!video_decode_accelerator_->Initialize(profile, this))
-    NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
+  if (!video_decode_accelerator_->Initialize(profile, this)) {
+    SendCreateDecoderReply(init_done_msg, MSG_ROUTING_NONE);
+    return;
+  }
+
+  SendCreateDecoderReply(init_done_msg, host_route_id_);
 }
 
 // Runs on IO thread if video_decode_accelerator_->CanDecodeOnIOThread() is
 // true, otherwise on the main thread.
 void GpuVideoDecodeAccelerator::OnDecode(
     base::SharedMemoryHandle handle, int32 id, uint32 size) {
   DCHECK(video_decode_accelerator_.get());
   if (id < 0) {
     DLOG(ERROR) << "BitstreamBuffer id " << id << " out of range";
     if (child_message_loop_->BelongsToCurrentThread()) {
@@ skipping 116 matching lines @@
 void GpuVideoDecodeAccelerator::NotifyEndOfBitstreamBuffer(
     int32 bitstream_buffer_id) {
   if (!Send(new AcceleratedVideoDecoderHostMsg_BitstreamBufferProcessed(
           host_route_id_, bitstream_buffer_id))) {
     DLOG(ERROR)
         << "Send(AcceleratedVideoDecoderHostMsg_BitstreamBufferProcessed) "
         << "failed";
   }
 }
 
-void GpuVideoDecodeAccelerator::NotifyInitializeDone() {
-  GpuCommandBufferMsg_CreateVideoDecoder::WriteReplyParams(
-      init_done_msg_, host_route_id_);
-  if (!Send(init_done_msg_))
-    DLOG(ERROR) << "Send(init_done_msg_) failed";
-  init_done_msg_ = NULL;
-}
-
 void GpuVideoDecodeAccelerator::NotifyFlushDone() {
   if (!Send(new AcceleratedVideoDecoderHostMsg_FlushDone(host_route_id_)))
     DLOG(ERROR) << "Send(AcceleratedVideoDecoderHostMsg_FlushDone) failed";
 }
 
 void GpuVideoDecodeAccelerator::NotifyResetDone() {
   if (!Send(new AcceleratedVideoDecoderHostMsg_ResetDone(host_route_id_)))
     DLOG(ERROR) << "Send(AcceleratedVideoDecoderHostMsg_ResetDone) failed";
 }
 
@@ skipping 13 matching lines @@
 
   stub_->channel()->RemoveRoute(host_route_id_);
   stub_->RemoveDestructionObserver(this);
 
   if (video_decode_accelerator_)
     video_decode_accelerator_.release()->Destroy();
 
   delete this;
 }
 
-bool GpuVideoDecodeAccelerator::Send(IPC::Message* message) {
-  if (filter_.get() && io_message_loop_->BelongsToCurrentThread())
-    return filter_->SendOnIOThread(message);
-  DCHECK(child_message_loop_->BelongsToCurrentThread());
-  return stub_->channel()->Send(message);
-}
-
 void GpuVideoDecodeAccelerator::SetTextureCleared(
     const media::Picture& picture) {
   DCHECK(child_message_loop_->BelongsToCurrentThread());
   DebugAutoLock auto_lock(debug_uncleared_textures_lock_);
   std::map<int32, scoped_refptr<gpu::gles2::TextureRef> >::iterator it;
   it = uncleared_textures_.find(picture.picture_buffer_id());
   if (it == uncleared_textures_.end())
     return;  // the texture has been cleared
 
   scoped_refptr<gpu::gles2::TextureRef> texture_ref = it->second;
   GLenum target = texture_ref->texture()->target();
   gpu::gles2::TextureManager* texture_manager =
       stub_->decoder()->GetContextGroup()->texture_manager();
   DCHECK(!texture_ref->texture()->IsLevelCleared(target, 0));
   texture_manager->SetLevelCleared(texture_ref, target, 0, true);
   uncleared_textures_.erase(it);
 }
 
+bool GpuVideoDecodeAccelerator::Send(IPC::Message* message) {
+  if (filter_.get() && io_message_loop_->BelongsToCurrentThread())
+    return filter_->SendOnIOThread(message);
+  DCHECK(child_message_loop_->BelongsToCurrentThread());
+  return stub_->channel()->Send(message);
+}
+
+void GpuVideoDecodeAccelerator::SendCreateDecoderReply(IPC::Message* message,
+                                                       int32 route_id) {
+  GpuCommandBufferMsg_CreateVideoDecoder::WriteReplyParams(message, route_id);
+  Send(message);
+}
+
 }  // namespace content