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 64 matching lines @@
       NOTREACHED();
       return false;
     default:
       NOTREACHED();
       return false;
   }
 }
 
 }  // namespace
 
-CommandBufferProxyImpl::CommandBufferProxyImpl(
-    GpuChannelHost* channel,
-    int route_id)
+CommandBufferProxyImpl::CommandBufferProxyImpl(GpuChannelHost* channel,
+                                               int route_id)
     : channel_(channel),
       route_id_(route_id),
       flush_count_(0),
       last_put_offset_(-1),
-      next_signal_id_(0) {
+      next_signal_id_(0),
+      main_loop_proxy_(base::MessageLoopProxy::current()),
+      tracker_(new GpuMemoryBufferUsageTracker) {
 }
 
 CommandBufferProxyImpl::~CommandBufferProxyImpl() {
   FOR_EACH_OBSERVER(DeletionObserver,
                     deletion_observers_,
                     OnWillDeleteImpl());
 }
 
 bool CommandBufferProxyImpl::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
@@ skipping 149 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;
 }
 
+CommandBufferProxyImpl::CallbackMessageLoopPair::CallbackMessageLoopPair(
+    const base::Closure& callback,
+    scoped_refptr<base::MessageLoopProxy> message_loop)
+    : callback(callback), message_loop(message_loop) {
+}
+
+CommandBufferProxyImpl::CallbackMessageLoopPair::~CallbackMessageLoopPair() {
+}
+
+CommandBufferProxyImpl::GpuMemoryBufferUsageTracker::
+    GpuMemoryBufferUsageTracker()
+    : next_gpu_memory_buffer_usage_id_(0) {
+}
+
+void CommandBufferProxyImpl::GpuMemoryBufferUsageTracker::OnWillDeleteImpl() {
+  base::AutoLock lock(gpu_memory_buffer_task_lock_);
+  GpuMemoryBufferUsageCompletedMap::iterator it =
+      gpu_memory_buffer_tasks_.begin();
+  for (; it != gpu_memory_buffer_tasks_.end(); it++) {
+    it->second.message_loop->PostTask(
+        FROM_HERE,
+        base::Bind(&CommandBufferProxyImpl::GpuMemoryBufferUsageTracker::
+                       UsageCompletedOnCaller,
+                   this,
+                   it->first));
+  }
+}
+
+uint32 CommandBufferProxyImpl::GpuMemoryBufferUsageTracker::AddUsage(
+    const CallbackMessageLoopPair& task) {
+  base::AutoLock lock(gpu_memory_buffer_task_lock_);
+  uint32 usage_id = next_gpu_memory_buffer_usage_id_++;
+
+  gpu_memory_buffer_tasks_.insert(std::make_pair(usage_id, task));
+  return usage_id;
+}
+
+void CommandBufferProxyImpl::GpuMemoryBufferUsageTracker::UsageCompleted(
+    uint32 task_id) {
+  base::AutoLock lock(gpu_memory_buffer_task_lock_);
+  GpuMemoryBufferUsageCompletedMap::iterator it =
+      gpu_memory_buffer_tasks_.find(task_id);
+  DCHECK(it != gpu_memory_buffer_tasks_.end());
+  it->second.message_loop->PostTask(
+      FROM_HERE,
+      base::Bind(&CommandBufferProxyImpl::GpuMemoryBufferUsageTracker::
+                     UsageCompletedOnCaller,
+                 this,
+                 task_id));
+}
+
+CommandBufferProxyImpl::GpuMemoryBufferUsageTracker::
+    ~GpuMemoryBufferUsageTracker() {
+}
+
+void
+CommandBufferProxyImpl::GpuMemoryBufferUsageTracker::UsageCompletedOnCaller(
+    uint32 task_id) {
+  base::Closure callback;
+  {
+    base::AutoLock lock(gpu_memory_buffer_task_lock_);
+    GpuMemoryBufferUsageCompletedMap::iterator it =
+        gpu_memory_buffer_tasks_.find(task_id);
+    DCHECK(it != gpu_memory_buffer_tasks_.end());
+
+    callback = it->second.callback;
+    gpu_memory_buffer_tasks_.erase(it);
+  }
+  callback.Run();
+}
+
+void CommandBufferProxyImpl::WaitForPendingGpuMemoryBufferUsageToComplete(
+    const base::Closure& callback) {
+  uint32 usage_id = tracker_->AddUsage(
+      CallbackMessageLoopPair(callback, base::MessageLoopProxy::current()));
+
+  main_loop_proxy_->PostTask(
+      FROM_HERE,
+      base::Bind(&CommandBufferProxyImpl::
+                     WaitForPendingGpuMemoryBufferUsageToCompleteOnMain,
+                 base::Unretained(this),
+                 usage_id));
+}
+
+void CommandBufferProxyImpl::WaitForPendingGpuMemoryBufferUsageToCompleteOnMain(
+    uint32 usage_id) {
+  SignalSyncPoint(
+      InsertSyncPoint(),
+      base::Bind(
+          &CommandBufferProxyImpl::GpuMemoryBufferUsageTracker::UsageCompleted,
+          tracker_,
+          usage_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 310 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