Convert //chromecast from scoped_ptr to std::unique_ptr

chromecast/browser/cast_browser_main_parts.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/cast_browser_main_parts.h"
 
 #include <stddef.h>
 #include <string.h>
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "cc/base/switches.h"
 #include "chromecast/base/cast_constants.h"
 #include "chromecast/base/cast_paths.h"
 #include "chromecast/base/cast_sys_info_util.h"
 #include "chromecast/base/chromecast_switches.h"
@@ skipping 268 matching lines @@
 #if defined(OS_ANDROID)
   net::NetworkChangeNotifier::SetFactory(
       new net::NetworkChangeNotifierFactoryAndroid());
 #else
   net::NetworkChangeNotifier::SetFactory(
       new NetworkChangeNotifierFactoryCast());
 #endif  // defined(OS_ANDROID)
 }
 
 void CastBrowserMainParts::PostMainMessageLoopStart() {
-  cast_browser_process_->SetMetricsHelper(make_scoped_ptr(
+  cast_browser_process_->SetMetricsHelper(base::WrapUnique(
       new metrics::CastMetricsHelper(base::ThreadTaskRunnerHandle::Get())));
 
 #if defined(OS_ANDROID)
   base::MessageLoopForUI::current()->Start();
 #endif  // defined(OS_ANDROID)
 }
 
 void CastBrowserMainParts::ToolkitInitialized() {
 #if defined(OS_LINUX)
   // Without this call, the FontConfig library gets implicitly initialized
@@ skipping 13 matching lines @@
 
 int CastBrowserMainParts::PreCreateThreads() {
 #if defined(OS_ANDROID)
   // GPU process is started immediately after threads are created, requiring
   // CrashDumpManager to be initialized beforehand.
   base::FilePath crash_dumps_dir;
   if (!chromecast::CrashHandler::GetCrashDumpLocation(&crash_dumps_dir)) {
     LOG(ERROR) << "Could not find crash dump location.";
   }
   cast_browser_process_->SetCrashDumpManager(
-      make_scoped_ptr(new breakpad::CrashDumpManager(crash_dumps_dir)));
+      base::WrapUnique(new breakpad::CrashDumpManager(crash_dumps_dir)));
 #else
   base::FilePath home_dir;
   CHECK(PathService::Get(DIR_CAST_HOME, &home_dir));
   if (!base::CreateDirectory(home_dir))
     return 1;
 
   // Hook for internal code
   cast_browser_process_->browser_client()->PreCreateThreads();
 
   // AudioManager is created immediately after threads are created, requiring
   // AudioManagerFactory to be set beforehand.
   ::media::AudioManager::SetFactory(
       new media::CastAudioManagerFactory(media_pipeline_backend_manager()));
 
   // Set GL strings so GPU config code can make correct feature blacklisting/
   // whitelisting decisions.
   // Note: SetGLStrings can be called before GpuDataManager::Initialize.
-  scoped_ptr<CastSysInfo> sys_info = CreateSysInfo();
+  std::unique_ptr<CastSysInfo> sys_info = CreateSysInfo();
   content::GpuDataManager::GetInstance()->SetGLStrings(
       sys_info->GetGlVendor(), sys_info->GetGlRenderer(),
       sys_info->GetGlVersion());
 #endif
 
 #if defined(USE_AURA)
   // Screen can (and should) exist even with no displays connected. Its presence
   // is assumed as an interface to access display information, e.g. from metrics
   // code.  See CastContentWindow::CreateWindowTree for update when resolution
   // is available.
-  cast_browser_process_->SetCastScreen(make_scoped_ptr(new CastScreen));
+  cast_browser_process_->SetCastScreen(base::WrapUnique(new CastScreen));
   DCHECK(!gfx::Screen::GetScreen());
   gfx::Screen::SetScreenInstance(cast_browser_process_->cast_screen());
 #endif
 
   content::ChildProcessSecurityPolicy::GetInstance()->RegisterWebSafeScheme(
       kChromeResourceScheme);
   return 0;
 }
 
 void CastBrowserMainParts::PreMainMessageLoopRun() {
   scoped_refptr<PrefRegistrySimple> pref_registry(new PrefRegistrySimple());
   metrics::RegisterPrefs(pref_registry.get());
   cast_browser_process_->SetPrefService(
       PrefServiceHelper::CreatePrefService(pref_registry.get()));
 
 #if defined(OS_ANDROID)
   ::media::SetMediaClientAndroid(new media::CastMediaClientAndroid());
 #endif  // defined(OS_ANDROID)
 
   cast_browser_process_->SetConnectivityChecker(
       ConnectivityChecker::Create(
           content::BrowserThread::GetMessageLoopProxyForThread(
               content::BrowserThread::IO)));
 
   cast_browser_process_->SetNetLog(net_log_.get());
 
   url_request_context_factory_->InitializeOnUIThread(net_log_.get());
 
   cast_browser_process_->SetBrowserContext(
-      make_scoped_ptr(new CastBrowserContext(url_request_context_factory_)));
+      base::WrapUnique(new CastBrowserContext(url_request_context_factory_)));
   cast_browser_process_->SetMetricsServiceClient(
       metrics::CastMetricsServiceClient::Create(
           content::BrowserThread::GetBlockingPool(),
           cast_browser_process_->pref_service(),
           cast_browser_process_->browser_context()->GetRequestContext()));
 
   if (!PlatformClientAuth::Initialize())
     LOG(ERROR) << "PlatformClientAuth::Initialize failed.";
 
-  cast_browser_process_->SetRemoteDebuggingServer(make_scoped_ptr(
-      new RemoteDebuggingServer(cast_browser_process_->browser_client()->
-          EnableRemoteDebuggingImmediately())));
+  cast_browser_process_->SetRemoteDebuggingServer(base::WrapUnique(
+      new RemoteDebuggingServer(cast_browser_process_->browser_client()
+                                    ->EnableRemoteDebuggingImmediately())));
 
 #if defined(USE_AURA) && !defined(DISABLE_DISPLAY)
   // TODO(halliwell) move audio builds to use ozone_platform_cast, then can
   // simplify this by removing DISABLE_DISPLAY condition.  Should then also
   // assert(ozone_platform_cast) in BUILD.gn where it depends on //ui/ozone.
   video_plane_controller_.reset(
       new media::VideoPlaneController(GetMediaTaskRunner()));
   cast_browser_process_->cast_screen()->SetDisplayResizeCallback(
       base::Bind(&media::VideoPlaneController::SetGraphicsPlaneResolution,
                  base::Unretained(video_plane_controller_.get())));
@@ skipping 75 matching lines @@
 void CastBrowserMainParts::PostDestroyThreads() {
 #if !defined(OS_ANDROID)
   media_resource_tracker_->FinalizeAndDestroy();
   media_resource_tracker_ = nullptr;
   media_pipeline_backend_manager_.reset();
 #endif
 }
 
 }  // namespace shell
 }  // namespace chromecast