Convert to base::Callback in safe_browsing client-side-detection code.

chrome/renderer/safe_browsing/phishing_classifier.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 "chrome/renderer/safe_browsing/phishing_classifier.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 59 matching lines @@
     url_extractor_.reset();
     dom_extractor_.reset();
     term_extractor_.reset();
   }
 }
 
 bool PhishingClassifier::is_ready() const {
   return scorer_ != NULL;
 }
 
-void PhishingClassifier::BeginClassification(const string16* page_text,
-                                             DoneCallback* done_callback) {
+void PhishingClassifier::BeginClassification(
+    const string16* page_text,
+    const DoneCallback& done_callback) {
   DCHECK(is_ready());
 
   // The RenderView should have called CancelPendingClassification() before
   // starting a new classification, so DCHECK this.
   CheckNoPendingClassification();
   // However, in an opt build, we will go ahead and clean up the pending
   // classification so that we can start in a known state.
   CancelPendingClassification();
 
   page_text_ = page_text;
-  done_callback_.reset(done_callback);
+  done_callback_ = done_callback;
 
   // For consistency, we always want to invoke the DoneCallback
   // asynchronously, rather than directly from this method.  To ensure that
   // this is the case, post a task to begin feature extraction on the next
   // iteration of the message loop.
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&PhishingClassifier::BeginFeatureExtraction,
                  weak_factory_.GetWeakPtr()));
 }
@@ skipping 28 matching lines @@
   features_.reset(new FeatureMap);
   if (!url_extractor_->ExtractFeatures(url, features_.get())) {
     RunFailureCallback();
     return;
   }
 
   // DOM feature extraction can take awhile, so it runs asynchronously
   // in several chunks of work and invokes the callback when finished.
   dom_extractor_->ExtractFeatures(
       features_.get(),
-      NewCallback(this, &PhishingClassifier::DOMExtractionFinished));
+      base::Bind(&PhishingClassifier::DOMExtractionFinished,
+                 base::Unretained(this)));
 }
 
 void PhishingClassifier::CancelPendingClassification() {
   // Note that cancelling the feature extractors is simply a no-op if they
   // were not running.
   DCHECK(is_ready());
   dom_extractor_->CancelPendingExtraction();
   term_extractor_->CancelPendingExtraction();
   weak_factory_.InvalidateWeakPtrs();
   Clear();
 }
 
 void PhishingClassifier::DOMExtractionFinished(bool success) {
   if (success) {
     // Term feature extraction can take awhile, so it runs asynchronously
     // in several chunks of work and invokes the callback when finished.
     term_extractor_->ExtractFeatures(
         page_text_,
         features_.get(),
-        NewCallback(this, &PhishingClassifier::TermExtractionFinished));
+        base::Bind(&PhishingClassifier::TermExtractionFinished,
+                   base::Unretained(this)));
   } else {
     RunFailureCallback();
   }
 }
 
 void PhishingClassifier::TermExtractionFinished(bool success) {
   if (success) {
     WebKit::WebView* web_view = render_view_->GetWebView();
     if (!web_view) {
       RunFailureCallback();
@@ skipping 25 matching lines @@
     float score = static_cast<float>(scorer_->ComputeScore(hashed_features));
     verdict.set_client_score(score);
     verdict.set_is_phishing(score >= kPhishyThreshold);
     RunCallback(verdict);
   } else {
     RunFailureCallback();
   }
 }
 
 void PhishingClassifier::CheckNoPendingClassification() {
-  DCHECK(!done_callback_.get());
+  DCHECK(done_callback_.is_null());
   DCHECK(!page_text_);
-  if (done_callback_.get() || page_text_) {
+  if (done_callback_.is_null() || page_text_) {
     LOG(ERROR) << "Classification in progress, missing call to "
                << "CancelPendingClassification";
     UMA_HISTOGRAM_COUNTS("SBClientPhishing.CheckNoPendingClassificationFailed",
                          1);
   }
 }
 
 void PhishingClassifier::RunCallback(const ClientPhishingRequest& verdict) {
-  done_callback_->Run(verdict);
+  done_callback_.Run(verdict);
   Clear();
 }
 
 void PhishingClassifier::RunFailureCallback() {
   ClientPhishingRequest verdict;
   // In this case we're not guaranteed to have a valid URL.  Just set it
   // to the empty string to make sure we have a valid protocol buffer.
   verdict.set_url("");
   verdict.set_client_score(kInvalidScore);
   verdict.set_is_phishing(false);
   RunCallback(verdict);
 }
 
 void PhishingClassifier::Clear() {
   page_text_ = NULL;
-  done_callback_.reset(NULL);
+  done_callback_.Reset();
   features_.reset(NULL);
 }
 
 }  // namespace safe_browsing