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

chrome/browser/safe_browsing/browser_feature_extractor.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/browser/safe_browsing/browser_feature_extractor.h"
 
 #include <map>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 100 matching lines @@
     ClientSideDetectionService* service)
     : tab_(tab),
       service_(service),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   DCHECK(tab);
 }
 
 BrowserFeatureExtractor::~BrowserFeatureExtractor() {
   weak_factory_.InvalidateWeakPtrs();
   // Delete all the pending extractions (delete callback and request objects).
-  STLDeleteContainerPairPointers(pending_extractions_.begin(),
-                                 pending_extractions_.end());
+  STLDeleteContainerPairFirstPointers(pending_extractions_.begin(),
+                                      pending_extractions_.end());
+
   // Also cancel all the pending history service queries.
   HistoryService* history;
   bool success = GetHistoryService(&history);
   DCHECK(success || pending_queries_.size() == 0);
   // Cancel all the pending history lookups and cleanup the memory.
   for (PendingQueriesMap::iterator it = pending_queries_.begin();
        it != pending_queries_.end(); ++it) {
     if (history) {
       history->CancelRequest(it->first);
     }
     ExtractionData& extraction = it->second;
     delete extraction.first;  // delete request
-    delete extraction.second;  // delete callback
   }
   pending_queries_.clear();
 }
 
 void BrowserFeatureExtractor::ExtractFeatures(const BrowseInfo* info,
                                               ClientPhishingRequest* request,
-                                              DoneCallback* callback) {
+                                              const DoneCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(request);
   DCHECK(info);
   DCHECK_EQ(0U, request->url().find("http:"));
-  DCHECK(callback);
-  if (!callback) {
+  DCHECK(!callback.is_null());
+  if (callback.is_null()) {
     DLOG(ERROR) << "ExtractFeatures called without a callback object";
     return;
   }
 
   // Extract features pertaining to this navigation.
   const NavigationController& controller = tab_->controller();
   int url_index = -1;
   int first_host_index = -1;
 
   GURL request_url(request->url());
@@ skipping 32 matching lines @@
   }
   if (first_host_index != -1) {
     AddNavigationFeatures(features::kHostPrefix,
                           controller,
                           first_host_index,
                           info->host_redirects,
                           request);
   }
 
   ExtractBrowseInfoFeatures(*info, request);
-  pending_extractions_.insert(std::make_pair(request, callback));
+  pending_extractions_[request] = callback;
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&BrowserFeatureExtractor::StartExtractFeatures,
                  weak_factory_.GetWeakPtr(), request, callback));
 }
 
 void BrowserFeatureExtractor::ExtractBrowseInfoFeatures(
     const BrowseInfo& info,
     ClientPhishingRequest* request) {
   if (service_) {
@@ skipping 21 matching lines @@
                static_cast<double>(info.unsafe_resource->threat_type),
                request);
   }
   if (info.http_status_code != 0) {
     AddFeature(features::kHttpStatusCode, info.http_status_code, request);
   }
 }
 
 void BrowserFeatureExtractor::StartExtractFeatures(
     ClientPhishingRequest* request,
-    DoneCallback* callback) {
+    const DoneCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  ExtractionData extraction = std::make_pair(request, callback);
-  size_t removed = pending_extractions_.erase(extraction);
+  size_t removed = pending_extractions_.erase(request);
   DCHECK_EQ(1U, removed);
   HistoryService* history;
   if (!request || !request->IsInitialized() || !GetHistoryService(&history)) {
-    callback->Run(false, request);
-    delete callback;
+    callback.Run(false, request);
     return;
   }
   CancelableRequestProvider::Handle handle = history->QueryURL(
       GURL(request->url()),
       true /* wants_visits */,
       &request_consumer_,
       base::Bind(&BrowserFeatureExtractor::QueryUrlHistoryDone,
                  base::Unretained(this)));
 
   StorePendingQuery(handle, request, callback);
 }
 
 void BrowserFeatureExtractor::QueryUrlHistoryDone(
     CancelableRequestProvider::Handle handle,
     bool success,
     const history::URLRow* row,
     history::VisitVector* visits) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   ClientPhishingRequest* request;
-  DoneCallback* callback;
+  DoneCallback callback;
   if (!GetPendingQuery(handle, &request, &callback)) {
     DLOG(FATAL) << "No pending history query found";
     return;
   }
   DCHECK(request);
-  DCHECK(callback);
+  DCHECK(!callback.is_null());
   if (!success) {
     // URL is not found in the history.  In practice this should not
     // happen (unless there is a real error) because we just visited
     // that URL.
-    callback->Run(false, request);
-    delete callback;
+    callback.Run(false, request);
     return;
   }
   AddFeature(features::kUrlHistoryVisitCount,
              static_cast<double>(row->visit_count()),
              request);
 
   base::Time threshold = base::Time::Now() - base::TimeDelta::FromDays(1);
   int num_visits_24h_ago = 0;
   int num_visits_typed = 0;
   int num_visits_link = 0;
