Convert Pass()→std::move() in //chrome

chrome/browser/safe_browsing/browser_feature_extractor.cc

 // Copyright (c) 2012 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 <stddef.h>
 
 #include <map>
 #include <utility>
@@ skipping 290 matching lines @@
     AddFeature(features::kHttpStatusCode, info.http_status_code, request);
   }
 }
 
 void BrowserFeatureExtractor::StartExtractFeatures(
     scoped_ptr<ClientPhishingRequest> request,
     const DoneCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   history::HistoryService* history;
   if (!request || !request->IsInitialized() || !GetHistoryService(&history)) {
-    callback.Run(false, request.Pass());
+    callback.Run(false, std::move(request));
     return;
   }
   GURL request_url(request->url());
   history->QueryURL(request_url,
                     true /* wants_visits */,
                     base::Bind(&BrowserFeatureExtractor::QueryUrlHistoryDone,
                                base::Unretained(this),
                                base::Passed(&request),
                                callback),
                     &cancelable_task_tracker_);
 }
 
 void BrowserFeatureExtractor::QueryUrlHistoryDone(
     scoped_ptr<ClientPhishingRequest> request,
     const DoneCallback& callback,
     bool success,
     const history::URLRow& row,
     const history::VisitVector& visits) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(request);
   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.Pass());
+    callback.Run(false, std::move(request));
     return;
   }
   AddFeature(features::kUrlHistoryVisitCount,
              static_cast<double>(row.visit_count()),
              request.get());
 
   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 20 matching lines @@
   AddFeature(features::kUrlHistoryTypedCount,
              static_cast<double>(num_visits_typed),
              request.get());
   AddFeature(features::kUrlHistoryLinkCount,
              static_cast<double>(num_visits_link),
              request.get());
 
   // Issue next history lookup for host visits.
   history::HistoryService* history;
   if (!GetHistoryService(&history)) {
-    callback.Run(false, request.Pass());
+    callback.Run(false, std::move(request));
     return;
   }
   GURL request_url(request->url());
   history->GetVisibleVisitCountToHost(
       request_url,
       base::Bind(&BrowserFeatureExtractor::QueryHttpHostVisitsDone,
                  base::Unretained(this),
                  base::Passed(&request),
                  callback),
       &cancelable_task_tracker_);
 }
 
 void BrowserFeatureExtractor::QueryHttpHostVisitsDone(
     scoped_ptr<ClientPhishingRequest> request,
     const DoneCallback& callback,
     bool success,
     int num_visits,
     base::Time first_visit) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(request);
   DCHECK(!callback.is_null());
   if (!success) {
-    callback.Run(false, request.Pass());
+    callback.Run(false, std::move(request));
     return;
   }
   SetHostVisitsFeatures(num_visits, first_visit, true, request.get());
 
   // Same lookup but for the HTTPS URL.
   history::HistoryService* history;
   if (!GetHistoryService(&history)) {
-    callback.Run(false, request.Pass());
+    callback.Run(false, std::move(request));
     return;
   }
   std::string https_url = request->url();
   history->GetVisibleVisitCountToHost(
       GURL(https_url.replace(0, 5, "https:")),
       base::Bind(&BrowserFeatureExtractor::QueryHttpsHostVisitsDone,
                  base::Unretained(this),
                  base::Passed(&request),
                  callback),
       &cancelable_task_tracker_);
 }
 
 void BrowserFeatureExtractor::QueryHttpsHostVisitsDone(
     scoped_ptr<ClientPhishingRequest> request,
     const DoneCallback& callback,
     bool success,
     int num_visits,
     base::Time first_visit) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(request);
   DCHECK(!callback.is_null());
   if (!success) {
-    callback.Run(false, request.Pass());
+    callback.Run(false, std::move(request));
     return;
   }
   SetHostVisitsFeatures(num_visits, first_visit, false, request.get());
-  callback.Run(true, request.Pass());
+  callback.Run(true, std::move(request));
 }
 
 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,
@@ skipping 34 matching lines @@
   for (IPUrlMap::const_iterator it = bad_ips->begin();
        it != bad_ips->end(); ++it) {
     AddMalwareIpUrlInfo(it->first, it->second, request.get());
     ++matched_bad_ips;
     // Limit the number of matched bad IPs in one request to control
     // the request's size
     if (matched_bad_ips >= kMaxMalwareIPPerRequest) {
       break;
     }
   }
-  callback.Run(true, request.Pass());
+  callback.Run(true, std::move(request));
 }
 
 }  // namespace safe_browsing