Implement proper synchronization between HW video decode IPC and CommandBuffer.

content/renderer/pepper_platform_video_decoder_impl.cc

 // Copyright (c) 2011 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/pepper_platform_video_decoder_impl.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "content/common/child_process.h"
 #include "content/renderer/gpu/gpu_channel_host.h"
 #include "content/renderer/gpu/gpu_video_decode_accelerator_host.h"
 #include "content/renderer/gpu/gpu_video_service_host.h"
 #include "content/renderer/render_thread.h"
 
 using media::BitstreamBuffer;
 
 PlatformVideoDecoderImpl::PlatformVideoDecoderImpl(
-    VideoDecodeAccelerator::Client* client, uint32 command_buffer_route_id)
+    VideoDecodeAccelerator::Client* client,
+    int32 command_buffer_route_id,
+    gpu::CommandBufferHelper* cmd_buffer_helper)
     : client_(client),
       command_buffer_route_id_(command_buffer_route_id),
+      cmd_buffer_helper_(cmd_buffer_helper),
       decoder_(NULL),
       message_loop_(NULL) {
   DCHECK(client);
 }
 
 PlatformVideoDecoderImpl::~PlatformVideoDecoderImpl() {}
 
 bool PlatformVideoDecoderImpl::GetConfigs(
     const std::vector<uint32>& requested_configs,
     std::vector<uint32>* matched_configs) {
@@ skipping 38 matching lines @@
   if (ChildProcess::current()->io_message_loop() != MessageLoop::current() ) {
     ChildProcess::current()->io_message_loop()->
         PostTask(FROM_HERE, base::Bind(
             &PlatformVideoDecoderImpl::InitializeDecoder,
             base::Unretained(this),
             configs));
     return;
   }
   GpuVideoServiceHost* video_service = channel_->gpu_video_service_host();
   decoder_.reset(video_service->CreateVideoAccelerator(
-      this, command_buffer_route_id_));
+      this, command_buffer_route_id_, cmd_buffer_helper_));
 
   // Send IPC message to initialize decoder in GPU process.
   decoder_->Initialize(configs);
 }
 
-bool PlatformVideoDecoderImpl::Decode(const BitstreamBuffer& bitstream_buffer) {
+void PlatformVideoDecoderImpl::Decode(const BitstreamBuffer& bitstream_buffer) {
   DCHECK(decoder_.get());
-  return decoder_->Decode(bitstream_buffer);
+  decoder_->Decode(bitstream_buffer);
 }
 
 void PlatformVideoDecoderImpl::AssignGLESBuffers(
     const std::vector<media::GLESBuffer>& buffers) {
   DCHECK(decoder_.get());
   decoder_->AssignGLESBuffers(buffers);
 }
 
 void PlatformVideoDecoderImpl::AssignSysmemBuffers(
     const std::vector<media::SysmemBuffer>& buffers) {
   DCHECK(decoder_.get());
   decoder_->AssignSysmemBuffers(buffers);
 }
 
 void PlatformVideoDecoderImpl::ReusePictureBuffer(
     int32 picture_buffer_id) {
   DCHECK(decoder_.get());
   decoder_->ReusePictureBuffer(picture_buffer_id);
 }
 
-bool PlatformVideoDecoderImpl::Flush() {
+void PlatformVideoDecoderImpl::Flush() {
   DCHECK(decoder_.get());
-  return decoder_->Flush();
+  decoder_->Flush();
 }
 
-bool PlatformVideoDecoderImpl::Abort() {
+void PlatformVideoDecoderImpl::Abort() {
   DCHECK(decoder_.get());
-  return decoder_->Abort();
+  decoder_->Abort();
 }
 
 void PlatformVideoDecoderImpl::NotifyEndOfStream() {
   DCHECK(message_loop_);
   message_loop_->
       PostTask(FROM_HERE, base::Bind(
           &VideoDecodeAccelerator::Client::NotifyEndOfStream,
           base::Unretained(client_)));
 }
 
@@ skipping 65 matching lines @@
           base::Unretained(client_)));
 }
 
 void PlatformVideoDecoderImpl::NotifyAbortDone() {
   DCHECK(message_loop_);
   message_loop_->
       PostTask(FROM_HERE, base::Bind(
           &VideoDecodeAccelerator::Client::NotifyAbortDone,
           base::Unretained(client_)));
 }