content: Cleanup GpuMemoryBufferImpl destruction.

content/renderer/render_thread_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/renderer/render_thread_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <vector>
@@ skipping 300 matching lines @@
 blink::WebGraphicsContext3D::Attributes GetOffscreenAttribs() {
   blink::WebGraphicsContext3D::Attributes attributes;
   attributes.shareResources = true;
   attributes.depth = false;
   attributes.stencil = false;
   attributes.antialias = false;
   attributes.noAutomaticFlushes = true;
   return attributes;
 }
 
+void DeletedGpuMemoryBuffer(ThreadSafeSender* sender,
+                            gfx::GpuMemoryBufferType type,
+                            const gfx::GpuMemoryBufferId& id) {
+  TRACE_EVENT0("renderer", "RenderThreadImpl::DeletedGpuMemoryBuffer");
+  sender->Send(new ChildProcessHostMsg_DeletedGpuMemoryBuffer(type, id));
+}
+
 }  // namespace
 
 // For measuring memory usage after each task. Behind a command line flag.
 class MemoryObserver : public base::MessageLoop::TaskObserver {
  public:
   MemoryObserver() {}
   virtual ~MemoryObserver() {}
 
   virtual void WillProcessTask(const base::PendingTask& pending_task) OVERRIDE {
   }
@@ skipping 939 matching lines @@
   thread_safe_sender()->Send(message);
 
   return result;
 }
 
 scoped_ptr<gfx::GpuMemoryBuffer> RenderThreadImpl::AllocateGpuMemoryBuffer(
     size_t width,
     size_t height,
     unsigned internalformat,
     unsigned usage) {
+  TRACE_EVENT0("renderer", "RenderThreadImpl::AllocateGpuMemoryBuffer");
+
   DCHECK(allocate_gpu_memory_buffer_thread_checker_.CalledOnValidThread());
 
   if (!GpuMemoryBufferImpl::IsFormatValid(internalformat))
     return scoped_ptr<gfx::GpuMemoryBuffer>();
 
   gfx::GpuMemoryBufferHandle handle;
   bool success;
   IPC::Message* message = new ChildProcessHostMsg_SyncAllocateGpuMemoryBuffer(
       width, height, internalformat, usage, &handle);
 
   // Allow calling this from the compositor thread.
   if (base::MessageLoop::current() == message_loop())
     success = ChildThread::Send(message);
   else
     success = sync_message_filter()->Send(message);
 
   if (!success)
     return scoped_ptr<gfx::GpuMemoryBuffer>();
 
-  return GpuMemoryBufferImpl::CreateFromHandle(
-             handle, gfx::Size(width, height), internalformat)
-      .PassAs<gfx::GpuMemoryBuffer>();
-}
+  scoped_ptr<GpuMemoryBufferImpl> buffer(GpuMemoryBufferImpl::CreateFromHandle(
+      handle,
+      gfx::Size(width, height),
+      internalformat,
+      base::Bind(&DeletedGpuMemoryBuffer,
+                 make_scoped_refptr(thread_safe_sender()),
+                 handle.type,
+                 handle.global_id)));
+  if (!buffer) {
+    thread_safe_sender()->Send(new ChildProcessHostMsg_DeletedGpuMemoryBuffer(
+        handle.type, handle.global_id));
+    return scoped_ptr<gfx::GpuMemoryBuffer>();
+  }
 
-void RenderThreadImpl::DeleteGpuMemoryBuffer(
-    scoped_ptr<gfx::GpuMemoryBuffer> buffer) {
-  gfx::GpuMemoryBufferHandle handle(buffer->GetHandle());
-
-  IPC::Message* message = new ChildProcessHostMsg_DeletedGpuMemoryBuffer(
-      handle.type, handle.global_id);
-
-  // Allow calling this from the compositor thread.
-  thread_safe_sender()->Send(message);
+  return buffer.PassAs<gfx::GpuMemoryBuffer>();
 }
 
 void RenderThreadImpl::DoNotSuspendWebKitSharedTimer() {
   suspend_webkit_shared_timer_ = false;
 }
 
 void RenderThreadImpl::DoNotNotifyWebKitOfModalLoop() {
   notify_webkit_of_modal_loop_ = false;
 }
 
@@ skipping 329 matching lines @@
   hidden_widget_count_--;
 
   if (!GetContentClient()->renderer()->RunIdleHandlerWhenWidgetsHidden()) {
     return;
   }
 
   ScheduleIdleHandler(kLongIdleHandlerDelayMs);
 }
 
 }  // namespace content