Cleanup GpuMemoryBuffer

content/common/gpu/client/gpu_channel_host.cc

 // 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.
 
 #include "content/common/gpu/client/gpu_channel_host.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
@@ skipping 32 matching lines @@
   host->Connect(channel_handle, shutdown_event);
   return host;
 }
 
 GpuChannelHost::GpuChannelHost(
     GpuChannelHostFactory* factory,
     const gpu::GPUInfo& gpu_info,
     cc::GpuMemoryBufferManager* gpu_memory_buffer_manager)
     : factory_(factory),
       gpu_info_(gpu_info),
-      gpu_memory_buffer_manager_(gpu_memory_buffer_manager) {
+      gpu_memory_buffer_manager_(gpu_memory_buffer_manager),
+      next_signal_id_(0) {
   next_transfer_buffer_id_.GetNext();
   next_image_id_.GetNext();
   next_route_id_.GetNext();
 }
 
 void GpuChannelHost::Connect(const IPC::ChannelHandle& channel_handle,
                              base::WaitableEvent* shutdown_event) {
   // Open a channel to the GPU process. We pass NULL as the main listener here
   // since we need to filter everything to route it to the right thread.
   scoped_refptr<base::MessageLoopProxy> io_loop = factory_->GetIOLoopProxy();
@@ skipping 248 matching lines @@
 }
 
 int32 GpuChannelHost::ReserveImageId() {
   return next_image_id_.GetNext();
 }
 
 int32 GpuChannelHost::GenerateRouteID() {
   return next_route_id_.GetNext();
 }
 
+namespace {
+class SyncPointTracker : public base::RefCounted<SyncPointTracker> {
+ public:
+  SyncPointTracker(const base::Closure& destruction_callback,
+                   scoped_refptr<MessageLoopProxy> caller_message_loop)
+      : destruction_callback_(destruction_callback),
+        caller_message_loop_(caller_message_loop) {}
+
+  void Noop() {}
+
+ private:
+  friend class base::RefCounted<SyncPointTracker>;
+  ~SyncPointTracker() {
+    caller_message_loop_->PostTask(FROM_HERE, destruction_callback_);
+  }
+
+  base::Closure destruction_callback_;
+  scoped_refptr<MessageLoopProxy> caller_message_loop_;
+};
+}
+
+void GpuChannelHost::WaitForPendingGpuMemoryBufferUsageToComplete(
+    const base::Closure& callback) {
+  AutoLock lock(signal_lock_);
+  uint32 signal_id = next_signal_id_++;
+  signal_tasks_.insert(std::make_pair(signal_id, callback));
+
+  factory_->GetMainLoop()->PostTask(
+      FROM_HERE,
+      base::Bind(
+          &GpuChannelHost::WaitForPendingGpuMemoryBufferUsageToCompleteOnMain,
+          base::Unretained(this),
+          signal_id,
+          base::MessageLoopProxy::current()));
+}
+
+void GpuChannelHost::WaitForPendingGpuMemoryBufferUsageToCompleteOnMain(
+    uint32 id,
+    scoped_refptr<base::MessageLoopProxy> caller_message_loop) {
+  scoped_refptr<SyncPointTracker> tracker = new SyncPointTracker(
+      base::Bind(&GpuChannelHost::WaitCompletedOnCallerThread,
+                 base::Unretained(this),
+                 id),
+      caller_message_loop);
+
+  AutoLock lock(context_lock_);
+  for (ProxyMap::iterator it = proxies_.begin(); it != proxies_.end(); it++) {
+    uint32 sync_point = it->second->InsertSyncPoint();
+    it->second->SignalSyncPoint(sync_point,
+                                base::Bind(&SyncPointTracker::Noop, tracker));
+  }

[reveman, 2014/10/22 16:20:08]

Could we make all this much simpler by just having a
WaitForPendingGpuMemoryBufferUsageToComplete on the proxy class and it would be
responsible for calling it in case it was destroyed?

Then we can simply use a base::BarrierClosure to create a compound callback
here.

+}
+
+void GpuChannelHost::WaitCompletedOnCallerThread(uint32 id) {
+  base::Closure callback;
+  {
+    AutoLock lock(signal_lock_);
+    SignalTaskMap::iterator it = signal_tasks_.find(id);
+    DCHECK(it != signal_tasks_.end());
+
+    callback = it->second;
+    signal_tasks_.erase(it);
+  }
+
+  callback.Run();
+}
+
 GpuChannelHost::~GpuChannelHost() {
   // channel_ must be destroyed on the main thread.
   if (!factory_->IsMainThread())
     factory_->GetMainLoop()->DeleteSoon(FROM_HERE, channel_.release());
 }
 
 
 GpuChannelHost::MessageFilter::MessageFilter()
     : lost_(false) {
 }
@@ skipping 59 matching lines @@
 
   listeners_.clear();
 }
 
 bool GpuChannelHost::MessageFilter::IsLost() const {
   AutoLock lock(lock_);
   return lost_;
 }
 
 }  // namespace content