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/barrier_closure.h"
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/threading/thread_restrictions.h"
 #include "content/common/gpu/client/command_buffer_proxy_impl.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "ipc/ipc_sync_message_filter.h"
 #include "url/gurl.h"
@@ skipping 24 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) {
+  AutoLock lock(signal_lock_);
+  uint32 signal_id = next_signal_id_++;
+  signal_tasks_.insert(std::make_pair(signal_id, callback));
+
+  base::Closure proxy_barrier_closure = base::BarrierClosure(
+      proxies_.size(),
+      base::Bind(&GpuChannelHost::GpuMemoryBufferWaitCompleted,
+                 base::Unretained(this),

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

is this safe?

+                 signal_id,
+                 base::MessageLoopProxy::current()));
+  for (ProxyMap::iterator it = proxies_.begin(); it != proxies_.end(); it++) {
+    it->second->WaitForPendingGpuMemoryBufferUsageToComplete(
+        proxy_barrier_closure);
+  }
+}
+
+void GpuChannelHost::GpuMemoryBufferWaitCompleted(

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

GpuMemoryBufferUsageCompleted

+    uint32 id,
+    scoped_refptr<base::MessageLoopProxy> caller_message_loop) {
+  caller_message_loop->PostTask(
+      FROM_HERE,
+      base::Bind(&GpuChannelHost::GpuMemoryBufferWaitCompletedOnCallerThread,
+                 base::Unretained(this),

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

is this safe? what if the GpuChannelHost is deleted while this is pending?

it seems like it would be easier to ensure that
GpuMemoryBufferUsageCompleted/OnCallerThread was always called and the callback
passed to ::WaitForPendingGpuMemoryBufferUsageToComplete was always deleted on
the correct thread if you make GpuMemoryBufferUsageCompleted/OnCallerThread
non-member functions and instead passed ownership of the callback between those
functions.

Using a map to ensure that "usage complete" callbacks are destroyed on the
caller thread only works if GpuChannelHost is guaranteed to be destroyed on the
caller thread. Doesn't look like that's necessarily the case here.

+                 id));
+}
+
+void GpuChannelHost::GpuMemoryBufferWaitCompletedOnCallerThread(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