Convert //chromecast from scoped_ptr to std::unique_ptr

chromecast/browser/url_request_context_factory.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 "chromecast/browser/url_request_context_factory.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/threading/worker_pool.h"
 #include "chromecast/base/chromecast_switches.h"
 #include "chromecast/browser/cast_http_user_agent_settings.h"
 #include "chromecast/browser/cast_network_delegate.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/cookie_store_factory.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/url_constants.h"
 #include "net/cert/cert_verifier.h"
@@ skipping 56 matching lines @@
       GetNetworkTaskRunner() const override {
     return content::BrowserThread::GetMessageLoopProxyForThread(
         content::BrowserThread::IO);
   }
 
  private:
   ~URLRequestContextGetter() override {}
 
   const bool is_media_;
   URLRequestContextFactory* const factory_;
-  scoped_ptr<net::URLRequestContext> request_context_;
+  std::unique_ptr<net::URLRequestContext> request_context_;
 
   DISALLOW_COPY_AND_ASSIGN(URLRequestContextGetter);
 };
 
 // The URLRequestContextFactory::MainURLRequestContextGetter class is used for
 // the main URLRequestContext.
 class URLRequestContextFactory::MainURLRequestContextGetter
     : public net::URLRequestContextGetter {
  public:
   MainURLRequestContextGetter(
@@ skipping 23 matching lines @@
         content::BrowserThread::IO);
   }
 
  private:
   ~MainURLRequestContextGetter() override {}
 
   content::BrowserContext* const browser_context_;
   URLRequestContextFactory* const factory_;
   content::ProtocolHandlerMap protocol_handlers_;
   content::URLRequestInterceptorScopedVector request_interceptors_;
-  scoped_ptr<net::URLRequestContext> request_context_;
+  std::unique_ptr<net::URLRequestContext> request_context_;
 
   DISALLOW_COPY_AND_ASSIGN(MainURLRequestContextGetter);
 };
 
 URLRequestContextFactory::URLRequestContextFactory()
     : app_network_delegate_(CastNetworkDelegate::Create()),
       system_network_delegate_(CastNetworkDelegate::Create()),
       system_dependencies_initialized_(false),
       main_dependencies_initialized_(false),
       media_dependencies_initialized_(false) {
@@ skipping 76 matching lines @@
 }
 
 void URLRequestContextFactory::InitializeMainContextDependencies(
     net::HttpTransactionFactory* transaction_factory,
     content::ProtocolHandlerMap* protocol_handlers,
     content::URLRequestInterceptorScopedVector request_interceptors) {
   if (main_dependencies_initialized_)
     return;
 
   main_transaction_factory_.reset(transaction_factory);
-  scoped_ptr<net::URLRequestJobFactoryImpl> job_factory(
+  std::unique_ptr<net::URLRequestJobFactoryImpl> job_factory(
       new net::URLRequestJobFactoryImpl());
   // Keep ProtocolHandlers added in sync with
   // CastContentBrowserClient::IsHandledURL().
   bool set_protocol = false;
   for (content::ProtocolHandlerMap::iterator it = protocol_handlers->begin();
        it != protocol_handlers->end();
        ++it) {
     set_protocol = job_factory->SetProtocolHandler(
-        it->first, make_scoped_ptr(it->second.release()));
+        it->first, base::WrapUnique(it->second.release()));
     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);
 
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableLocalFileAccesses)) {
     set_protocol = job_factory->SetProtocolHandler(
         url::kFileScheme,
-        make_scoped_ptr(new net::FileProtocolHandler(
+        base::WrapUnique(new net::FileProtocolHandler(
             content::BrowserThread::GetBlockingPool()
                 ->GetTaskRunnerWithShutdownBehavior(
                     base::SequencedWorkerPool::SKIP_ON_SHUTDOWN))));
     DCHECK(set_protocol);
   }
 
   // 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 (content::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();
 
   main_job_factory_.reset(top_job_factory.release());
 
   main_dependencies_initialized_ = true;
 }
 
 void URLRequestContextFactory::InitializeMediaContextDependencies(
     net::HttpTransactionFactory* transaction_factory) {
@@ skipping 122 matching lines @@
 
 void URLRequestContextFactory::InitializeNetworkDelegates() {
   app_network_delegate_->Initialize(false);
   LOG(INFO) << "Initialized app network delegate.";
   system_network_delegate_->Initialize(false);
   LOG(INFO) << "Initialized system network delegate.";
 }
 
 }  // namespace shell
 }  // namespace chromecast