Convert //components/mus from scoped_ptr to std::unique_ptr

components/mus/mus_app.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 "components/mus/mus_app.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/command_line.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/platform_thread.h"
 #include "build/build_config.h"
 #include "components/mus/common/args.h"
 #include "components/mus/gles2/gpu_impl.h"
 #include "components/mus/ws/display.h"
 #include "components/mus/ws/display_binding.h"
 #include "components/mus/ws/display_manager.h"
 #include "components/mus/ws/user_display_manager.h"
 #include "components/mus/ws/window_server.h"
@@ skipping 34 matching lines @@
 
 const char kResourceFileStrings[] = "mus_app_resources_strings.pak";
 const char kResourceFile100[] = "mus_app_resources_100.pak";
 const char kResourceFile200[] = "mus_app_resources_200.pak";
 
 }  // namespace
 
 // TODO(sky): this is a pretty typical pattern, make it easier to do.
 struct MandolineUIServicesApp::PendingRequest {
   shell::Connection* connection;
-  scoped_ptr<mojo::InterfaceRequest<mojom::WindowTreeFactory>> wtf_request;
+  std::unique_ptr<mojo::InterfaceRequest<mojom::WindowTreeFactory>> wtf_request;
 };
 
 struct MandolineUIServicesApp::UserState {
-  scoped_ptr<ws::WindowTreeHostFactory> window_tree_host_factory;
+  std::unique_ptr<ws::WindowTreeHostFactory> window_tree_host_factory;
 };
 
 MandolineUIServicesApp::MandolineUIServicesApp() : test_config_(false) {}
 
 MandolineUIServicesApp::~MandolineUIServicesApp() {
   // Destroy |window_server_| first, since it depends on |event_source_|.
   // WindowServer (or more correctly its Displays) may have state that needs to
   // be destroyed before GpuState as well.
   window_server_.reset();
 
@@ skipping 25 matching lines @@
   rb.AddDataPackFromFile(loader.ReleaseFile(kResourceFile200),
                          ui::SCALE_FACTOR_200P);
 }
 
 MandolineUIServicesApp::UserState* MandolineUIServicesApp::GetUserState(
     shell::Connection* connection) {
   const ws::UserId& user_id = connection->GetRemoteIdentity().user_id();
   auto it = user_id_to_user_state_.find(user_id);
   if (it != user_id_to_user_state_.end())
     return it->second.get();
-  user_id_to_user_state_[user_id] = make_scoped_ptr(new UserState);
+  user_id_to_user_state_[user_id] = base::WrapUnique(new UserState);
   return user_id_to_user_state_[user_id].get();
 }
 
 void MandolineUIServicesApp::AddUserIfNecessary(shell::Connection* connection) {
   window_server_->user_id_tracker()->AddUserId(
       connection->GetRemoteIdentity().user_id());
 }
 
 void MandolineUIServicesApp::Initialize(shell::Connector* connector,
                                         const shell::Identity& identity,
@@ skipping 100 matching lines @@
     mojom::WindowManagerFactoryServiceRequest request) {
   AddUserIfNecessary(connection);
   window_server_->window_manager_factory_registry()->Register(
       connection->GetRemoteIdentity().user_id(), std::move(request));
 }
 
 void MandolineUIServicesApp::Create(Connection* connection,
                                     mojom::WindowTreeFactoryRequest request) {
   AddUserIfNecessary(connection);
   if (!window_server_->display_manager()->has_displays()) {
-    scoped_ptr<PendingRequest> pending_request(new PendingRequest);
+    std::unique_ptr<PendingRequest> pending_request(new PendingRequest);
     pending_request->connection = connection;
     pending_request->wtf_request.reset(
         new mojo::InterfaceRequest<mojom::WindowTreeFactory>(
             std::move(request)));
     pending_requests_.push_back(std::move(pending_request));
     return;
   }
   AddUserIfNecessary(connection);
   new ws::WindowTreeFactory(
       window_server_.get(), connection->GetRemoteIdentity().user_id(),
@@ skipping 19 matching lines @@
   new ws::WindowServerTestImpl(window_server_.get(), std::move(request));
 }
 
 void MandolineUIServicesApp::Create(shell::Connection* connection,
                                     mojom::GpuRequest request) {
   DCHECK(platform_display_init_params_.gpu_state);
   new GpuImpl(std::move(request), platform_display_init_params_.gpu_state);
 }
 
 }  // namespace mus