Convert //content/browser from scoped_ptr to std::unique_ptr

content/browser/mojo/mojo_shell_context.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 "content/browser/mojo/mojo_shell_context.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/path_service.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "components/profile_service/profile_app.h"
 #include "content/browser/gpu/gpu_process_host.h"
 #include "content/browser/mojo/constants.h"
 #include "content/common/gpu_process_launch_causes.h"
 #include "content/common/mojo/current_thread_loader.h"
 #include "content/common/mojo/mojo_shell_connection_impl.h"
 #include "content/common/mojo/static_loader.h"
@@ skipping 205 matching lines @@
   }
 
  private:
   MojoShellContext* shell_context_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(Proxy);
 };
 
 // static
-base::LazyInstance<scoped_ptr<MojoShellContext::Proxy>>
+base::LazyInstance<std::unique_ptr<MojoShellContext::Proxy>>
     MojoShellContext::proxy_ = LAZY_INSTANCE_INITIALIZER;
 
 void MojoShellContext::SetApplicationsForTest(
     const StaticApplicationMap* apps) {
   g_applications_for_test = apps;
 }
 
 MojoShellContext::MojoShellContext(
     scoped_refptr<base::SingleThreadTaskRunner> file_thread,
     scoped_refptr<base::SingleThreadTaskRunner> db_thread) {
   proxy_.Get().reset(new Proxy(this));
 
   scoped_refptr<base::SingleThreadTaskRunner> file_task_runner =
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE);
-  scoped_ptr<mojo::shell::NativeRunnerFactory> native_runner_factory(
+  std::unique_ptr<mojo::shell::NativeRunnerFactory> native_runner_factory(
       new mojo::shell::InProcessNativeRunnerFactory(
           BrowserThread::GetBlockingPool()));
   manifest_provider_.reset(new BuiltinManifestProvider);
   catalog_.reset(new catalog::Factory(file_task_runner.get(), nullptr,
                                       manifest_provider_.get()));
   shell_.reset(new mojo::shell::Shell(std::move(native_runner_factory),
                                       catalog_->TakeShellClient()));
   shell_->set_default_loader(
-      scoped_ptr<mojo::shell::Loader>(new DefaultLoader));
+      std::unique_ptr<mojo::shell::Loader>(new DefaultLoader));
 
   StaticApplicationMap apps;
   GetContentClient()->browser()->RegisterInProcessMojoApplications(&apps);
   if (g_applications_for_test) {
     // Add testing apps to the map, potentially overwriting whatever the
     // browser client registered.
     for (const auto& entry : *g_applications_for_test)
       apps[entry.first] = entry.second;
   }
   for (const auto& entry : apps) {
-    shell_->SetLoaderForName(
-        make_scoped_ptr(new StaticLoader(entry.second)), entry.first);
+    shell_->SetLoaderForName(base::WrapUnique(new StaticLoader(entry.second)),
+                             entry.first);
   }
 
   ContentBrowserClient::OutOfProcessMojoApplicationMap sandboxed_apps;
   GetContentClient()
       ->browser()
       ->RegisterOutOfProcessMojoApplications(&sandboxed_apps);
   for (const auto& app : sandboxed_apps) {
-    shell_->SetLoaderForName(
-        make_scoped_ptr(
-            new UtilityProcessLoader(app.second, true /* use_sandbox */)),
-        app.first);
+    shell_->SetLoaderForName(base::WrapUnique(new UtilityProcessLoader(
+                                 app.second, true /* use_sandbox */)),
+                             app.first);
   }
 
   ContentBrowserClient::OutOfProcessMojoApplicationMap unsandboxed_apps;
   GetContentClient()
       ->browser()
       ->RegisterUnsandboxedOutOfProcessMojoApplications(&unsandboxed_apps);
   for (const auto& app : unsandboxed_apps) {
-    shell_->SetLoaderForName(
-        make_scoped_ptr(
-            new UtilityProcessLoader(app.second, false /* use_sandbox */)),
-        app.first);
+    shell_->SetLoaderForName(base::WrapUnique(new UtilityProcessLoader(
+                                 app.second, false /* use_sandbox */)),
+                             app.first);
   }
 
 #if (ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
-  shell_->SetLoaderForName(make_scoped_ptr(new GpuProcessLoader), "mojo:media");
+  shell_->SetLoaderForName(base::WrapUnique(new GpuProcessLoader),
+                           "mojo:media");
 #endif
 
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kMojoLocalStorage)) {
-    base::Callback<scoped_ptr<mojo::ShellClient>()> profile_callback =
+    base::Callback<std::unique_ptr<mojo::ShellClient>()> profile_callback =
         base::Bind(&profile::CreateProfileApp, file_thread, db_thread);
     shell_->SetLoaderForName(
-        make_scoped_ptr(new CurrentThreadLoader(profile_callback)),
+        base::WrapUnique(new CurrentThreadLoader(profile_callback)),
         "mojo:profile");
   }
 
   if (!IsRunningInMojoShell()) {
     MojoShellConnection::Create(
         shell_->InitInstanceForEmbedder(kBrowserMojoApplicationName),
         false /* is_external */);
   }
 }
 
@@ skipping 15 matching lines @@
                                      std::move(exposed_services), callback);
 }
 
 void MojoShellContext::ConnectToApplicationOnOwnThread(
     const std::string& user_id,
     const std::string& name,
     const std::string& requestor_name,
     mojo::shell::mojom::InterfaceProviderRequest request,
     mojo::shell::mojom::InterfaceProviderPtr exposed_services,
     const mojo::shell::mojom::Connector::ConnectCallback& callback) {
-  scoped_ptr<mojo::shell::ConnectParams> params(new mojo::shell::ConnectParams);
+  std::unique_ptr<mojo::shell::ConnectParams> params(
+      new mojo::shell::ConnectParams);
   mojo::Identity source_id(requestor_name, user_id);
   params->set_source(source_id);
   params->set_target(mojo::Identity(name, user_id));
   params->set_remote_interfaces(std::move(request));
   params->set_local_interfaces(std::move(exposed_services));
   params->set_connect_callback(callback);
   shell_->Connect(std::move(params));
 }
 
 }  // namespace content