Remove custom Task implementation from RenderWidgetHelper::UpdateMsgProxy.

content/browser/renderer_host/render_widget_helper.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/renderer_host/render_widget_helper.h"
 
 #include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/eintr_wrapper.h"
 #include "base/threading/thread.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/resource_dispatcher_host.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
-// A Task used with InvokeLater that we hold a pointer to in pending_paints_.
-// Instances are deleted by MessageLoop after it calls their Run method.
-class RenderWidgetHelper::UpdateMsgProxy : public Task {
+// A helper used with DidReceiveUpdateMsg that we hold a pointer to in
+// pending_paints_.
+class RenderWidgetHelper::UpdateMsgProxy {
  public:
-  UpdateMsgProxy(RenderWidgetHelper* h, const IPC::Message& m)
-      : helper(h),
-        message(m),
-        cancelled(false) {
-  }
+  UpdateMsgProxy(RenderWidgetHelper* h, const IPC::Message& m);
+  ~UpdateMsgProxy();
+  void Run();
+  void Cancel() { cancelled_ = true; }
 
-  ~UpdateMsgProxy() {
-    // If the paint message was never dispatched, then we need to let the
-    // helper know that we are going away.
-    if (!cancelled && helper)
-      helper->OnDiscardUpdateMsg(this);
-  }
+  const IPC::Message& message() const { return message_; }
 
-  virtual void Run() {
-    if (!cancelled) {
-      helper->OnDispatchUpdateMsg(this);
-      helper = NULL;
-    }
-  }
-
-  scoped_refptr<RenderWidgetHelper> helper;
-  IPC::Message message;
-  bool cancelled;  // If true, then the message will not be dispatched.
+ private:
+  scoped_refptr<RenderWidgetHelper> helper_;
+  IPC::Message message_;
+  bool cancelled_;  // If true, then the message will not be dispatched.
 
   DISALLOW_COPY_AND_ASSIGN(UpdateMsgProxy);
 };
 
+RenderWidgetHelper::UpdateMsgProxy::UpdateMsgProxy(
+    RenderWidgetHelper* h, const IPC::Message& m)
+    : helper_(h), message_(m), cancelled_(false) {

[brettw, 2011/12/10 00:01:55]

Initializers should go on separate lines

+}
+
+RenderWidgetHelper::UpdateMsgProxy::~UpdateMsgProxy() {
+  // If the paint message was never dispatched, then we need to let the
+  // helper know that we are going away.
+  if (!cancelled_ && helper_)
+    helper_->OnDiscardUpdateMsg(this);
+}
+
+void RenderWidgetHelper::UpdateMsgProxy::Run() {
+  if (!cancelled_) {
+    helper_->OnDispatchUpdateMsg(this);
+    helper_ = NULL;
+  }
+}
+
 RenderWidgetHelper::RenderWidgetHelper()
     : render_process_id_(-1),
 #if defined(OS_WIN)
       event_(CreateEvent(NULL, FALSE /* auto-reset */, FALSE, NULL)),
 #elif defined(OS_POSIX)
       event_(false /* auto-reset */, false),
 #endif
       resource_dispatcher_host_(NULL) {
 }
 
@@ skipping 47 matching lines @@
     UpdateMsgProxy* proxy = NULL;
     {
       base::AutoLock lock(pending_paints_lock_);
 
       UpdateMsgProxyMap::iterator it = pending_paints_.find(render_widget_id);
       if (it != pending_paints_.end()) {
         proxy = it->second;
 
         // Flag the proxy as cancelled so that when it is run as a task it will
         // do nothing.
-        proxy->cancelled = true;
+        proxy->Cancel();
 
         pending_paints_.erase(it);
       }
     }
 
     if (proxy) {
-      *msg = proxy->message;
+      *msg = proxy->message();
       DCHECK(msg->routing_id() == render_widget_id);
       return true;
     }
 
     // Calculate the maximum amount of time that we are willing to sleep.
     base::TimeDelta max_sleep_time =
         max_delay - (base::TimeTicks::Now() - time_start);
     if (max_sleep_time <= base::TimeDelta::FromMilliseconds(0))
       break;
 
@@ skipping 30 matching lines @@
     }
 
     result.first->second = (proxy = new UpdateMsgProxy(this, msg));
   }
 
   // Notify anyone waiting on the UI thread that there is a new entry in the
   // proxy map.  If they don't find the entry they are looking for, then they
   // will just continue waiting.
   event_.Signal();
 
-  // The proxy will be deleted when it is run as a task.
-  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, proxy);
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::Bind(&UpdateMsgProxy::Run, base::Owned(proxy)));
 }
 
 void RenderWidgetHelper::OnDiscardUpdateMsg(UpdateMsgProxy* proxy) {
-  const IPC::Message& msg = proxy->message;
+  const IPC::Message& msg = proxy->message();
 
   // Remove the proxy from the map now that we are going to handle it normally.
   {
     base::AutoLock lock(pending_paints_lock_);
 
     UpdateMsgProxyMap::iterator it = pending_paints_.find(msg.routing_id());
     DCHECK(it != pending_paints_.end());
     DCHECK(it->second == proxy);
 
     pending_paints_.erase(it);
   }
 }
 
 void RenderWidgetHelper::OnDispatchUpdateMsg(UpdateMsgProxy* proxy) {
   OnDiscardUpdateMsg(proxy);
 
   // It is reasonable for the host to no longer exist.
   content::RenderProcessHost* host =
       content::RenderProcessHost::FromID(render_process_id_);
   if (host)
-    host->OnMessageReceived(proxy->message);
+    host->OnMessageReceived(proxy->message());
 }
 
 void RenderWidgetHelper::OnCancelResourceRequests(
     int render_widget_id) {
   resource_dispatcher_host_->CancelRequestsForRoute(
       render_process_id_, render_widget_id);
 }
 
 void RenderWidgetHelper::OnCrossSiteSwapOutACK(
     const ViewMsg_SwapOut_Params& params) {
@@ skipping 139 matching lines @@
 gfx::PluginWindowHandle RenderWidgetHelper::LookupCompositingSurface(
     int render_widget_id) {
   base::AutoLock locked(view_compositing_surface_map_lock_);
   ViewCompositingSurfaceMap::iterator it =
       view_compositing_surface_map_.find(render_widget_id);
   if (it == view_compositing_surface_map_.end())
     return gfx::kNullPluginWindow;
 
   return it->second;
 }