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

content/browser/gpu/gpu_process_host_ui_shim.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_ui_shim.h"
 
 #include <algorithm>
 
+#include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/id_map.h"
 #include "base/lazy_instance.h"
 #include "base/process_util.h"
 #include "content/browser/gpu/gpu_data_manager.h"
 #include "content/browser/gpu/gpu_process_host.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/renderer_host/render_widget_host_view.h"
 #include "content/common/gpu/gpu_messages.h"
@@ skipping 12 matching lines @@
 namespace {
 
 // One of the linux specific headers defines this as a macro.
 #ifdef DestroyAll
 #undef DestroyAll
 #endif
 
 base::LazyInstance<IDMap<GpuProcessHostUIShim> > g_hosts_by_id =
     LAZY_INSTANCE_INITIALIZER;
 
-class SendOnIOThreadTask : public Task {
- public:
-  SendOnIOThreadTask(int host_id, IPC::Message* msg)
-      : host_id_(host_id),
-        msg_(msg) {
-  }
-
- private:
-  void Run() {
-    GpuProcessHost* host = GpuProcessHost::FromID(host_id_);
-    if (host)
-      host->Send(msg_.release());
-  }
-
-  int host_id_;
-  scoped_ptr<IPC::Message> msg_;
-};
+void SendOnIOThreadTask(int host_id, IPC::Message* msg) {
+  GpuProcessHost* host = GpuProcessHost::FromID(host_id);
+  if (host)
+    host->Send(msg);
+  else
+    delete msg;
+}
 
 class ScopedSendOnIOThread {
  public:
   ScopedSendOnIOThread(int host_id, IPC::Message* msg)
       : host_id_(host_id),
         msg_(msg),
         cancelled_(false) {
   }
 
   ~ScopedSendOnIOThread() {
     if (!cancelled_) {
       BrowserThread::PostTask(BrowserThread::IO,
                               FROM_HERE,
-                              new SendOnIOThreadTask(host_id_,
-                                                     msg_.release()));
+                              base::Bind(&SendOnIOThreadTask,
+                                         host_id_,
+                                         msg_.release()));
     }
   }
 
   void Cancel() { cancelled_ = true; }
 
  private:
   int host_id_;
   scoped_ptr<IPC::Message> msg_;
   bool cancelled_;
 };
 
 RenderWidgetHostView* GetRenderWidgetHostViewFromID(int render_process_id,
                                                     int render_widget_id) {
   content::RenderProcessHost* process =
       content::RenderProcessHost::FromID(render_process_id);
   if (!process)
     return NULL;
 
   RenderWidgetHost* host = static_cast<RenderWidgetHost*>(
       process->GetListenerByID(render_widget_id));
   return host ? host->view() : NULL;
 }
 
 }  // namespace
 
-RouteToGpuProcessHostUIShimTask::RouteToGpuProcessHostUIShimTask(
-    int host_id,
-    const IPC::Message& msg)
-  : host_id_(host_id),
-    msg_(msg) {
-}
-
-RouteToGpuProcessHostUIShimTask::~RouteToGpuProcessHostUIShimTask() {
-}
-
-void RouteToGpuProcessHostUIShimTask::Run() {
-  GpuProcessHostUIShim* ui_shim = GpuProcessHostUIShim::FromID(host_id_);
+void RouteToGpuProcessHostUIShimTask(int host_id, const IPC::Message& msg) {
+  GpuProcessHostUIShim* ui_shim = GpuProcessHostUIShim::FromID(host_id);
   if (ui_shim)
-    ui_shim->OnMessageReceived(msg_);
+    ui_shim->OnMessageReceived(msg);
 }
 
 GpuProcessHostUIShim::GpuProcessHostUIShim(int host_id)
     : host_id_(host_id) {
   g_hosts_by_id.Pointer()->AddWithID(this, host_id_);
 }
 
 // static
 GpuProcessHostUIShim* GpuProcessHostUIShim::Create(int host_id) {
   DCHECK(!FromID(host_id));
@@ skipping 27 matching lines @@
   if (g_hosts_by_id.Pointer()->IsEmpty())
     return NULL;
   IDMap<GpuProcessHostUIShim>::iterator it(g_hosts_by_id.Pointer());
   return it.GetCurrentValue();
 }
 
 bool GpuProcessHostUIShim::Send(IPC::Message* msg) {
   DCHECK(CalledOnValidThread());
   return BrowserThread::PostTask(BrowserThread::IO,
                                  FROM_HERE,
-                                 new SendOnIOThreadTask(host_id_, msg));
+                                 base::Bind(&SendOnIOThreadTask,
+                                            host_id_,
+                                            msg));
 }
 
 bool GpuProcessHostUIShim::OnMessageReceived(const IPC::Message& message) {
   DCHECK(CalledOnValidThread());
 
   if (message.routing_id() != MSG_ROUTING_CONTROL)
     return false;
 
   return OnControlMessageReceived(message);
 }
@@ skipping 207 matching lines @@
 void GpuProcessHostUIShim::OnAcceleratedSurfaceRelease(
     const GpuHostMsg_AcceleratedSurfaceRelease_Params& params) {
   RenderWidgetHostView* view = GetRenderWidgetHostViewFromID(
       params.renderer_id, params.render_view_id);
   if (!view)
     return;
   view->AcceleratedSurfaceRelease(params.identifier);
 }
 
 #endif