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

components/mus/ws/display.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 "components/mus/ws/display.h"
 
 #include "base/debug/debugger.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/mus/common/types.h"
 #include "components/mus/ws/display_binding.h"
@@ skipping 43 matching lines @@
   // Destroy any trees, which triggers destroying the WindowManagerState. Copy
   // off the WindowManagerStates as destruction mutates
   // |window_manager_state_map_|.
   std::set<WindowManagerState*> states;
   for (auto& pair : window_manager_state_map_)
     states.insert(pair.second.get());
   for (WindowManagerState* state : states)
     window_server_->DestroyTree(state->tree());
 }
 
-void Display::Init(scoped_ptr<DisplayBinding> binding) {
+void Display::Init(std::unique_ptr<DisplayBinding> binding) {
   init_called_ = true;
   binding_ = std::move(binding);
   display_manager()->AddDisplay(this);
   InitWindowManagersIfNecessary();
 }
 
 DisplayManager* Display::display_manager() {
   return window_server_->display_manager();
 }
 
@@ skipping 168 matching lines @@
 void Display::SetTitle(const mojo::String& title) {
   platform_display_->SetTitle(title.To<base::string16>());
 }
 
 void Display::InitWindowManagersIfNecessary() {
   if (!init_called_ || !root_)
     return;
 
   display_manager()->OnDisplayAcceleratedWidgetAvailable(this);
   if (binding_) {
-    scoped_ptr<WindowManagerState> wms_ptr(new WindowManagerState(
+    std::unique_ptr<WindowManagerState> wms_ptr(new WindowManagerState(
         this, platform_display_.get(), top_level_surface_id_));
     WindowManagerState* wms = wms_ptr.get();
     // For this case we never create additional WindowManagerStates, so any
     // id works.
     window_manager_state_map_[shell::mojom::kRootUserID] = std::move(wms_ptr);
     wms->tree_ = binding_->CreateWindowTree(wms->root());
   } else {
     CreateWindowManagerStatesFromRegistry();
   }
 }
 
 void Display::CreateWindowManagerStatesFromRegistry() {
   std::vector<WindowManagerFactoryService*> services =
       window_server_->window_manager_factory_registry()->GetServices();
   for (WindowManagerFactoryService* service : services) {
     if (service->window_manager_factory())
       CreateWindowManagerStateFromService(service);
   }
 }
 
 void Display::CreateWindowManagerStateFromService(
     WindowManagerFactoryService* service) {
-  scoped_ptr<WindowManagerState> wms_ptr(
+  std::unique_ptr<WindowManagerState> wms_ptr(
       new WindowManagerState(this, platform_display_.get(),
                              top_level_surface_id_, service->user_id()));
   WindowManagerState* wms = wms_ptr.get();
   window_manager_state_map_[service->user_id()] = std::move(wms_ptr);
   wms->tree_ = window_server_->CreateTreeForWindowManager(
       this, service->window_manager_factory(), wms->root(), service->user_id());
   if (!binding_) {
     const bool is_active =
         service->user_id() == window_server_->user_id_tracker()->active_id();
     wms->root()->SetVisible(is_active);
@@ skipping 194 matching lines @@
   DCHECK_EQ(0u, window_manager_state_map_.count(id));
 }
 
 void Display::OnWindowManagerFactorySet(WindowManagerFactoryService* service) {
   if (!binding_)
     CreateWindowManagerStateFromService(service);
 }
 
 }  // namespace ws
 }  // namespace mus