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();
 }
 
+void GpuChannelHost::WaitForPendingGpuMemoryBufferUsageToComplete(
+    const base::Closure& callback) {
+  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));
+}
+
+void GpuChannelHost::WaitForPendingGpuMemoryBufferUsageToCompleteOnMain(
+    uint32 id) {
+  AutoLock lock(context_lock_);
+
+  size_t num_proxies = proxies_.size();
+  signal_counters_.insert(std::make_pair(id, num_proxies));

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

Instead of signal_counters_ and signal_tasks_ maps, could we create some
refcounted object that you pass to SignalSyncPoint and simple post a task to the
IO thread from the dtor of this object? I'm thinking this will make it easy to
ensure that we behave properly when a proxy is removed while we're waiting for
usage to complete. Would also remove the need for hash maps and signal ids.

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

That's a good idea, it deals with proxy removal cleanly. I don't think we can
get rid of signal_tasks_ though because external callbacks are not supposed to
cross thread boundaries.

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

hm, does it matter when you can guaranteed that it's not used or destroyed on
the other thread?

+
+  if (!num_proxies) {
+    OnSignalSyncPoint(id);
+    return;
+  }
+
+  for (ProxyMap::iterator it = proxies_.begin(); it != proxies_.end(); it++) {
+    uint32 sync_point = it->second->InsertSyncPoint();
+    it->second->SignalSyncPoint(
+        sync_point,
+        base::Bind(
+            &GpuChannelHost::OnSignalSyncPoint, base::Unretained(this), id));
+  }
+}
+
+void GpuChannelHost::OnSignalSyncPoint(uint32 id) {
+  SignalCounterMap::iterator it = signal_counters_.find(id);
+  DCHECK(it != signal_counters_.end());
+  it->second--;
+
+  if (it->second <= 0) {
+    factory_->GetIOLoopProxy()->PostTask(
+        FROM_HERE,
+        base::Bind(&GpuChannelHost::ProcessSignalCounterOnIO,
+                   base::Unretained(this),
+                   id));
+  }
+}
+
+void GpuChannelHost::ProcessSignalCounterOnIO(uint32 id) {
+  SignalTaskMap::iterator it = signal_tasks_.find(id);
+  DCHECK(it != signal_tasks_.end());
+
+  base::Closure 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