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

ios/chrome/browser/browser_state/chrome_browser_state_io_data.cc

 // 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_io_data.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/debug/alias.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/path_service.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "components/about_handler/about_protocol_handler.h"
 #include "components/content_settings/core/browser/content_settings_provider.h"
 #include "components/content_settings/core/browser/cookie_settings.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
@@ skipping 34 matching lines @@
 #include "net/url_request/url_request_context_builder.h"
 #include "net/url_request/url_request_intercepting_job_factory.h"
 #include "net/url_request/url_request_interceptor.h"
 #include "net/url_request/url_request_job_factory_impl.h"
 
 namespace {
 
 // For safe shutdown, must be called before the ChromeBrowserStateIOData is
 // destroyed.
 void NotifyContextGettersOfShutdownOnIO(
-    scoped_ptr<ChromeBrowserStateIOData::IOSChromeURLRequestContextGetterVector>
+    std::unique_ptr<
+        ChromeBrowserStateIOData::IOSChromeURLRequestContextGetterVector>
         getters) {
   DCHECK_CURRENTLY_ON(web::WebThread::IO);
   ChromeBrowserStateIOData::IOSChromeURLRequestContextGetterVector::iterator
       iter;
   for (auto& chrome_context_getter : *getters)
     chrome_context_getter->NotifyContextShuttingDown();
 }
 
 }  // namespace
 
 void ChromeBrowserStateIOData::InitializeOnUIThread(
     ios::ChromeBrowserState* browser_state) {
   DCHECK_CURRENTLY_ON(web::WebThread::UI);
   PrefService* pref_service = browser_state->GetPrefs();
-  scoped_ptr<ProfileParams> params(new ProfileParams);
+  std::unique_ptr<ProfileParams> params(new ProfileParams);
   params->path = browser_state->GetOriginalChromeBrowserState()->GetStatePath();
 
   params->io_thread = GetApplicationContext()->GetIOSChromeIOThread();
 
   params->cookie_settings =
       ios::CookieSettingsFactory::GetForBrowserState(browser_state);
   params->host_content_settings_map =
       ios::HostContentSettingsMapFactory::GetForBrowserState(browser_state);
   params->ssl_config_service = browser_state->GetSSLConfigService();
 
@@ skipping 26 matching lines @@
     signin_allowed_.Init(prefs::kSigninAllowed, pref_service);
     signin_allowed_.MoveToThread(io_task_runner);
   }
 
   initialized_on_UI_thread_ = true;
 }
 
 ChromeBrowserStateIOData::AppRequestContext::AppRequestContext() {}
 
 void ChromeBrowserStateIOData::AppRequestContext::SetCookieStore(
-    scoped_ptr<net::CookieStore> cookie_store) {
+    std::unique_ptr<net::CookieStore> cookie_store) {
   cookie_store_ = std::move(cookie_store);
   set_cookie_store(cookie_store_.get());
 }
 
 void ChromeBrowserStateIOData::AppRequestContext::SetHttpTransactionFactory(
-    scoped_ptr<net::HttpTransactionFactory> http_factory) {
+    std::unique_ptr<net::HttpTransactionFactory> http_factory) {
   http_factory_ = std::move(http_factory);
   set_http_transaction_factory(http_factory_.get());
 }
 
 void ChromeBrowserStateIOData::AppRequestContext::SetJobFactory(
-    scoped_ptr<net::URLRequestJobFactory> job_factory) {
+    std::unique_ptr<net::URLRequestJobFactory> job_factory) {
   job_factory_ = std::move(job_factory);
   set_job_factory(job_factory_.get());
 }
 
 ChromeBrowserStateIOData::AppRequestContext::~AppRequestContext() {
   AssertNoURLRequests();
 }
 
 ChromeBrowserStateIOData::ProfileParams::ProfileParams()
     : io_thread(nullptr), browser_state(nullptr) {}
