base::Bind migrations in chrome/renderer

chrome/renderer/net/renderer_net_predictor.cc

 // Copyright (c) 2006-2010 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.
 
 // See header file for description of RendererNetPredictor class
 
 #include "chrome/renderer/net/renderer_net_predictor.h"
 
 #include <ctype.h>
 
+#include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "chrome/common/net/predictor_common.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/renderer/net/predictor_queue.h"
 #include "content/public/renderer/render_thread.h"
 
 using content::RenderThread;
 
 // The number of hostnames submitted to Browser DNS resolver per call to
 // SubmitHostsnames() (which reads names from our queue).
 static const size_t kMAX_SUBMISSION_PER_TASK = 30;
 
 RendererNetPredictor::RendererNetPredictor()
     : c_string_queue_(1000),
-      ALLOW_THIS_IN_INITIALIZER_LIST(renderer_predictor_factory_(this)) {
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   Reset();
 }
 
 RendererNetPredictor::~RendererNetPredictor() {
 }
 
 void RendererNetPredictor::Reset() {
   domain_map_.clear();
   c_string_queue_.Clear();
   buffer_full_discard_count_ = 0;
   numeric_ip_discard_count_ = 0;
   new_name_count_ = 0;
 }
 
 // Push names into queue quickly!
 void RendererNetPredictor::Resolve(const char* name, size_t length) {
   if (!length)
     return;  // Don't store empty strings in buffer.
   if (is_numeric_ip(name, length))
     return;  // Numeric IPs have no DNS lookup significance.
 
   size_t old_size =  c_string_queue_.Size();
   DnsQueue::PushResult result = c_string_queue_.Push(name, length);
   if (DnsQueue::SUCCESSFUL_PUSH == result) {
     if (1 == c_string_queue_.Size()) {
       DCHECK_EQ(old_size, 0u);
       if (0 != old_size)
         return;  // Overkill safety net: Don't send too many InvokeLater's.
-      renderer_predictor_factory_.RevokeAll();
-      RenderThread::Get()->GetMessageLoop()->PostDelayedTask(FROM_HERE,
-          renderer_predictor_factory_.NewRunnableMethod(
-              &RendererNetPredictor::SubmitHostnames), 10);
+      weak_factory_.InvalidateWeakPtrs();
+      RenderThread::Get()->GetMessageLoop()->PostDelayedTask(
+          FROM_HERE, base::Bind(&RendererNetPredictor::SubmitHostnames,
+                                weak_factory_.GetWeakPtr()),
+          10);
     }
     return;
   }
   if (DnsQueue::OVERFLOW_PUSH == result) {
     ++buffer_full_discard_count_;
     return;
   }
   DCHECK(DnsQueue::REDUNDANT_PUSH == result);
 }
 
@@ skipping 10 matching lines @@
   // longer than the page may be visible!?!?!  If we implement a better
   // mechanism for doing domain_map.clear() (see end of this method), then
   // we'd automatically flush such pending work from a ridiculously link-filled
   // page.
 
   // Don't overload the browser DNS lookup facility, or take too long here,
   // by only sending off kMAX_SUBMISSION_PER_TASK names to the Browser.
   // This will help to avoid overloads when a page has a TON of links.
   DnsPrefetchNames(kMAX_SUBMISSION_PER_TASK);
   if (new_name_count_ > 0 || 0 < c_string_queue_.Size()) {
-    renderer_predictor_factory_.RevokeAll();
-    RenderThread::Get()->GetMessageLoop()->PostDelayedTask(FROM_HERE,
-        renderer_predictor_factory_.NewRunnableMethod(
-            &RendererNetPredictor::SubmitHostnames), 10);
+    weak_factory_.InvalidateWeakPtrs();
+    RenderThread::Get()->GetMessageLoop()->PostDelayedTask(
+        FROM_HERE, base::Bind(&RendererNetPredictor::SubmitHostnames,
+                              weak_factory_.GetWeakPtr()),
+        10);
   } else {
     // TODO(JAR): Should we only clear the map when we navigate, or reload?
     domain_map_.clear();
   }
 }
 
 // Pull some hostnames from the queue, and add them to our map.
 void RendererNetPredictor::ExtractBufferedNames(size_t size_goal) {
   size_t count(0);  // Number of entries to find (0 means find all).
   if (size_goal > 0) {
@@ skipping 48 matching lines @@
 // address.
 bool RendererNetPredictor::is_numeric_ip(const char* name, size_t length) {
   // Scan for a character outside our lookup list.
   while (length-- > 0) {
     if (!isdigit(*name) && '.' != *name)
       return false;
     ++name;
   }
   return true;
 }