Support multiple HW video decoders per context.

content/renderer/gpu/command_buffer_proxy.h

 // 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.
 
 #ifndef CONTENT_RENDERER_GPU_COMMAND_BUFFER_PROXY_H_
 #define CONTENT_RENDERER_GPU_COMMAND_BUFFER_PROXY_H_
 #pragma once
 
 #if defined(ENABLE_GPU)
 
 #include <map>
 #include <queue>
 
 #include "base/callback_old.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "content/renderer/gpu/gpu_video_decode_accelerator_host.h"
 #include "gpu/command_buffer/common/command_buffer.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_message.h"
 
 namespace base {
 class SharedMemory;
 }
 
 namespace gfx {
 class Size;
 }
 
+class GpuChannelHost;
 class PluginChannelHost;
 class Task;
 
 // Client side proxy that forwards messages synchronously to a
 // CommandBufferStub.
 class CommandBufferProxy : public gpu::CommandBuffer,
                            public IPC::Channel::Listener {
  public:
-  CommandBufferProxy(IPC::Channel::Sender* channel, int route_id);
+  CommandBufferProxy(GpuChannelHost* channel, int route_id);
   virtual ~CommandBufferProxy();
 
   // IPC::Channel::Listener implementation:
   virtual bool OnMessageReceived(const IPC::Message& message);
   virtual void OnChannelError();
 
   int route_id() const { return route_id_; }
 
   // CommandBuffer implementation:
   virtual bool Initialize(int32 size);
@@ skipping 61 matching lines @@
   void OnDestroyed(gpu::error::ContextLostReason reason);
 
   // As with the service, the client takes ownership of the ring buffer.
   int32 num_entries_;
   scoped_ptr<base::SharedMemory> ring_buffer_;
 
   // Local cache of id to transfer buffer mapping.
   typedef std::map<int32, gpu::Buffer> TransferBufferMap;
   TransferBufferMap transfer_buffers_;
 
-  // The video decoder host corresponding to the stub's video decoder in the GPU
-  // process, if one exists.
-  scoped_refptr<GpuVideoDecodeAcceleratorHost> video_decoder_host_;
+  // Zero or more video decoder hosts owned by this proxy, keyed by their
+  // decoder_route_id.
+  typedef std::map<int, scoped_refptr<GpuVideoDecodeAcceleratorHost> > Decoders;
+  Decoders video_decoder_hosts_;
 
   // The last cached state received from the service.
   State last_state_;
 
-  IPC::Channel::Sender* channel_;
+  // |*this| is owned by |*channel_| and so is always outlived by it, so using a
+  // raw pointer is ok.
+  GpuChannelHost* channel_;
   int route_id_;
   unsigned int flush_count_;
 
   scoped_ptr<Task> notify_repaint_task_;
 
   scoped_ptr<Callback0::Type> swap_buffers_callback_;
   scoped_ptr<Callback0::Type> channel_error_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(CommandBufferProxy);
 };
 
 #endif  // ENABLE_GPU
 
 #endif  // CONTENT_RENDERER_GPU_COMMAND_BUFFER_PROXY_H_