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

chrome/browser/supervised_user/child_accounts/permission_request_creator_apiary.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/child_accounts/permission_request_creator_apiary.h"
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.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 "chrome/common/chrome_switches.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"
@@ skipping 31 matching lines @@
 struct PermissionRequestCreatorApiary::Request {
   Request(const std::string& request_type,
           const std::string& object_ref,
           const SuccessCallback& callback,
           int url_fetcher_id);
   ~Request();
 
   std::string request_type;
   std::string object_ref;
   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;
 };
 
 PermissionRequestCreatorApiary::Request::Request(
     const std::string& request_type,
     const std::string& object_ref,
     const SuccessCallback& callback,
     int url_fetcher_id)
     : request_type(request_type),
       object_ref(object_ref),
       callback(callback),
@@ skipping 10 matching lines @@
     : OAuth2TokenService::Consumer("permissions_creator"),
       oauth2_token_service_(oauth2_token_service),
       account_id_(account_id),
       context_(context),
       url_fetcher_id_(0) {
 }
 
 PermissionRequestCreatorApiary::~PermissionRequestCreatorApiary() {}
 
 // static
-scoped_ptr<PermissionRequestCreator>
+std::unique_ptr<PermissionRequestCreator>
 PermissionRequestCreatorApiary::CreateWithProfile(Profile* profile) {
   ProfileOAuth2TokenService* token_service =
       ProfileOAuth2TokenServiceFactory::GetForProfile(profile);
   SigninManagerBase* signin = SigninManagerFactory::GetForProfile(profile);
-  return make_scoped_ptr(new PermissionRequestCreatorApiary(
-      token_service,
-      signin->GetAuthenticatedAccountId(),
+  return base::WrapUnique(new PermissionRequestCreatorApiary(
+      token_service, signin->GetAuthenticatedAccountId(),
       profile->GetRequestContext()));
 }
 
 bool PermissionRequestCreatorApiary::IsEnabled() const {
   return true;
 }
 
 void PermissionRequestCreatorApiary::CreateURLAccessRequest(
     const GURL& url_requested,
     const SuccessCallback& callback) {
@@ skipping 123 matching lines @@
   }
 
   if (response_code != net::HTTP_OK) {
     LOG(WARNING) << "HTTP error " << response_code;
     DispatchResult(it, false);
     return;
   }
 
   std::string response_body;
   source->GetResponseAsString(&response_body);
-  scoped_ptr<base::Value> value = base::JSONReader::Read(response_body);
+  std::unique_ptr<base::Value> value = base::JSONReader::Read(response_body);
   base::DictionaryValue* dict = NULL;
   if (!value || !value->GetAsDictionary(&dict)) {
     LOG(WARNING) << "Invalid top-level dictionary";
     DispatchResult(it, false);
     return;
   }
   base::DictionaryValue* permission_dict = NULL;
   if (!dict->GetDictionary(kPermissionRequestKey, &permission_dict)) {
     LOG(WARNING) << "Permission request not found";
     DispatchResult(it, false);
     return;
   }
   std::string id;
   if (!permission_dict->GetString(kIdKey, &id)) {
     LOG(WARNING) << "ID not found";
     DispatchResult(it, false);
     return;
   }
   DispatchResult(it, true);
 }
 
 void PermissionRequestCreatorApiary::DispatchResult(RequestIterator it,
                                                     bool success) {
   (*it)->callback.Run(success);
   requests_.erase(it);
 }