gpu: Refactor GpuMemoryBuffer framework for multi-process support.

content/common/gpu/client/command_buffer_proxy_impl.h

 // 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.
 
 #ifndef CONTENT_COMMON_GPU_CLIENT_COMMAND_BUFFER_PROXY_IMPL_H_
 #define CONTENT_COMMON_GPU_CLIENT_COMMAND_BUFFER_PROXY_IMPL_H_
 
 #include <map>
 #include <queue>
 #include <string>
 
 #include "gpu/ipc/command_buffer_proxy.h"
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/containers/hash_tables.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "content/common/gpu/gpu_memory_allocation.h"
-#include "content/common/gpu/gpu_memory_allocation.h"
 #include "gpu/command_buffer/common/command_buffer.h"
 #include "gpu/command_buffer/common/command_buffer_shared.h"
+#include "gpu/command_buffer/common/gpu_control.h"
 #include "ipc/ipc_listener.h"
 #include "media/video/video_decode_accelerator.h"
 #include "ui/base/latency_info.h"
 
 struct GPUCommandBufferConsoleMessage;
 
 namespace base {
 class SharedMemory;
 }
 
 namespace gpu {
 struct Mailbox;
 }
 
 namespace content {
 class GpuChannelHost;
 
 // Client side proxy that forwards messages synchronously to a
 // CommandBufferStub.
 class CommandBufferProxyImpl
     : public CommandBufferProxy,
+      public gpu::GpuControl,

[no sievers, 2013/08/13 00:45:43]

I *thought* the concern of routing everything through the CommandBuffer was more
relevant to the client/proxy side.

If we still route things through here, why don't we just implement the service
portion in GpuCommandBufferStub then, similar to other things we already do?

[reveman, 2013/08/13 01:48:26]

I like having a *Service class that can be shared between in-process and
out-of-process usage. Part for code-reuse but mostly because I think it forces
us to make code work in both modes, or at least makes us think about how
something would work in the alternative mode when adding something new.

       public IPC::Listener,
       public base::SupportsWeakPtr<CommandBufferProxyImpl> {
  public:
   class DeletionObserver {
    public:
     // Called during the destruction of the CommandBufferProxyImpl.
     virtual void OnWillDeleteImpl() = 0;
 
    protected:
     virtual ~DeletionObserver() {}
@@ skipping 37 matching lines @@
   virtual gpu::Buffer CreateTransferBuffer(size_t size,
                                            int32* id) OVERRIDE;
   virtual void DestroyTransferBuffer(int32 id) OVERRIDE;
   virtual gpu::Buffer GetTransferBuffer(int32 id) OVERRIDE;
   virtual void SetToken(int32 token) OVERRIDE;
   virtual void SetParseError(gpu::error::Error error) OVERRIDE;
   virtual void SetContextLostReason(
       gpu::error::ContextLostReason reason) OVERRIDE;
   virtual uint32 InsertSyncPoint() OVERRIDE;
 
+  // GpuControl implementation:
+  virtual gfx::GpuMemoryBuffer* CreateGpuMemoryBuffer(
+      size_t width,
+      size_t height,
+      unsigned internalformat,
+      int32* id) OVERRIDE;
+  virtual void DestroyGpuMemoryBuffer(int32 id) OVERRIDE;
+
   void SetMemoryAllocationChangedCallback(
       const base::Callback<void(const GpuMemoryAllocationForRenderer&)>&
           callback);
 
   void AddDeletionObserver(DeletionObserver* observer);
   void RemoveDeletionObserver(DeletionObserver* observer);
 
   bool DiscardBackbuffer();
   bool EnsureBackbuffer();
 
@@ skipping 90 matching lines @@
   // Tasks to be invoked in SignalSyncPoint responses.
   uint32 next_signal_id_;
   SignalTaskMap signal_tasks_;
 
   DISALLOW_COPY_AND_ASSIGN(CommandBufferProxyImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_CLIENT_COMMAND_BUFFER_PROXY_IMPL_H_