Support multiple HW video decoders per context.

content/renderer/gpu/command_buffer_proxy.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/gpu/command_buffer_proxy.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/process_util.h"
 #include "base/shared_memory.h"
 #include "base/task.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/plugin_messages.h"
 #include "content/common/view_messages.h"
+#include "content/renderer/gpu/gpu_channel_host.h"
 #include "content/renderer/plugin_channel_host.h"
 #include "content/renderer/render_thread.h"
 #include "gpu/command_buffer/common/cmd_buffer_common.h"
 #include "ui/gfx/size.h"
 
 using gpu::Buffer;
 
 CommandBufferProxy::CommandBufferProxy(
-    IPC::Channel::Sender* channel,
+    GpuChannelHost* channel,
     int route_id)
     : num_entries_(0),
       channel_(channel),
       route_id_(route_id),
       flush_count_(0) {
 }
 
 CommandBufferProxy::~CommandBufferProxy() {
   // Delete all the locally cached shared memory objects, closing the handle
   // in this process.
   for (TransferBufferMap::iterator it = transfer_buffers_.begin();
        it != transfer_buffers_.end();
        ++it) {
     delete it->second.shared_memory;
     it->second.shared_memory = NULL;
   }
 }
 
 bool CommandBufferProxy::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(CommandBufferProxy, message)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_UpdateState, OnUpdateState);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_Destroyed, OnDestroyed);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SwapBuffers, OnSwapBuffers);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_NotifyRepaint,
                         OnNotifyRepaint);
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
-  if (!handled && video_decoder_host_)
-    handled = video_decoder_host_->OnMessageReceived(message);
-
   DCHECK(handled);
   return handled;
 }
 
 void CommandBufferProxy::OnChannelError() {
-  if (video_decoder_host_)
-    video_decoder_host_->OnChannelError();
+  for (Decoders::iterator it = video_decoder_hosts_.begin();
+       it != video_decoder_hosts_.end(); ++it) {
+    it->second->OnChannelError();
+  }
   OnDestroyed(gpu::error::kUnknown);
 }
 
 void CommandBufferProxy::OnDestroyed(gpu::error::ContextLostReason reason) {
   // Prevent any further messages from being sent.
   channel_ = NULL;
 
   // When the client sees that the context is lost, they should delete this
   // CommandBufferProxy and create a new one.
   last_state_.error = gpu::error::kLostContext;
@@ skipping 315 matching lines @@
 }
 
 void CommandBufferProxy::SetNotifyRepaintTask(Task* task) {
   notify_repaint_task_.reset(task);
 }
 
 scoped_refptr<GpuVideoDecodeAcceleratorHost>
 CommandBufferProxy::CreateVideoDecoder(
     const std::vector<int32>& configs,
     media::VideoDecodeAccelerator::Client* client) {
-  video_decoder_host_ = new GpuVideoDecodeAcceleratorHost(
-      channel_, route_id_, client);
-
-  if (!Send(new GpuCommandBufferMsg_CreateVideoDecoder(route_id_, configs))) {
+  int decoder_route_id;
+  if (!Send(new GpuCommandBufferMsg_CreateVideoDecoder(route_id_, configs,
+                                                       &decoder_route_id))) {
     LOG(ERROR) << "Send(GpuChannelMsg_CreateVideoDecoder) failed";
-    video_decoder_host_ = NULL;
+    return NULL;
   }
 
-  return video_decoder_host_;
+  scoped_refptr<GpuVideoDecodeAcceleratorHost> decoder_host =
+      new GpuVideoDecodeAcceleratorHost(channel_, decoder_route_id, client);
+  bool inserted = video_decoder_hosts_.insert(std::make_pair(
+      decoder_route_id, decoder_host)).second;
+  DCHECK(inserted);
+
+  channel_->AddRoute(decoder_route_id, decoder_host.get());
+
+  return decoder_host;
 }
 
 #if defined(OS_MACOSX)
 void CommandBufferProxy::SetWindowSize(const gfx::Size& size) {
   if (last_state_.error != gpu::error::kNoError)
     return;
 
   Send(new GpuCommandBufferMsg_SetWindowSize(route_id_, size));
 }
 #endif
@@ skipping 19 matching lines @@
   delete msg;
   return false;
 }
 
 void CommandBufferProxy::OnUpdateState(const gpu::CommandBuffer::State& state) {
   // Handle wraparound. It works as long as we don't have more than 2B state
   // updates in flight across which reordering occurs.
   if (state.generation - last_state_.generation < 0x80000000U)
     last_state_ = state;
 }