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

ios/crnet/crnet_environment.mm

 // 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 "ios/crnet/crnet_environment.h"
 
 #import <Foundation/Foundation.h>
 
 #include <utility>
 
 #include "base/at_exit.h"
 #include "base/atomicops.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/i18n/icu_util.h"
 #include "base/json/json_writer.h"
 #include "base/mac/bind_objc_block.h"
 #include "base/mac/foundation_util.h"
 #include "base/mac/scoped_block.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/path_service.h"
 #include "base/threading/worker_pool.h"
 #include "components/prefs/json_pref_store.h"
 #include "components/prefs/pref_filter.h"
 #include "crypto/nss_util.h"
 #include "ios/crnet/sdch_owner_pref_storage.h"
 #include "ios/net/cookies/cookie_store_ios.h"
 #include "ios/net/crn_http_protocol_handler.h"
 #include "ios/net/empty_nsurlcache.h"
@@ skipping 312 matching lines @@
   if (!sdch_enabled_) {
     DCHECK_EQ(static_cast<net::SdchManager*>(nullptr), context->sdch_manager());
     return;
   }
 
   sdch_manager_.reset(new net::SdchManager());
   sdch_owner_.reset(new net::SdchOwner(sdch_manager_.get(), context));
   if (!sdch_pref_store_filename_.empty()) {
     base::FilePath path(sdch_pref_store_filename_);
     pref_store_worker_pool_ = file_user_blocking_thread_->task_runner();
-    net_pref_store_ = new JsonPrefStore(
-        path,
-        pref_store_worker_pool_.get(),
-        scoped_ptr<PrefFilter>());
+    net_pref_store_ = new JsonPrefStore(path, pref_store_worker_pool_.get(),
+                                        std::unique_ptr<PrefFilter>());
     net_pref_store_->ReadPrefsAsync(nullptr);
     sdch_owner_->EnablePersistentStorage(
-        scoped_ptr<net::SdchOwner::PrefStorage>(
+        std::unique_ptr<net::SdchOwner::PrefStorage>(
             new SdchOwnerPrefStorage(net_pref_store_.get())));
   }
   context->set_sdch_manager(sdch_manager_.get());
 }
 
 void CrNetEnvironment::InitializeOnNetworkThread() {
   DCHECK(base::MessageLoop::current() == network_io_thread_->message_loop());
 
   ConfigureSdchOnNetworkThread();
 
@@ skipping 46 matching lines @@
           std::move(proxy_config_service_), 0, nullptr)
           .release());
 
   // Cache
   NSArray* dirs = NSSearchPathForDirectoriesInDomains(NSCachesDirectory,
                                                       NSUserDomainMask,
                                                       YES);
   base::FilePath cache_path =
       base::mac::NSStringToFilePath([dirs objectAtIndex:0]);
   cache_path = cache_path.Append(FILE_PATH_LITERAL("crnet"));
-  scoped_ptr<net::HttpCache::DefaultBackend> main_backend(
+  std::unique_ptr<net::HttpCache::DefaultBackend> main_backend(
       new net::HttpCache::DefaultBackend(net::DISK_CACHE,
                                          net::CACHE_BACKEND_DEFAULT, cache_path,
                                          0,  // Default cache size.
                                          network_cache_thread_->task_runner()));
 
   net::HttpNetworkSession::Params params;
   params.host_resolver = main_context_->host_resolver();
   params.cert_verifier = main_context_->cert_verifier();
   params.channel_id_service = main_context_->channel_id_service();
   params.transport_security_state = main_context_->transport_security_state();
@@ skipping 27 matching lines @@
   main_context_->set_http_transaction_factory(main_cache);
 
   // Cookies
   cookie_store_ = net::CookieStoreIOS::CreateCookieStore(
       [NSHTTPCookieStorage sharedHTTPCookieStorage]);
   main_context_->set_cookie_store(cookie_store_.get());
 
   net::URLRequestJobFactoryImpl* job_factory =
       new net::URLRequestJobFactoryImpl;
   job_factory->SetProtocolHandler(
-      "data", make_scoped_ptr(new net::DataProtocolHandler));
+      "data", base::WrapUnique(new net::DataProtocolHandler));
   job_factory->SetProtocolHandler(
-      "file", make_scoped_ptr(
+      "file", base::WrapUnique(
                   new net::FileProtocolHandler(file_thread_->task_runner())));
   main_context_->set_job_factory(job_factory);
 
   main_context_->set_net_log(net_log_.get());
 }
 
 std::string CrNetEnvironment::user_agent() {
   const net::HttpUserAgentSettings* user_agent_settings =
       main_context_->http_user_agent_settings();
   if (!user_agent_settings) {
     return nullptr;
   }
 
   return user_agent_settings->GetUserAgent();
 }
 
 void CrNetEnvironment::ClearCache(ClearCacheCallback callback) {
   PostToNetworkThread(
       FROM_HERE,
       base::Bind(&net::ClearHttpCache, main_context_getter_,
                  network_io_thread_->task_runner(), base::BindBlock(callback)));
 }