@@ skipping 75 matching lines @@
   return net::URLRequest::IsHandledProtocol(scheme);
 }
 
 // static
 void ChromeBrowserStateIOData::InstallProtocolHandlers(
     net::URLRequestJobFactoryImpl* job_factory,
     ProtocolHandlerMap* protocol_handlers) {
   for (ProtocolHandlerMap::iterator it = protocol_handlers->begin();
        it != protocol_handlers->end(); ++it) {
     bool set_protocol = job_factory->SetProtocolHandler(
-        it->first, make_scoped_ptr(it->second.release()));
+        it->first, base::WrapUnique(it->second.release()));
     DCHECK(set_protocol);
   }
   protocol_handlers->clear();
 }
 
 net::URLRequestContext* ChromeBrowserStateIOData::GetMainRequestContext()
     const {
   DCHECK(initialized_);
   return main_request_context_.get();
 }
 
 net::URLRequestContext* ChromeBrowserStateIOData::GetIsolatedAppRequestContext(
     net::URLRequestContext* main_context,
     const base::FilePath& partition_path) const {
   DCHECK(initialized_);
   AppRequestContext* context = nullptr;
   if (ContainsKey(app_request_context_map_, partition_path)) {
     context = app_request_context_map_[partition_path];
   } else {
     context = AcquireIsolatedAppRequestContext(main_context);
     app_request_context_map_[partition_path] = context;
   }
   DCHECK(context);
   return context;
 }
 
 void ChromeBrowserStateIOData::SetCookieStoreForPartitionPath(
-    scoped_ptr<net::CookieStore> cookie_store,
+    std::unique_ptr<net::CookieStore> cookie_store,
     const base::FilePath& partition_path) {
   DCHECK(ContainsKey(app_request_context_map_, partition_path));
   app_request_context_map_[partition_path]->SetCookieStore(
       std::move(cookie_store));
 }
 
 content_settings::CookieSettings* ChromeBrowserStateIOData::GetCookieSettings()
     const {
   DCHECK(initialized_);
   return cookie_settings_.get();
@@ skipping 24 matching lines @@
   DCHECK_CURRENTLY_ON(web::WebThread::IO);
   return enable_metrics_.GetValue();
 }
 
 base::WeakPtr<net::HttpServerProperties>
 ChromeBrowserStateIOData::http_server_properties() const {
   return http_server_properties_->GetWeakPtr();
 }
 
 void ChromeBrowserStateIOData::set_http_server_properties(
-    scoped_ptr<net::HttpServerProperties> http_server_properties) const {
+    std::unique_ptr<net::HttpServerProperties> http_server_properties) const {
   http_server_properties_ = std::move(http_server_properties);
 }
 
 void ChromeBrowserStateIOData::Init(
     ProtocolHandlerMap* protocol_handlers) const {
   // The basic logic is implemented here. The specific initialization
   // is done in InitializeInternal(), implemented by subtypes. Static helper
   // functions have been provided to assist in common operations.
   DCHECK_CURRENTLY_ON(web::WebThread::IO);
   DCHECK(!initialized_);
 
   // TODO(jhawkins): Remove once crbug.com/102004 is fixed.
   CHECK(initialized_on_UI_thread_);
 
   // TODO(jhawkins): Return to DCHECK once crbug.com/102004 is fixed.
   CHECK(profile_params_.get());
 
   IOSChromeIOThread* const io_thread = profile_params_->io_thread;
   IOSChromeIOThread::Globals* const io_thread_globals = io_thread->globals();
 
   // Create the common request contexts.
   main_request_context_.reset(new net::URLRequestContext());
 
-  scoped_ptr<IOSChromeNetworkDelegate> network_delegate(
+  std::unique_ptr<IOSChromeNetworkDelegate> network_delegate(
       new IOSChromeNetworkDelegate());
 
   network_delegate->set_cookie_settings(profile_params_->cookie_settings.get());
   network_delegate->set_enable_do_not_track(&enable_do_not_track_);
 
   // NOTE: Proxy service uses the default io thread network delegate, not the
   // delegate just created.
   proxy_service_ = ios::ProxyServiceFactory::CreateProxyService(
       io_thread->net_log(), nullptr,
       io_thread_globals->system_network_delegate.get(),
@@ skipping 25 matching lines @@
   profile_params_.reset();
   initialized_ = true;
 }
 
 void ChromeBrowserStateIOData::ApplyProfileParamsToContext(
     net::URLRequestContext* context) const {
   context->set_http_user_agent_settings(chrome_http_user_agent_settings_.get());
   context->set_ssl_config_service(profile_params_->ssl_config_service.get());
 }
 
-scoped_ptr<net::URLRequestJobFactory>
+std::unique_ptr<net::URLRequestJobFactory>
 ChromeBrowserStateIOData::SetUpJobFactoryDefaults(
-    scoped_ptr<net::URLRequestJobFactoryImpl> job_factory,
+    std::unique_ptr<net::URLRequestJobFactoryImpl> job_factory,
     URLRequestInterceptorScopedVector request_interceptors,
     net::NetworkDelegate* network_delegate) const {
   // NOTE(willchan): Keep these protocol handlers in sync with
   // ChromeBrowserStateIOData::IsHandledProtocol().
   bool set_protocol = job_factory->SetProtocolHandler(
       url::kFileScheme,
-      make_scoped_ptr(new net::FileProtocolHandler(
+      base::WrapUnique(new net::FileProtocolHandler(
           web::WebThread::GetBlockingPool()->GetTaskRunnerWithShutdownBehavior(
               base::SequencedWorkerPool::SKIP_ON_SHUTDOWN))));
   DCHECK(set_protocol);
 
   set_protocol = job_factory->SetProtocolHandler(
-      url::kDataScheme, make_scoped_ptr(new net::DataProtocolHandler()));
+      url::kDataScheme, base::WrapUnique(new net::DataProtocolHandler()));
   DCHECK(set_protocol);
 
   job_factory->SetProtocolHandler(
       url::kAboutScheme,
-      make_scoped_ptr(new about_handler::AboutProtocolHandler()));
+      base::WrapUnique(new about_handler::AboutProtocolHandler()));
 
   // Set up interceptors in the reverse order.
-  scoped_ptr<net::URLRequestJobFactory> top_job_factory =
+  std::unique_ptr<net::URLRequestJobFactory> top_job_factory =
       std::move(job_factory);
   for (URLRequestInterceptorScopedVector::reverse_iterator i =
            request_interceptors.rbegin();
        i != request_interceptors.rend(); ++i) {
     top_job_factory.reset(new net::URLRequestInterceptingJobFactory(
-        std::move(top_job_factory), make_scoped_ptr(*i)));
+        std::move(top_job_factory), base::WrapUnique(*i)));
   }
   request_interceptors.weak_clear();
   return top_job_factory;
 }
 
 void ChromeBrowserStateIOData::ShutdownOnUIThread(
-    scoped_ptr<IOSChromeURLRequestContextGetterVector> context_getters) {
+    std::unique_ptr<IOSChromeURLRequestContextGetterVector> context_getters) {
   DCHECK_CURRENTLY_ON(web::WebThread::UI);
 
   google_services_user_account_id_.Destroy();
   enable_referrers_.Destroy();
   enable_do_not_track_.Destroy();
   enable_metrics_.Destroy();
   sync_disabled_.Destroy();
   signin_allowed_.Destroy();
   if (chrome_http_user_agent_settings_)
     chrome_http_user_agent_settings_->CleanupOnUIThread();
 
   if (!context_getters->empty()) {
     if (web::WebThread::IsMessageLoopValid(web::WebThread::IO)) {
       web::WebThread::PostTask(web::WebThread::IO, FROM_HERE,
                                base::Bind(&NotifyContextGettersOfShutdownOnIO,
                                           base::Passed(&context_getters)));
     }
   }
 
   bool posted = web::WebThread::DeleteSoon(web::WebThread::IO, FROM_HERE, this);
   if (!posted)
     delete this;
 }
 
 void ChromeBrowserStateIOData::set_channel_id_service(
     net::ChannelIDService* channel_id_service) const {
   channel_id_service_.reset(channel_id_service);
 }
 
