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 143 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();
 
+  // To be called on IO thread.

[reveman, 2014/10/21 20:27:58]

I assume it's more appropriate to do the thread hop in this implementation than
requiring it to be done by the caller, correct?

[alexst (slow to review), 2014/10/22 14:47:08]

I was initially thinking that since the browser side already does this on IO, it
was reasonably to enforce, but it occurs to me that we don't know which thread
might call it in a renderer, so the restriction is probably invalid.

+  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);
   virtual ~GpuChannelHost();
   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 WaitForPendingGpuMemoryBufferUsageToCompleteOnMain(uint32 id);
+  void OnSignalSyncPoint(uint32 id);
+  void ProcessSignalCounterOnIO(uint32 id);
+
+  typedef base::hash_map<uint32, base::Closure> SignalTaskMap;
+  typedef base::hash_map<uint32, int> SignalCounterMap;
+  uint32 next_signal_id_;
+  SignalTaskMap signal_tasks_;
+  SignalCounterMap signal_counters_;
+
   DISALLOW_COPY_AND_ASSIGN(GpuChannelHost);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_CLIENT_GPU_CHANNEL_HOST_H_