Convert //ios from scoped_ptr to std::unique_ptr.

ios/chrome/browser/browser_state/chrome_browser_state_impl_io_data.mm

 // Copyright 2015 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 "ios/chrome/browser/browser_state/chrome_browser_state_impl_io_data.h"
 
+#include <memory>
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/sequenced_task_runner.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/worker_pool.h"
 #include "components/cookie_config/cookie_store_util.h"
 #include "components/net_log/chrome_net_log.h"
 #include "components/prefs/json_pref_store.h"
 #include "components/prefs/pref_filter.h"
 #include "components/prefs/pref_service.h"
 #include "ios/chrome/browser/application_context.h"
 #include "ios/chrome/browser/browser_state/chrome_browser_state.h"
@@ skipping 72 matching lines @@
     return result_value->GetAsDictionary(result);
   }
 
   bool GetMutableValue(base::DictionaryValue** result) override {
     base::Value* result_value = nullptr;
     if (!storage_->GetMutableValue(storage_key_, &result_value))
       return false;
     return result_value->GetAsDictionary(result);
   }
 
-  void SetValue(scoped_ptr<base::DictionaryValue> value) override {
+  void SetValue(std::unique_ptr<base::DictionaryValue> value) override {
     storage_->SetValue(storage_key_, std::move(value),
                        WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   }
 
   void ReportValueChanged() override {
     storage_->ReportValueChanged(storage_key_,
                                  WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   }
 
   bool IsInitializationComplete() override {
@@ skipping 136 matching lines @@
   DCHECK_CURRENTLY_ON(web::WebThread::UI);
   if (initialized_)
     return;
 
   // Set initialized_ to true at the beginning in case any of the objects
   // below try to get the ResourceContext pointer.
   initialized_ = true;
   PrefService* pref_service = browser_state_->GetPrefs();
   io_data_->http_server_properties_manager_ =
       HttpServerPropertiesManagerFactory::CreateManager(pref_service);
-  io_data_->set_http_server_properties(scoped_ptr<net::HttpServerProperties>(
-      io_data_->http_server_properties_manager_));
+  io_data_->set_http_server_properties(
+      std::unique_ptr<net::HttpServerProperties>(
+          io_data_->http_server_properties_manager_));
   io_data_->safe_browsing_enabled()->Init(prefs::kSafeBrowsingEnabled,
                                           pref_service);
   io_data_->safe_browsing_enabled()->MoveToThread(
       web::WebThread::GetTaskRunnerForThread(web::WebThread::IO));
   io_data_->InitializeOnUIThread(browser_state_);
 }
 
-scoped_ptr<ChromeBrowserStateIOData::IOSChromeURLRequestContextGetterVector>
+std::unique_ptr<
+    ChromeBrowserStateIOData::IOSChromeURLRequestContextGetterVector>
 ChromeBrowserStateImplIOData::Handle::GetAllContextGetters() {
   IOSChromeURLRequestContextGetterMap::iterator iter;
-  scoped_ptr<IOSChromeURLRequestContextGetterVector> context_getters(
+  std::unique_ptr<IOSChromeURLRequestContextGetterVector> context_getters(
       new IOSChromeURLRequestContextGetterVector());
 
   iter = app_request_context_getter_map_.begin();
   for (; iter != app_request_context_getter_map_.end(); ++iter)
     context_getters->push_back(iter->second);
 
   if (main_request_context_getter_.get())
     context_getters->push_back(main_request_context_getter_);
 
   return context_getters;
 }
 
 ChromeBrowserStateImplIOData::LazyParams::LazyParams() : cache_max_size(0) {}
 
 ChromeBrowserStateImplIOData::LazyParams::~LazyParams() {}
 
 ChromeBrowserStateImplIOData::ChromeBrowserStateImplIOData()
     : ChromeBrowserStateIOData(
           ios::ChromeBrowserStateType::REGULAR_BROWSER_STATE),
       http_server_properties_manager_(nullptr),
       app_cache_max_size_(0) {}
 
 ChromeBrowserStateImplIOData::~ChromeBrowserStateImplIOData() {}
 
 void ChromeBrowserStateImplIOData::InitializeInternal(
-    scoped_ptr<IOSChromeNetworkDelegate> chrome_network_delegate,
+    std::unique_ptr<IOSChromeNetworkDelegate> chrome_network_delegate,
     ProfileParams* profile_params,
     ProtocolHandlerMap* protocol_handlers) const {
   // Set up a persistent store for use by the network stack on the IO thread.
   base::FilePath network_json_store_filepath(
       profile_path_.Append(kIOSChromeNetworkPersistentStateFilename));
   network_json_store_ = new JsonPrefStore(
       network_json_store_filepath,
       JsonPrefStore::GetTaskRunnerForFile(network_json_store_filepath,
                                           web::WebThread::GetBlockingPool()),
-      scoped_ptr<PrefFilter>());
+      std::unique_ptr<PrefFilter>());
   network_json_store_->ReadPrefsAsync(nullptr);
 
   net::URLRequestContext* main_context = main_request_context();
 
   IOSChromeIOThread* const io_thread = profile_params->io_thread;
   IOSChromeIOThread::Globals* const io_thread_globals = io_thread->globals();
 
   ApplyProfileParamsToContext(main_context);
 
   if (http_server_properties_manager_)
@@ skipping 48 matching lines @@
                 web::WebThread::GetBlockingPool()->GetSequenceToken()));
     channel_id_service = new net::ChannelIDService(
         new net::DefaultChannelIDStore(channel_id_db.get()),
         base::WorkerPool::GetTaskRunner(true));
   }
 
   set_channel_id_service(channel_id_service);
   main_context->set_channel_id_service(channel_id_service);
   main_cookie_store_->SetChannelIDServiceID(channel_id_service->GetUniqueID());
 
-  scoped_ptr<net::HttpCache::BackendFactory> main_backend(
+  std::unique_ptr<net::HttpCache::BackendFactory> main_backend(
       new net::HttpCache::DefaultBackend(
           net::DISK_CACHE, net::CACHE_BACKEND_BLOCKFILE,
           lazy_params_->cache_path, lazy_params_->cache_max_size,
           web::WebThread::GetTaskRunnerForThread(web::WebThread::CACHE)));
   http_network_session_ = CreateHttpNetworkSession(*profile_params);
   main_http_factory_ = CreateMainHttpFactory(http_network_session_.get(),
                                              std::move(main_backend));
   main_context->set_http_transaction_factory(main_http_factory_.get());
 
-  scoped_ptr<net::URLRequestJobFactoryImpl> main_job_factory(
+  std::unique_ptr<net::URLRequestJobFactoryImpl> main_job_factory(
       new net::URLRequestJobFactoryImpl());
   InstallProtocolHandlers(main_job_factory.get(), protocol_handlers);
 
   // TODO(crbug.com/592012): Delete request_interceptor and its handling if
   // it's not needed in the future.
   URLRequestInterceptorScopedVector request_interceptors;
   main_job_factory_ = SetUpJobFactoryDefaults(std::move(main_job_factory),
                                               std::move(request_interceptors),
                                               main_context->network_delegate());
   main_context->set_job_factory(main_job_factory_.get());
   main_context->set_network_quality_estimator(
       io_thread_globals->network_quality_estimator.get());
 
   // Setup SDCH for this profile.
   sdch_manager_.reset(new net::SdchManager);
   sdch_policy_.reset(new net::SdchOwner(sdch_manager_.get(), main_context));
   main_context->set_sdch_manager(sdch_manager_.get());
   sdch_policy_->EnablePersistentStorage(
-      make_scoped_ptr(new SdchOwnerPrefStorage(network_json_store_.get())));
+      base::WrapUnique(new SdchOwnerPrefStorage(network_json_store_.get())));
 
   lazy_params_.reset();
 }
 
 ChromeBrowserStateIOData::AppRequestContext*
 ChromeBrowserStateImplIOData::InitializeAppRequestContext(
     net::URLRequestContext* main_context) const {
   // Copy most state from the main context.
   AppRequestContext* context = new AppRequestContext();
   context->CopyFrom(main_context);
 
   // Use a separate HTTP disk cache for isolated apps.
-  scoped_ptr<net::HttpCache::BackendFactory> app_backend =
+  std::unique_ptr<net::HttpCache::BackendFactory> app_backend =
       net::HttpCache::DefaultBackend::InMemory(0);
-  scoped_ptr<net::HttpCache> app_http_cache =
+  std::unique_ptr<net::HttpCache> app_http_cache =
       CreateHttpFactory(http_network_session_.get(), std::move(app_backend));
 
   cookie_util::CookieStoreConfig ios_cookie_config(
       base::FilePath(),
       cookie_util::CookieStoreConfig::EPHEMERAL_SESSION_COOKIES,
       cookie_util::CookieStoreConfig::COOKIE_STORE_IOS, nullptr);
-  scoped_ptr<net::CookieStore> cookie_store =
+  std::unique_ptr<net::CookieStore> cookie_store =
       cookie_util::CreateCookieStore(ios_cookie_config);
 
   // Transfer ownership of the cookies and cache to AppRequestContext.
   context->SetCookieStore(std::move(cookie_store));
   context->SetHttpTransactionFactory(std::move(app_http_cache));
 
-  scoped_ptr<net::URLRequestJobFactoryImpl> job_factory(
+  std::unique_ptr<net::URLRequestJobFactoryImpl> job_factory(
       new net::URLRequestJobFactoryImpl());
   // TODO(crbug.com/592012): Delete request_interceptor and its handling if
   // it's not needed in the future.
   URLRequestInterceptorScopedVector request_interceptors;
-  scoped_ptr<net::URLRequestJobFactory> top_job_factory(SetUpJobFactoryDefaults(
-      std::move(job_factory), std::move(request_interceptors),
-      main_context->network_delegate()));
+  std::unique_ptr<net::URLRequestJobFactory> top_job_factory(
+      SetUpJobFactoryDefaults(std::move(job_factory),
+                              std::move(request_interceptors),
+                              main_context->network_delegate()));
   context->SetJobFactory(std::move(top_job_factory));
 
   return context;
 }
 
 ChromeBrowserStateIOData::AppRequestContext*
 ChromeBrowserStateImplIOData::AcquireIsolatedAppRequestContext(
     net::URLRequestContext* main_context) const {
   // We create per-app contexts on demand, unlike the others above.
   AppRequestContext* app_request_context =
       InitializeAppRequestContext(main_context);
   DCHECK(app_request_context);
   return app_request_context;
 }
 
 void ChromeBrowserStateImplIOData::ClearNetworkingHistorySinceOnIOThread(
     base::Time time,
     const base::Closure& completion) {
   DCHECK_CURRENTLY_ON(web::WebThread::IO);
   DCHECK(initialized());
 
   DCHECK(transport_security_state());
   // Completes synchronously.
   transport_security_state()->DeleteAllDynamicDataSince(time);
   DCHECK(http_server_properties_manager_);
   http_server_properties_manager_->Clear(completion);
 }