@@ skipping 19 matching lines @@
   AddFeature(features::kUrlHistoryTypedCount,
              static_cast<double>(num_visits_typed),
              request);
   AddFeature(features::kUrlHistoryLinkCount,
              static_cast<double>(num_visits_link),
              request);
 
   // Issue next history lookup for host visits.
   HistoryService* history;
   if (!GetHistoryService(&history)) {
-    callback->Run(false, request);
-    delete callback;
+    callback.Run(false, request);
     return;
   }
   CancelableRequestProvider::Handle next_handle =
       history->GetVisibleVisitCountToHost(
           GURL(request->url()),
           &request_consumer_,
           base::Bind(&BrowserFeatureExtractor::QueryHttpHostVisitsDone,
                      base::Unretained(this)));
   StorePendingQuery(next_handle, request, callback);
 }
 
 void BrowserFeatureExtractor::QueryHttpHostVisitsDone(
     CancelableRequestProvider::Handle handle,
     bool success,
     int num_visits,
     base::Time first_visit) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   ClientPhishingRequest* request;
-  DoneCallback* callback;
+  DoneCallback callback;
   if (!GetPendingQuery(handle, &request, &callback)) {
     DLOG(FATAL) << "No pending history query found";
     return;
   }
   DCHECK(request);
-  DCHECK(callback);
+  DCHECK(!callback.is_null());
   if (!success) {
-    callback->Run(false, request);
-    delete callback;
+    callback.Run(false, request);
     return;
   }
   SetHostVisitsFeatures(num_visits, first_visit, true, request);
 
   // Same lookup but for the HTTPS URL.
   HistoryService* history;
   if (!GetHistoryService(&history)) {
-    callback->Run(false, request);
-    delete callback;
+    callback.Run(false, request);
     return;
   }
   std::string https_url = request->url();
   CancelableRequestProvider::Handle next_handle =
       history->GetVisibleVisitCountToHost(
           GURL(https_url.replace(0, 5, "https:")),
           &request_consumer_,
           base::Bind(&BrowserFeatureExtractor::QueryHttpsHostVisitsDone,
                      base::Unretained(this)));
   StorePendingQuery(next_handle, request, callback);
 }
 
 void BrowserFeatureExtractor::QueryHttpsHostVisitsDone(
     CancelableRequestProvider::Handle handle,
     bool success,
     int num_visits,
     base::Time first_visit) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   ClientPhishingRequest* request;
-  DoneCallback* callback;
+  DoneCallback callback;
   if (!GetPendingQuery(handle, &request, &callback)) {
     DLOG(FATAL) << "No pending history query found";
     return;
   }
   DCHECK(request);
-  DCHECK(callback);
+  DCHECK(!callback.is_null());
   if (!success) {
-    callback->Run(false, request);
-    delete callback;
+    callback.Run(false, request);
     return;
   }
   SetHostVisitsFeatures(num_visits, first_visit, false, request);
-  callback->Run(true, request);  // We're done with all the history lookups.
-  delete callback;
+  callback.Run(true, request);  // We're done with all the history lookups.
 }
 
 void BrowserFeatureExtractor::SetHostVisitsFeatures(
     int num_visits,
     base::Time first_visit,
     bool is_http_query,
     ClientPhishingRequest* request) {
   DCHECK(request);
   AddFeature(is_http_query ?
              features::kHttpHostVisitCount : features::kHttpsHostVisitCount,
              static_cast<double>(num_visits),
              request);
   if (num_visits > 0) {
     AddFeature(
         is_http_query ?
         features::kFirstHttpHostVisitMoreThan24hAgo :
         features::kFirstHttpsHostVisitMoreThan24hAgo,
         (first_visit < (base::Time::Now() - base::TimeDelta::FromDays(1))) ?
         1.0 : 0.0,
         request);
   }
 }
 
 void BrowserFeatureExtractor::StorePendingQuery(
     CancelableRequestProvider::Handle handle,
     ClientPhishingRequest* request,
-    DoneCallback* callback) {
+    const DoneCallback& callback) {
   DCHECK_EQ(0U, pending_queries_.count(handle));
   pending_queries_[handle] = std::make_pair(request, callback);
 }
 
 bool BrowserFeatureExtractor::GetPendingQuery(
     CancelableRequestProvider::Handle handle,
     ClientPhishingRequest** request,
-    DoneCallback** callback) {
+    DoneCallback* callback) {
   PendingQueriesMap::iterator it = pending_queries_.find(handle);
   DCHECK(it != pending_queries_.end());
   if (it != pending_queries_.end()) {
     *request = it->second.first;
     *callback = it->second.second;
     pending_queries_.erase(it);
     return true;
   }
   return false;
 }
 
 bool BrowserFeatureExtractor::GetHistoryService(HistoryService** history) {
   *history = NULL;
   if (tab_ && tab_->browser_context()) {
     Profile* profile = Profile::FromBrowserContext(tab_->browser_context());
     *history = profile->GetHistoryService(Profile::EXPLICIT_ACCESS);
     if (*history) {
       return true;
     }
   }
   VLOG(2) << "Unable to query history.  No history service available.";
   return false;
 }
 
 }  // namespace safe_browsing