base::Bind: Convert content/renderer.

content/renderer/render_widget.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/renderer/render_widget.h"
 
+#include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "content/common/swapped_out_messages.h"
 #include "content/common/view_messages.h"
@@ skipping 228 matching lines @@
 
   // Browser correspondence is no longer needed at this point.
   if (routing_id_ != MSG_ROUTING_NONE) {
     RenderThread::Get()->RemoveRoute(routing_id_);
     SetHidden(false);
   }
 
   // If there is a Send call on the stack, then it could be dangerous to close
   // now.  Post a task that only gets invoked when there are no nested message
   // loops.
-  MessageLoop::current()->PostNonNestableTask(FROM_HERE,
-      NewRunnableMethod(this, &RenderWidget::Close));
+  MessageLoop::current()->PostNonNestableTask(
+      FROM_HERE, NewRunnableMethod(this, &RenderWidget::Close));
 
   // Balances the AddRef taken when we called AddRoute.
   Release();
 }
 
 void RenderWidget::OnResize(const gfx::Size& new_size,
                             const gfx::Rect& resizer_rect,
                             bool is_fullscreen) {
   // During shutdown we can just ignore this message.
   if (!webwidget_)
@@ skipping 386 matching lines @@
   int animationInterval = IsRenderingVSynced() ? 16 : 0;
 
   base::Time now = base::Time::Now();
   if (now >= animation_floor_time_) {
     TRACE_EVENT0("renderer", "RenderWidget::AnimateIfNeeded")
     animation_floor_time_ = now +
         base::TimeDelta::FromMilliseconds(animationInterval);
     // Set a timer to call us back after animationInterval before
     // running animation callbacks so that if a callback requests another
     // we'll be sure to run it at the proper time.
-    MessageLoop::current()->PostDelayedTask(FROM_HERE, NewRunnableMethod(
-        this, &RenderWidget::AnimationCallback), animationInterval);
+    MessageLoop::current()->PostDelayedTask(
+        FROM_HERE, base::Bind(&RenderWidget::AnimationCallback, this),
+        animationInterval);
     animation_task_posted_ = true;
     animation_update_pending_ = false;
     webwidget_->animate(0.0);
     return;
   }
   TRACE_EVENT0("renderer", "EarlyOut_AnimatedTooRecently");
   if (animation_task_posted_)
     return;
   // This code uses base::Time::Now() to calculate the floor and next fire
   // time because javascript's Date object uses base::Time::Now().  The
   // message loop uses base::TimeTicks, which on windows can have a
   // different granularity than base::Time.
   // The upshot of all this is that this function might be called before
   // base::Time::Now() has advanced past the animation_floor_time_.  To
   // avoid exposing this delay to javascript, we keep posting delayed
   // tasks until base::Time::Now() has advanced far enough.
   int64 delay = (animation_floor_time_ - now).InMillisecondsRoundedUp();
   animation_task_posted_ = true;
-  MessageLoop::current()->PostDelayedTask(FROM_HERE,
-      NewRunnableMethod(this, &RenderWidget::AnimationCallback), delay);
+  MessageLoop::current()->PostDelayedTask(
+      FROM_HERE, base::Bind(&RenderWidget::AnimationCallback, this), delay);
 }
 
 bool RenderWidget::IsRenderingVSynced() {
   // TODO(nduca): Forcing a driver to disable vsync (e.g. in a control panel) is
   // not caught by this check. This will lead to artificially low frame rates
   // for people who force vsync off at a driver level and expect Chrome to speed
   // up.
   return !has_disable_gpu_vsync_switch_;
 }
 
@@ skipping 196 matching lines @@
   // a single update.
   if (is_accelerated_compositing_active_ && animation_task_posted_)
     return;
 
   // Perform updating asynchronously.  This serves two purposes:
   // 1) Ensures that we call WebView::Paint without a bunch of other junk
   //    on the call stack.
   // 2) Allows us to collect more damage rects before painting to help coalesce
   //    the work that we will need to do.
   invalidation_task_posted_ = true;
-  MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &RenderWidget::InvalidationCallback));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&RenderWidget::InvalidationCallback, this));
 }
 
 void RenderWidget::didScrollRect(int dx, int dy, const WebRect& clip_rect) {
   // Drop scrolls on the floor when we are in compositing mode.
   // TODO(nduca): stop WebViewImpl from sending scrolls in the first place.
   if (is_accelerated_compositing_active_)
     return;
 
   // The scrolled rect might be outside the bounds of the view.
   gfx::Rect view_rect(size_);
@@ skipping 16 matching lines @@
   // a single update.
   if (is_accelerated_compositing_active_ && animation_task_posted_)
     return;
 
   // Perform updating asynchronously.  This serves two purposes:
   // 1) Ensures that we call WebView::Paint without a bunch of other junk
   //    on the call stack.
   // 2) Allows us to collect more damage rects before painting to help coalesce
   //    the work that we will need to do.
   invalidation_task_posted_ = true;
-  MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &RenderWidget::InvalidationCallback));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&RenderWidget::InvalidationCallback, this));
 }
 
 void RenderWidget::didActivateCompositor(int compositor_identifier) {
   TRACE_EVENT0("gpu", "RenderWidget::didActivateCompositor");
 
   CompositorThread* compositor_thread =
       RenderThreadImpl::current()->compositor_thread();
   if (compositor_thread)
     compositor_thread->AddCompositor(routing_id_, compositor_identifier);
 
@@ skipping 30 matching lines @@
     didInvalidateRect(WebRect(0, 0, 1, 1));
   }
 }
 
 void RenderWidget::scheduleAnimation() {
   TRACE_EVENT0("gpu", "RenderWidget::scheduleAnimation");
   if (!animation_update_pending_) {
     animation_update_pending_ = true;
     if (!animation_task_posted_) {
       animation_task_posted_ = true;
-      MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
-          this, &RenderWidget::AnimationCallback));
+      MessageLoop::current()->PostTask(
+          FROM_HERE, base::Bind(&RenderWidget::AnimationCallback, this));
     }
   }
 }
 
 void RenderWidget::didChangeCursor(const WebCursorInfo& cursor_info) {
   // TODO(darin): Eliminate this temporary.
   WebCursor cursor(cursor_info);
 
   // Only send a SetCursor message if we need to make a change.
   if (!current_cursor_.IsEqual(cursor)) {
@@ skipping 37 matching lines @@
 
 void RenderWidget::closeWidgetSoon() {
   // If a page calls window.close() twice, we'll end up here twice, but that's
   // OK.  It is safe to send multiple Close messages.
 
   // Ask the RenderWidgetHost to initiate close.  We could be called from deep
   // in Javascript.  If we ask the RendwerWidgetHost to close now, the window
   // could be closed before the JS finishes executing.  So instead, post a
   // message back to the message loop, which won't run until the JS is
   // complete, and then the Close message can be sent.
-  MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &RenderWidget::DoDeferredClose));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&RenderWidget::DoDeferredClose, this));
 }
 
 void RenderWidget::Close() {
   if (webwidget_) {
     webwidget_->close();
     webwidget_ = NULL;
   }
 }
 
 WebRect RenderWidget::windowRect() {
@@ skipping 413 matching lines @@
   }
 }
 
 bool RenderWidget::WillHandleMouseEvent(const WebKit::WebMouseEvent& event) {
   return false;
 }
 
 bool RenderWidget::WebWidgetHandlesCompositorScheduling() const {
   return false;
 }