Convert //chrome/browser/safe_browsing from scoped_ptr to std::unique_ptr

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 220 matching lines @@
         std::string(), controller, url_index, info->url_redirects, request);
   }
   if (first_host_index != -1) {
     AddNavigationFeatures(features::kHostPrefix,
                           controller,
                           first_host_index,
                           info->host_redirects,
                           request);
   }
 
-  // The API doesn't take a scoped_ptr because the API gets mocked and we
-  // cannot mock an API that takes scoped_ptr as arguments.
-  scoped_ptr<ClientPhishingRequest> req(request);
+  // The API doesn't take a std::unique_ptr because the API gets mocked and we
+  // cannot mock an API that takes std::unique_ptr as arguments.
+  std::unique_ptr<ClientPhishingRequest> req(request);
 
   ExtractBrowseInfoFeatures(*info, request);
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&BrowserFeatureExtractor::StartExtractFeatures,
                  weak_factory_.GetWeakPtr(), base::Passed(&req), callback));
 }
 
 void BrowserFeatureExtractor::ExtractMalwareFeatures(
     BrowseInfo* info,
     ClientMalwareRequest* request,
     const MalwareDoneCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   // Grab the IPs because they might go away before we're done
   // checking them against the IP blacklist on the IO thread.
-  scoped_ptr<IPUrlMap> ips(new IPUrlMap);
+  std::unique_ptr<IPUrlMap> ips(new IPUrlMap);
   ips->swap(info->ips);
 
   IPUrlMap* ips_ptr = ips.get();
 
-  // The API doesn't take a scoped_ptr because the API gets mocked and we
-  // cannot mock an API that takes scoped_ptr as arguments.
-  scoped_ptr<ClientMalwareRequest> req(request);
+  // The API doesn't take a std::unique_ptr because the API gets mocked and we
+  // cannot mock an API that takes std::unique_ptr as arguments.
+  std::unique_ptr<ClientMalwareRequest> req(request);
 
   // IP blacklist lookups have to happen on the IO thread.
   BrowserThread::PostTaskAndReply(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&FilterBenignIpsOnIOThread,
                  host_->database_manager(),
                  ips_ptr),
       base::Bind(&BrowserFeatureExtractor::FinishExtractMalwareFeatures,
                  weak_factory_.GetWeakPtr(),
@@ skipping 19 matching lines @@
     AddFeature(features::kSafeBrowsingThreatType,
                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(
-    scoped_ptr<ClientPhishingRequest> request,
+    std::unique_ptr<ClientPhishingRequest> request,
     const DoneCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   history::HistoryService* history;
   if (!request || !request->IsInitialized() || !GetHistoryService(&history)) {
     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,
+    std::unique_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
@@ skipping 46 matching lines @@
   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,
+    std::unique_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, std::move(request));
     return;
@@ skipping 10 matching lines @@
   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,
+    std::unique_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, std::move(request));
     return;
@@ skipping 32 matching lines @@
         profile, ServiceAccessType::EXPLICIT_ACCESS);
     if (*history) {
       return true;
     }
   }
   DVLOG(2) << "Unable to query history.  No history service available.";
   return false;
 }
 
 void BrowserFeatureExtractor::FinishExtractMalwareFeatures(
-    scoped_ptr<IPUrlMap> bad_ips,
+    std::unique_ptr<IPUrlMap> bad_ips,
     MalwareDoneCallback callback,
-    scoped_ptr<ClientMalwareRequest> request) {
+    std::unique_ptr<ClientMalwareRequest> request) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   int matched_bad_ips = 0;
   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, std::move(request));
 }
 
 }  // namespace safe_browsing