-scoped_ptr<net::HttpNetworkSession>
+std::unique_ptr<net::HttpNetworkSession>
 ChromeBrowserStateIOData::CreateHttpNetworkSession(
     const ProfileParams& profile_params) const {
   net::HttpNetworkSession::Params params;
   net::URLRequestContext* context = main_request_context();
 
   IOSChromeIOThread* const io_thread = profile_params.io_thread;
 
   io_thread->InitializeNetworkSessionParams(&params);
   net::URLRequestContextBuilder::SetHttpNetworkSessionComponents(context,
                                                                  &params);
   if (!IsOffTheRecord()) {
     params.socket_performance_watcher_factory =
         io_thread->globals()->network_quality_estimator.get();
   }
 
-  return scoped_ptr<net::HttpNetworkSession>(
+  return std::unique_ptr<net::HttpNetworkSession>(
       new net::HttpNetworkSession(params));
 }
 
-scoped_ptr<net::HttpCache> ChromeBrowserStateIOData::CreateMainHttpFactory(
+std::unique_ptr<net::HttpCache> ChromeBrowserStateIOData::CreateMainHttpFactory(
     net::HttpNetworkSession* session,
-    scoped_ptr<net::HttpCache::BackendFactory> main_backend) const {
-  return scoped_ptr<net::HttpCache>(
+    std::unique_ptr<net::HttpCache::BackendFactory> main_backend) const {
+  return std::unique_ptr<net::HttpCache>(
       new net::HttpCache(session, std::move(main_backend), true));
 }
 
-scoped_ptr<net::HttpCache> ChromeBrowserStateIOData::CreateHttpFactory(
+std::unique_ptr<net::HttpCache> ChromeBrowserStateIOData::CreateHttpFactory(
     net::HttpNetworkSession* shared_session,
-    scoped_ptr<net::HttpCache::BackendFactory> backend) const {
-  return scoped_ptr<net::HttpCache>(
+    std::unique_ptr<net::HttpCache::BackendFactory> backend) const {
+  return std::unique_ptr<net::HttpCache>(
       new net::HttpCache(shared_session, std::move(backend), true));
 }