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

chrome/browser/safe_browsing/client_side_detection_service.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/client_side_detection_service.h"
 
 #include <algorithm>
+#include <memory>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/safe_browsing/client_model.pb.h"
@@ skipping 238 matching lines @@
        !i.IsAtEnd(); i.Advance()) {
     SendModelToProcess(i.GetCurrentValue());
   }
 }
 
 void ClientSideDetectionService::StartClientReportPhishingRequest(
     ClientPhishingRequest* verdict,
     bool is_extended_reporting,
     const ClientReportPhishingRequestCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  scoped_ptr<ClientPhishingRequest> request(verdict);
+  std::unique_ptr<ClientPhishingRequest> request(verdict);
 
   if (!enabled_) {
     if (!callback.is_null())
       callback.Run(GURL(request->url()), false);
     return;
   }
 
   // Fill in metadata about which model we used.
   if (is_extended_reporting) {
     request->set_model_filename(model_loader_extended_->name());
@@ skipping 32 matching lines @@
   fetcher->Start();
 
   // Record that we made a request
   phishing_report_times_.push(base::Time::Now());
 }
 
 void ClientSideDetectionService::StartClientReportMalwareRequest(
     ClientMalwareRequest* verdict,
     const ClientReportMalwareRequestCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  scoped_ptr<ClientMalwareRequest> request(verdict);
+  std::unique_ptr<ClientMalwareRequest> request(verdict);
 
   if (!enabled_) {
     if (!callback.is_null())
       callback.Run(GURL(request->url()), GURL(request->url()), false);
     return;
   }
 
   std::string request_data;
   if (!request->SerializeToString(&request_data)) {
     UpdateEnumUMAHistogram(REPORT_FAILED_SERIALIZATION);
@@ skipping 31 matching lines @@
 
 
 void ClientSideDetectionService::HandlePhishingVerdict(
     const net::URLFetcher* source,
     const GURL& url,
     const net::URLRequestStatus& status,
     int response_code,
     const net::ResponseCookies& cookies,
     const std::string& data) {
   ClientPhishingResponse response;
-  scoped_ptr<ClientReportInfo> info(client_phishing_reports_[source]);
+  std::unique_ptr<ClientReportInfo> info(client_phishing_reports_[source]);
   bool is_phishing = false;
   if (status.is_success() && net::HTTP_OK == response_code &&
       response.ParseFromString(data)) {
     // Cache response, possibly flushing an old one.
     cache_[info->phishing_url] =
         make_linked_ptr(new CacheState(response.phishy(), base::Time::Now()));
     is_phishing = response.phishy();
   } else {
     DLOG(ERROR) << "Unable to get the server verdict for URL: "
                 << info->phishing_url << " status: " << status.status() << " "
@@ skipping 14 matching lines @@
     const std::string& data) {
   if (status.is_success()) {
     UMA_HISTOGRAM_SPARSE_SLOWLY(
         "SBClientMalware.IPBlacklistRequestResponseCode", response_code);
   }
   // status error is negative, so we put - in front of it.
   UMA_HISTOGRAM_SPARSE_SLOWLY(
       "SBClientMalware.IPBlacklistRequestNetError", -status.error());
 
   ClientMalwareResponse response;
-  scoped_ptr<ClientMalwareReportInfo> info(client_malware_reports_[source]);
+  std::unique_ptr<ClientMalwareReportInfo> info(
+      client_malware_reports_[source]);
   bool should_blacklist = false;
   if (status.is_success() && net::HTTP_OK == response_code &&
       response.ParseFromString(data)) {
     should_blacklist = response.blacklist();
   } else {
     DLOG(ERROR) << "Unable to get the server verdict for URL: "
                 << info->original_url << " status: " << status.status() << " "
                 << "response_code:" << response_code;
   }
 
@@ skipping 98 matching lines @@
     const std::string& report_url) {
   GURL url(report_url);
   std::string api_key = google_apis::GetAPIKey();
   if (!api_key.empty())
     url = url.Resolve("?key=" + net::EscapeQueryParamValue(api_key, true));
 
   return url;
 }
 
 }  // namespace safe_browsing