Remove custom Task implementations and re-exorcise old callbacks from gpu.

content/browser/gpu/gpu_process_host.cc

 // Copyright (c) 2011 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/browser/gpu/gpu_process_host.h"
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/base_switches.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/lazy_instance.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram.h"
 #include "base/process_util.h"
 #include "base/string_piece.h"
 #include "base/threading/thread.h"
 #include "content/browser/gpu/gpu_data_manager.h"
@@ skipping 41 matching lines @@
 static int g_gpu_crash_count = 0;
 
 // Maximum number of times the gpu process is allowed to crash in a session.
 // Once this limit is reached, any request to launch the gpu process will fail.
 static const int kGpuMaxCrashCount = 3;
 
 int g_last_host_id = 0;
 
 #if defined(TOOLKIT_USES_GTK)
 
-class ReleasePermanentXIDDispatcher: public Task {
- public:
-  explicit ReleasePermanentXIDDispatcher(gfx::PluginWindowHandle surface);
-  void Run();
- private:
-  gfx::PluginWindowHandle surface_;
-};
-
-ReleasePermanentXIDDispatcher::ReleasePermanentXIDDispatcher(
-  gfx::PluginWindowHandle surface)
-      : surface_(surface) {
-}
-
-void ReleasePermanentXIDDispatcher::Run() {
+void ReleasePermanentXIDDispatcher(gfx::PluginWindowHandle surface) {
   GtkNativeViewManager* manager = GtkNativeViewManager::GetInstance();
-  manager->ReleasePermanentXID(surface_);
+  manager->ReleasePermanentXID(surface);
 }
 
 #endif
 
 void SendGpuProcessMessage(int renderer_id,
                            content::CauseForGpuLaunch cause,
                            IPC::Message* message) {
   GpuProcessHost* host = GpuProcessHost::GetForRenderer(
       renderer_id, cause);
   if (host) {
@@ skipping 21 matching lines @@
     : surface_(surface) {
   GtkNativeViewManager* manager = GtkNativeViewManager::GetInstance();
   if (!manager->AddRefPermanentXID(surface_)) {
     LOG(ERROR) << "Surface " << surface << " cannot be referenced.";
   }
 }
 
 GpuProcessHost::SurfaceRef::~SurfaceRef() {
   BrowserThread::PostTask(BrowserThread::UI,
                           FROM_HERE,
-                          new ReleasePermanentXIDDispatcher(surface_));
+                          base::Bind(&ReleasePermanentXIDDispatcher, surface_));
 }
 #endif  // defined(TOOLKIT_USES_GTK)
 
 // This class creates a GPU thread (instead of a GPU process), when running
 // with --in-process-gpu or --single-process.
 class GpuMainThread : public base::Thread {
  public:
   explicit GpuMainThread(const std::string& channel_id)
       : base::Thread("Chrome_InProcGpuThread"),
         channel_id_(channel_id),
@@ skipping 90 matching lines @@
   delete host;
   return NULL;
 }
 
 // static
 void GpuProcessHost::SendOnIO(int renderer_id,
                               content::CauseForGpuLaunch cause,
                               IPC::Message* message) {
   BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
-        NewRunnableFunction(
+        base::Bind(
             &SendGpuProcessMessage, renderer_id, cause, message));
 }
 
 // static
 GpuProcessHost* GpuProcessHost::FromID(int host_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (host_id == 0)
     return NULL;
 
@@ skipping 21 matching lines @@
   g_hosts_by_id.Pointer()->AddWithID(this, host_id_);
 
   // Post a task to create the corresponding GpuProcessHostUIShim.  The
   // GpuProcessHostUIShim will be destroyed if either the browser exits,
   // in which case it calls GpuProcessHostUIShim::DestroyAll, or the
   // GpuProcessHost is destroyed, which happens when the corresponding GPU
   // process terminates or fails to launch.
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
-      NewRunnableFunction(&GpuProcessHostUIShim::Create, host_id));
+      base::Bind(base::IgnoreResult(&GpuProcessHostUIShim::Create), host_id));
 }
 
 GpuProcessHost::~GpuProcessHost() {
   DCHECK(CalledOnValidThread());
 
   SendOutstandingReplies();
   UMA_HISTOGRAM_ENUMERATION("GPU.GPUProcessLifetimeEvents",
                             DIED_FIRST_TIME + g_gpu_crash_count,
                             GPU_PROCESS_LIFETIME_EVENT_MAX);
 
@@ skipping 18 matching lines @@
   // In case we never started, clean up.
   while (!queued_messages_.empty()) {
     delete queued_messages_.front();
     queued_messages_.pop();
   }
 
   g_hosts_by_id.Pointer()->Remove(host_id_);
 
   BrowserThread::PostTask(BrowserThread::UI,
                           FROM_HERE,
-                          NewRunnableFunction(GpuProcessHostUIShim::Destroy,
-                                              host_id_));
+                          base::Bind(&GpuProcessHostUIShim::Destroy, host_id_));
 }
 
 bool GpuProcessHost::Init() {
   std::string channel_id = child_process_host()->CreateChannel();
   if (channel_id.empty())
     return false;
 
   if (in_process_) {
     CommandLine::ForCurrentProcess()->AppendSwitch(
         switches::kDisableGpuWatchdog);
@@ skipping 17 matching lines @@
   } else if (!LaunchGpuProcess(channel_id))
     return false;
 
   return Send(new GpuMsg_Initialize());
 }
 
 void GpuProcessHost::RouteOnUIThread(const IPC::Message& message) {
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
-      new RouteToGpuProcessHostUIShimTask(host_id_, message));
+      base::Bind(&RouteToGpuProcessHostUIShimTask, host_id_, message));
 }
 
 bool GpuProcessHost::Send(IPC::Message* msg) {
   DCHECK(CalledOnValidThread());
   if (child_process_host()->IsChannelOpening()) {
     queued_messages_.push(msg);
     return true;
   }
 
   return BrowserChildProcessHost::Send(msg);
@@ skipping 16 matching lines @@
 void GpuProcessHost::OnChannelConnected(int32 peer_pid) {
   BrowserChildProcessHost::OnChannelConnected(peer_pid);
   while (!queued_messages_.empty()) {
     Send(queued_messages_.front());
     queued_messages_.pop();
   }
 }
 
 void GpuProcessHost::EstablishGpuChannel(
     int renderer_id,
-    EstablishChannelCallback *callback) {
+    const EstablishChannelCallback& callback) {
   DCHECK(CalledOnValidThread());
   TRACE_EVENT0("gpu", "GpuProcessHostUIShim::EstablishGpuChannel");
-  linked_ptr<EstablishChannelCallback> wrapped_callback(callback);
 
   // If GPU features are already blacklisted, no need to establish the channel.
   if (!GpuDataManager::GetInstance()->GpuAccessAllowed()) {
     EstablishChannelError(
-        wrapped_callback.release(), IPC::ChannelHandle(),
+        callback, IPC::ChannelHandle(),
         base::kNullProcessHandle, content::GPUInfo());
     return;
   }
 
   if (Send(new GpuMsg_EstablishChannel(renderer_id))) {
-    channel_requests_.push(wrapped_callback);
+    channel_requests_.push(callback);
   } else {
     EstablishChannelError(
-        wrapped_callback.release(), IPC::ChannelHandle(),
+        callback, IPC::ChannelHandle(),
         base::kNullProcessHandle, content::GPUInfo());
   }
 }
 
 void GpuProcessHost::CreateViewCommandBuffer(
     gfx::PluginWindowHandle compositing_surface,
     int32 render_view_id,
     int32 renderer_id,
     const GPUCreateCommandBufferConfig& init_params,
-    CreateCommandBufferCallback* callback) {
+    const CreateCommandBufferCallback& callback) {
   DCHECK(CalledOnValidThread());
-  linked_ptr<CreateCommandBufferCallback> wrapped_callback(callback);
 
 #if defined(TOOLKIT_USES_GTK)
   ViewID view_id(renderer_id, render_view_id);
 
   // There should only be one such command buffer (for the compositor).  In
   // practice, if the GPU process lost a context, GraphicsContext3D with
   // associated command buffer and view surface will not be gone until new
   // one is in place and all layers are reattached.
   linked_ptr<SurfaceRef> surface_ref;
   SurfaceRefMap::iterator it = surface_refs_.find(view_id);
   if (it != surface_refs_.end())
     surface_ref = (*it).second;
   else
     surface_ref.reset(new SurfaceRef(compositing_surface));
 #endif  // defined(TOOLKIT_USES_GTK)
 
   if (compositing_surface != gfx::kNullPluginWindow &&
       Send(new GpuMsg_CreateViewCommandBuffer(
           compositing_surface, render_view_id, renderer_id, init_params))) {
-    create_command_buffer_requests_.push(wrapped_callback);
+    create_command_buffer_requests_.push(callback);
 #if defined(TOOLKIT_USES_GTK)
     surface_refs_.insert(std::pair<ViewID, linked_ptr<SurfaceRef> >(
         view_id, surface_ref));
 #endif
   } else {
-    CreateCommandBufferError(wrapped_callback.release(), MSG_ROUTING_NONE);
+    CreateCommandBufferError(callback, MSG_ROUTING_NONE);
   }
 }
 
 void GpuProcessHost::OnChannelEstablished(
     const IPC::ChannelHandle& channel_handle) {
   // The GPU process should have launched at this point and this object should
   // have been notified of its process handle.
   DCHECK(gpu_process_);
 
-  linked_ptr<EstablishChannelCallback> callback = channel_requests_.front();
+  EstablishChannelCallback callback = channel_requests_.front();
   channel_requests_.pop();
 
   // Currently if any of the GPU features are blacklisted, we don't establish a
   // GPU channel.
   if (!channel_handle.name.empty() &&
       !GpuDataManager::GetInstance()->GpuAccessAllowed()) {
     Send(new GpuMsg_CloseChannel(channel_handle));
-    EstablishChannelError(callback.release(),
+    EstablishChannelError(callback,
                           IPC::ChannelHandle(),
                           base::kNullProcessHandle,
                           content::GPUInfo());
     RouteOnUIThread(GpuHostMsg_OnLogMessage(
         logging::LOG_WARNING,
         "WARNING",
         "Hardware acceleration is unavailable."));
     return;
   }
 
-  callback->Run(
+  callback.Run(
       channel_handle, gpu_process_, GpuDataManager::GetInstance()->gpu_info());
 }
 
 void GpuProcessHost::OnCommandBufferCreated(const int32 route_id) {
   if (!create_command_buffer_requests_.empty()) {
-    linked_ptr<CreateCommandBufferCallback> callback =
+    CreateCommandBufferCallback callback =
         create_command_buffer_requests_.front();
     create_command_buffer_requests_.pop();
     if (route_id == MSG_ROUTING_NONE)
-      CreateCommandBufferError(callback.release(), route_id);
+      CreateCommandBufferError(callback, route_id);
     else
-      callback->Run(route_id);
+      callback.Run(route_id);
   }
 }
 
 void GpuProcessHost::OnDestroyCommandBuffer(
     gfx::PluginWindowHandle window, int32 renderer_id,
     int32 render_view_id) {
 #if defined(TOOLKIT_USES_GTK)
   ViewID view_id(renderer_id, render_view_id);
   SurfaceRefMap::iterator it = surface_refs_.find(view_id);
   if (it != surface_refs_.end())
@@ skipping 123 matching lines @@
       cmd_line);
 
   UMA_HISTOGRAM_ENUMERATION("GPU.GPUProcessLifetimeEvents",
                             LAUNCHED, GPU_PROCESS_LIFETIME_EVENT_MAX);
   return true;
 }
 
 void GpuProcessHost::SendOutstandingReplies() {
   // First send empty channel handles for all EstablishChannel requests.
   while (!channel_requests_.empty()) {
-    linked_ptr<EstablishChannelCallback> callback = channel_requests_.front();
+    EstablishChannelCallback callback = channel_requests_.front();
     channel_requests_.pop();
-    EstablishChannelError(callback.release(),
+    EstablishChannelError(callback,
                           IPC::ChannelHandle(),
                           base::kNullProcessHandle,
                           content::GPUInfo());
   }
 }
 
 void GpuProcessHost::EstablishChannelError(
-    EstablishChannelCallback* callback,
+    const EstablishChannelCallback& callback,
     const IPC::ChannelHandle& channel_handle,
     base::ProcessHandle renderer_process_for_gpu,
     const content::GPUInfo& gpu_info) {
-  scoped_ptr<EstablishChannelCallback> wrapped_callback(callback);
-  wrapped_callback->Run(channel_handle, renderer_process_for_gpu, gpu_info);
+  callback.Run(channel_handle, renderer_process_for_gpu, gpu_info);
 }
 
 void GpuProcessHost::CreateCommandBufferError(
-    CreateCommandBufferCallback* callback, int32 route_id) {
-  scoped_ptr<GpuProcessHost::CreateCommandBufferCallback>
-    wrapped_callback(callback);
-  callback->Run(route_id);
+    const CreateCommandBufferCallback& callback, int32 route_id) {
+  callback.Run(route_id);
 }