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

chrome/browser/supervised_user/experimental/safe_search_url_reporter.cc

 // Copyright 2016 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/safe_search_url_reporter.h"
 
 #include "base/callback.h"
 #include "base/json/json_writer.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "components/signin/core/browser/signin_manager_base.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
@@ skipping 13 matching lines @@
 
 // Request keys
 const char kUrlKey[] = "url";
 
 struct SafeSearchURLReporter::Report {
   Report(const GURL& url, const SuccessCallback& callback, int url_fetcher_id);
   ~Report();
 
   GURL url;
   SuccessCallback callback;
-  scoped_ptr<OAuth2TokenService::Request> access_token_request;
+  std::unique_ptr<OAuth2TokenService::Request> access_token_request;
   std::string access_token;
   bool access_token_expired;
   int url_fetcher_id;
-  scoped_ptr<URLFetcher> url_fetcher;
+  std::unique_ptr<URLFetcher> url_fetcher;
 };
 
 SafeSearchURLReporter::Report::Report(const GURL& url,
                                       const SuccessCallback& callback,
                                       int url_fetcher_id)
     : url(url),
       callback(callback),
       access_token_expired(false),
       url_fetcher_id(url_fetcher_id) {}
 
 SafeSearchURLReporter::Report::~Report() {}
 
 SafeSearchURLReporter::SafeSearchURLReporter(
     OAuth2TokenService* oauth2_token_service,
     const std::string& account_id,
     net::URLRequestContextGetter* context)
     : OAuth2TokenService::Consumer("safe_search_url_reporter"),
       oauth2_token_service_(oauth2_token_service),
       account_id_(account_id),
       context_(context),
       url_fetcher_id_(0) {}
 
 SafeSearchURLReporter::~SafeSearchURLReporter() {}
 
 // static
-scoped_ptr<SafeSearchURLReporter> SafeSearchURLReporter::CreateWithProfile(
+std::unique_ptr<SafeSearchURLReporter> SafeSearchURLReporter::CreateWithProfile(
     Profile* profile) {
   ProfileOAuth2TokenService* token_service =
       ProfileOAuth2TokenServiceFactory::GetForProfile(profile);
   SigninManagerBase* signin = SigninManagerFactory::GetForProfile(profile);
-  return make_scoped_ptr(new SafeSearchURLReporter(
+  return base::WrapUnique(new SafeSearchURLReporter(
       token_service, signin->GetAuthenticatedAccountId(),
       profile->GetRequestContext()));
 }
 
 void SafeSearchURLReporter::ReportUrl(const GURL& url,
                                       const SuccessCallback& callback) {
   reports_.push_back(
-      make_scoped_ptr(new Report(url, callback, url_fetcher_id_)));
+      base::WrapUnique(new Report(url, callback, url_fetcher_id_)));
   StartFetching(reports_.back().get());
 }
 
 void SafeSearchURLReporter::StartFetching(Report* report) {
   OAuth2TokenService::ScopeSet scopes;
   scopes.insert(kApiScope);
   report->access_token_request =
       oauth2_token_service_->StartRequest(account_id_, scopes, this);
 }
 
@@ skipping 78 matching lines @@
     return;
   }
 
   DispatchResult(it, true);
 }
 
 void SafeSearchURLReporter::DispatchResult(ReportIterator it, bool success) {
   (*it)->callback.Run(success);
   reports_.erase(it);
 }