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

chrome/browser/supervised_user/experimental/supervised_user_async_url_checker.cc

 // Copyright 2014 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/supervised_user/experimental/supervised_user_async_url_checker.h"
 
 #include <string>
 #include <utility>
 
 #include "base/callback.h"
@@ skipping 27 matching lines @@
 const size_t kDefaultCacheSize = 1000;
 const size_t kDefaultCacheTimeoutSeconds = 3600;
 
 // Builds the POST data for SafeSearch API requests.
 std::string BuildRequestData(const std::string& api_key, const GURL& url) {
   std::string query = net::EscapeQueryParamValue(url.spec(), true);
   return base::StringPrintf(kDataFormat, api_key.c_str(), query.c_str());
 }
 
 // Creates a URLFetcher to call the SafeSearch API for |url|.
-scoped_ptr<net::URLFetcher> CreateFetcher(URLFetcherDelegate* delegate,
-                                          URLRequestContextGetter* context,
-                                          const std::string& api_key,
-                                          const GURL& url) {
-  scoped_ptr<net::URLFetcher> fetcher = URLFetcher::Create(
-      0, GURL(kApiUrl), URLFetcher::POST, delegate);
+std::unique_ptr<net::URLFetcher> CreateFetcher(URLFetcherDelegate* delegate,
+                                               URLRequestContextGetter* context,
+                                               const std::string& api_key,
+                                               const GURL& url) {
+  std::unique_ptr<net::URLFetcher> fetcher =
+      URLFetcher::Create(0, GURL(kApiUrl), URLFetcher::POST, delegate);
   fetcher->SetUploadData(kDataContentType, BuildRequestData(api_key, url));
   fetcher->SetRequestContext(context);
   fetcher->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
                         net::LOAD_DO_NOT_SAVE_COOKIES);
   return fetcher;
 }
 
 // Parses a SafeSearch API |response| and stores the result in |is_porn|.
 // On errors, returns false and doesn't set |is_porn|.
 bool ParseResponse(const std::string& response, bool* is_porn) {
-  scoped_ptr<base::Value> value = base::JSONReader::Read(response);
+  std::unique_ptr<base::Value> value = base::JSONReader::Read(response);
   const base::DictionaryValue* dict = nullptr;
   if (!value || !value->GetAsDictionary(&dict)) {
     DLOG(WARNING) << "ParseResponse failed to parse global dictionary";
     return false;
   }
   const base::ListValue* classifications_list = nullptr;
   if (!dict->GetList("classifications", &classifications_list)) {
     DLOG(WARNING) << "ParseResponse failed to parse classifications list";
     return false;
   }
   if (classifications_list->GetSize() != 1) {
     DLOG(WARNING) << "ParseResponse expected exactly one result";
     return false;
   }
   const base::DictionaryValue* classification_dict = nullptr;
   if (!classifications_list->GetDictionary(0, &classification_dict)) {
     DLOG(WARNING) << "ParseResponse failed to parse classification dict";
     return false;
   }
   classification_dict->GetBoolean("pornography", is_porn);
   return true;
 }
 
 }  // namespace
 
 struct SupervisedUserAsyncURLChecker::Check {
   Check(const GURL& url,
-        scoped_ptr<net::URLFetcher> fetcher,
+        std::unique_ptr<net::URLFetcher> fetcher,
         const CheckCallback& callback);
   ~Check();
 
   GURL url;
-  scoped_ptr<net::URLFetcher> fetcher;
+  std::unique_ptr<net::URLFetcher> fetcher;
   std::vector<CheckCallback> callbacks;
   base::TimeTicks start_time;
 };
 
-SupervisedUserAsyncURLChecker::Check::Check(const GURL& url,
-                                            scoped_ptr<net::URLFetcher> fetcher,
-                                            const CheckCallback& callback)
+SupervisedUserAsyncURLChecker::Check::Check(
+    const GURL& url,
+    std::unique_ptr<net::URLFetcher> fetcher,
+    const CheckCallback& callback)
     : url(url),
       fetcher(std::move(fetcher)),
       callbacks(1, callback),
       start_time(base::TimeTicks::Now()) {}
 
 SupervisedUserAsyncURLChecker::Check::~Check() {}
 
 SupervisedUserAsyncURLChecker::CheckResult::CheckResult(
     SupervisedUserURLFilter::FilteringBehavior behavior,
     bool uncertain)
@@ skipping 54 matching lines @@
   for (Check* check : checks_in_progress_) {
     if (check->url == url) {
       DVLOG(1) << "Adding to pending check for " << url.spec();
       check->callbacks.push_back(callback);
       return false;
     }
   }
 
   DVLOG(1) << "Checking URL " << url;
   std::string api_key = google_apis::GetAPIKey();
-  scoped_ptr<URLFetcher> fetcher(CreateFetcher(this, context_, api_key, url));
+  std::unique_ptr<URLFetcher> fetcher(
+      CreateFetcher(this, context_, api_key, url));
   fetcher->Start();
   checks_in_progress_.push_back(new Check(url, std::move(fetcher), callback));
   return false;
 }
 
 void SupervisedUserAsyncURLChecker::OnURLFetchComplete(
     const net::URLFetcher* source) {
   ScopedVector<Check>::iterator it = checks_in_progress_.begin();
   while (it != checks_in_progress_.end()) {
     if (source == (*it)->fetcher.get())
@@ skipping 21 matching lines @@
 
   UMA_HISTOGRAM_TIMES("ManagedUsers.SafeSitesDelay",
                       base::TimeTicks::Now() - check->start_time);
 
   cache_.Put(check->url, CheckResult(behavior, uncertain));
 
   for (size_t i = 0; i < check->callbacks.size(); i++)
     check->callbacks[i].Run(check->url, behavior, uncertain);
   checks_in_progress_.erase(it);
 }