Cleanup GpuMemoryBuffer

content/common/gpu/client/command_buffer_proxy_impl.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/command_buffer_proxy_impl.h"
 
 #include "base/callback.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/shared_memory.h"
@@ skipping 151 matching lines @@
   deletion_observers_.RemoveObserver(observer);
 }
 
 void CommandBufferProxyImpl::OnSetMemoryAllocation(
     const gpu::MemoryAllocation& allocation) {
   if (!memory_allocation_changed_callback_.is_null())
     memory_allocation_changed_callback_.Run(allocation);
 }
 
 void CommandBufferProxyImpl::OnSignalSyncPointAck(uint32 id) {
-  SignalTaskMap::iterator it = signal_tasks_.find(id);
-  DCHECK(it != signal_tasks_.end());
-  base::Closure callback = it->second;
-  signal_tasks_.erase(it);
+  base::Closure callback;
+  {
+    base::AutoLock lock(signal_lock_);

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

Alternatively, we can make sure to only access signal_tasks_ on the thread that
is set up to process messages for this command buffer. Looks like using
MessageLoopProxy::current() at the time the ctor is called would yield the
correct result.

We should probably avoid adding a lock where a lock is currently not needed.

+    SignalTaskMap::iterator it = signal_tasks_.find(id);
+    DCHECK(it != signal_tasks_.end());
+    callback = it->second;
+    signal_tasks_.erase(it);
+  }
   callback.Run();
 }
 
 void CommandBufferProxyImpl::SetChannelErrorCallback(
     const base::Closure& callback) {
   channel_error_callback_ = callback;
 }
 
 bool CommandBufferProxyImpl::Initialize() {
   TRACE_EVENT0("gpu", "CommandBufferProxyImpl::Initialize");
@@ skipping 66 matching lines @@
     const std::vector<ui::LatencyInfo>& latency_info) {
   for (size_t i = 0; i < latency_info.size(); i++)
     latency_info_.push_back(latency_info[i]);
 }
 
 void CommandBufferProxyImpl::SetSwapBuffersCompletionCallback(
     const SwapBuffersCompletionCallback& callback) {
   swap_buffers_completion_callback_ = callback;
 }
 
+void CommandBufferProxyImpl::WaitForPendingGpuMemoryBufferUsageToComplete(
+    const base::Closure& callback) {
+  uint32 sync_point = InsertSyncPoint();
+  SignalSyncPoint(
+      sync_point,
+      base::Bind(&CommandBufferProxyImpl::GpuMemoryBufferSyncPointSignalled,
+                 base::Unretained(this),
+                 sync_point));
+
+  base::AutoLock lock(gpu_memory_buffer_task_lock_);
+  gpu_memory_buffer_tasks_.insert(std::make_pair(sync_point, callback));

[alexst (slow to review), 2014/10/22 20:05:01]

Forgot to add, these are to be called in the destructor. if the proxy goes away.

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

Will the dtor be called on the same thread that called this function?

+}
+
+void CommandBufferProxyImpl::GpuMemoryBufferSyncPointSignalled(
+    uint32 sync_point) {
+  base::Closure callback;
+  {
+    base::AutoLock lock(gpu_memory_buffer_task_lock_);
+    SignalTaskMap::iterator it = gpu_memory_buffer_tasks_.find(sync_point);
+    DCHECK(it != gpu_memory_buffer_tasks_.end());
+    callback = it->second;
+    signal_tasks_.erase(it);
+  }
+  callback.Run();
+}
+
+uint32 CommandBufferProxyImpl::GetNextSignalId() {
+  base::AutoLock lock(signal_lock_);
+  return next_signal_id_++;
+}
+
 void CommandBufferProxyImpl::WaitForTokenInRange(int32 start, int32 end) {
   TRACE_EVENT2("gpu",
                "CommandBufferProxyImpl::WaitForToken",
                "start",
                start,
                "end",
                end);
   TryUpdateState();
   if (!InRange(start, end, last_state_.token) &&
       last_state_.error == gpu::error::kNoError) {
@@ skipping 184 matching lines @@
     return;
 
   Send(new GpuCommandBufferMsg_RetireSyncPoint(route_id_, sync_point));
 }
 
 void CommandBufferProxyImpl::SignalSyncPoint(uint32 sync_point,
                                              const base::Closure& callback) {
   if (last_state_.error != gpu::error::kNoError)
     return;
 
-  uint32 signal_id = next_signal_id_++;
+  uint32 signal_id = GetNextSignalId();
   if (!Send(new GpuCommandBufferMsg_SignalSyncPoint(route_id_,
                                                     sync_point,
                                                     signal_id))) {
     return;
   }
 
+  base::AutoLock lock(signal_lock_);
   signal_tasks_.insert(std::make_pair(signal_id, callback));
 }
 
 void CommandBufferProxyImpl::SignalQuery(uint32 query,
                                          const base::Closure& callback) {
   if (last_state_.error != gpu::error::kNoError)
     return;
 
   // Signal identifiers are hidden, so nobody outside of this class will see
   // them. (And thus, they cannot save them.) The IDs themselves only last
   // until the callback is invoked, which will happen as soon as the GPU
   // catches upwith the command buffer.
   // A malicious caller trying to create a collision by making next_signal_id
   // would have to make calls at an astounding rate (300B/s) and even if they
   // could do that, all they would do is to prevent some callbacks from getting
   // called, leading to stalled threads and/or memory leaks.
-  uint32 signal_id = next_signal_id_++;
+  uint32 signal_id = GetNextSignalId();
   if (!Send(new GpuCommandBufferMsg_SignalQuery(route_id_,
                                                 query,
                                                 signal_id))) {
     return;
   }
 
+  base::AutoLock lock(signal_lock_);
   signal_tasks_.insert(std::make_pair(signal_id, callback));
 }
 
 void CommandBufferProxyImpl::SetSurfaceVisible(bool visible) {
   if (last_state_.error != gpu::error::kNoError)
     return;
 
   Send(new GpuCommandBufferMsg_SetSurfaceVisible(route_id_, visible));
 }
 
@@ skipping 76 matching lines @@
     if (!ui::LatencyInfo::Verify(
             latency_info, "CommandBufferProxyImpl::OnSwapBuffersCompleted")) {
       swap_buffers_completion_callback_.Run(std::vector<ui::LatencyInfo>());
       return;
     }
     swap_buffers_completion_callback_.Run(latency_info);
   }
 }
 
 }  // namespace content