Cleanup GpuMemoryBuffer

content/common/gpu/client/gpu_channel_host.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_GPU_CHANNEL_HOST_H_
 #define CONTENT_COMMON_GPU_CLIENT_GPU_CHANNEL_HOST_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 57 matching lines @@
   virtual ~GpuChannelHostFactory() {}
 
   virtual bool IsMainThread() = 0;
   virtual base::MessageLoop* GetMainLoop() = 0;
   virtual scoped_refptr<base::MessageLoopProxy> GetIOLoopProxy() = 0;
   virtual scoped_ptr<base::SharedMemory> AllocateSharedMemory(size_t size) = 0;
   virtual CreateCommandBufferResult CreateViewCommandBuffer(
       int32 surface_id,
       const GPUCreateCommandBufferConfig& init_params,
       int32 route_id) = 0;
+  virtual void WaitForPendingGpuMemoryBufferUsageToComplete(
+      const base::Closure& callback) = 0;
 };
 
 // Encapsulates an IPC channel between the client and one GPU process.
 // On the GPU process side there's a corresponding GpuChannel.
 // Every method can be called on any thread with a message loop, except for the
 // IO thread.
 class GpuChannelHost : public IPC::Sender,
                        public base::RefCountedThreadSafe<GpuChannelHost> {
  public:
   // Must be called on the main thread (as defined by the factory).
@@ skipping 66 matching lines @@
   // closed. Returns an invalid handle on failure.
   gfx::GpuMemoryBufferHandle ShareGpuMemoryBufferToGpuProcess(
       gfx::GpuMemoryBufferHandle source_handle);
 
   // Reserve one unused image ID.
   int32 ReserveImageId();
 
   // Generate a route ID guaranteed to be unique for this channel.
   int32 GenerateRouteID();
 
+  void WaitForPendingGpuMemoryBufferUsageToComplete(
+      const base::Closure& callback);
+
  private:
   friend class base::RefCountedThreadSafe<GpuChannelHost>;
   GpuChannelHost(GpuChannelHostFactory* factory,
                  const gpu::GPUInfo& gpu_info,
                  cc::GpuMemoryBufferManager* gpu_memory_buffer_manager);
   ~GpuChannelHost() override;
   void Connect(const IPC::ChannelHandle& channel_handle,
                base::WaitableEvent* shutdown_event);
 
   // A filter used internally to route incoming messages from the IO thread
@@ skipping 61 matching lines @@
 
   // Route IDs are allocated in sequence.
   base::AtomicSequenceNumber next_route_id_;
 
   // Protects proxies_.
   mutable base::Lock context_lock_;
   // Used to look up a proxy from its routing id.
   typedef base::hash_map<int, CommandBufferProxyImpl*> ProxyMap;
   ProxyMap proxies_;
 
+  void GpuMemoryBufferWaitCompleted(
+      uint32 id,
+      scoped_refptr<base::MessageLoopProxy> caller_message_loop);
+  void GpuMemoryBufferWaitCompletedOnCallerThread(uint32 id);
+
+  // Protects signal_tasks_.
+  mutable base::Lock signal_lock_;
+  typedef base::hash_map<uint32, base::Closure> SignalTaskMap;

[reveman, 2014/10/22 22:42:47]

GpuMemoryBufferUsageCompletedTaskMap?

+  SignalTaskMap signal_tasks_;
+  uint32 next_signal_id_;
+
   DISALLOW_COPY_AND_ASSIGN(GpuChannelHost);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_CLIENT_GPU_CHANNEL_HOST_H_