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(scoped_refptr<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>();
-}
-
-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);
+             handle,
+             gfx::Size(width, height),
+             internalformat,
+             base::Bind(&DeletedGpuMemoryBuffer,
+                        make_scoped_refptr(thread_safe_sender()),

[piman, 2014/09/24 03:19:10]

nit: you don't need make_scoped_refptr, Bind figures out whether to refcount or
not based on the presence of AddRef/Release, not on the fact that it's a refptr.
Similarly, you don't actually need a scoped_refptr in the callback.

[reveman, 2014/09/24 06:03:38]

hm, I think we do, unless I'm doing something completely wrong. Bind is using
the NeedsScopedRefptrButGetsRawPtr trait from
raw_scoped_refptr_mismatch_checker.h and the comment at the top of that file
seem to indicate that scoped_refptr needs to be used explicitly.

[piman, 2014/09/24 06:40:28]

Ah, sorry you're right. What I said is only true for the |this| parameter of a
method.

(you still don't need it on the DeletedGpuMemoryBuffer function, but either
way).

[reveman, 2014/09/24 07:10:54]

Are you saying I could safely use base::Unretained with the ThreadSafeSender
instance or I don't need it at all?

+                        handle.type,
+                        handle.global_id)).PassAs<gfx::GpuMemoryBuffer>();

[piman, 2014/09/24 03:19:10]

Should DeletedGpuMemoryBuffer be called if CreateFromHandle fails?

[reveman, 2014/09/24 06:03:38]

Good catch. Done.

 }
 
 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