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

components/mus/ws/window_server.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/ws/window_server.h"
 
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/stl_util.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/operation.h"
 #include "components/mus/ws/server_window.h"
 #include "components/mus/ws/window_coordinate_conversions.h"
 #include "components/mus/ws/window_manager_access_policy.h"
 #include "components/mus/ws/window_manager_factory_service.h"
 #include "components/mus/ws/window_manager_state.h"
@@ skipping 46 matching lines @@
 ConnectionSpecificId WindowServer::GetAndAdvanceNextConnectionId() {
   const ConnectionSpecificId id = next_connection_id_++;
   DCHECK_LT(id, next_connection_id_);
   return id;
 }
 
 WindowTree* WindowServer::EmbedAtWindow(
     ServerWindow* root,
     const UserId& user_id,
     mojom::WindowTreeClientPtr client,
-    scoped_ptr<AccessPolicy> access_policy) {
-  scoped_ptr<WindowTree> tree_ptr(
+    std::unique_ptr<AccessPolicy> access_policy) {
+  std::unique_ptr<WindowTree> tree_ptr(
       new WindowTree(this, user_id, root, std::move(access_policy)));
   WindowTree* tree = tree_ptr.get();
 
   mojom::WindowTreePtr window_tree_ptr;
   mojom::WindowTreeRequest window_tree_request = GetProxy(&window_tree_ptr);
-  scoped_ptr<WindowTreeBinding> binding = delegate_->CreateWindowTreeBinding(
-      WindowServerDelegate::BindingType::EMBED, this, tree,
-      &window_tree_request, &client);
+  std::unique_ptr<WindowTreeBinding> binding =
+      delegate_->CreateWindowTreeBinding(
+          WindowServerDelegate::BindingType::EMBED, this, tree,
+          &window_tree_request, &client);
   if (!binding) {
     binding.reset(new ws::DefaultWindowTreeBinding(
         tree, this, std::move(window_tree_request), std::move(client)));
   }
 
   AddTree(std::move(tree_ptr), std::move(binding), std::move(window_tree_ptr));
   OnTreeMessagedClient(tree->id());
   return tree;
 }
 
-WindowTree* WindowServer::AddTree(scoped_ptr<WindowTree> tree_impl_ptr,
-                                  scoped_ptr<WindowTreeBinding> binding,
+WindowTree* WindowServer::AddTree(std::unique_ptr<WindowTree> tree_impl_ptr,
+                                  std::unique_ptr<WindowTreeBinding> binding,
                                   mojom::WindowTreePtr tree_ptr) {
   CHECK_EQ(0u, tree_map_.count(tree_impl_ptr->id()));
   WindowTree* tree = tree_impl_ptr.get();
   tree_map_[tree->id()] = std::move(tree_impl_ptr);
   tree->Init(std::move(binding), std::move(tree_ptr));
   return tree;
 }
 
 WindowTree* WindowServer::CreateTreeForWindowManager(
     Display* display,
     mojom::WindowManagerFactory* factory,
     ServerWindow* root,
     const UserId& user_id) {
   mojom::DisplayPtr display_ptr = display->ToMojomDisplay();
   mojom::WindowTreeClientPtr tree_client;
   factory->CreateWindowManager(std::move(display_ptr), GetProxy(&tree_client));
-  scoped_ptr<WindowTree> tree_ptr(new WindowTree(
-      this, user_id, root, make_scoped_ptr(new WindowManagerAccessPolicy)));
+  std::unique_ptr<WindowTree> tree_ptr(new WindowTree(
+      this, user_id, root, base::WrapUnique(new WindowManagerAccessPolicy)));
   WindowTree* tree = tree_ptr.get();
   mojom::WindowTreePtr window_tree_ptr;
   mojom::WindowTreeRequest tree_request;
-  scoped_ptr<WindowTreeBinding> binding = delegate_->CreateWindowTreeBinding(
-      WindowServerDelegate::BindingType::WINDOW_MANAGER, this, tree,
-      &tree_request, &tree_client);
+  std::unique_ptr<WindowTreeBinding> binding =
+      delegate_->CreateWindowTreeBinding(
+          WindowServerDelegate::BindingType::WINDOW_MANAGER, this, tree,
+          &tree_request, &tree_client);
   if (!binding) {
     DefaultWindowTreeBinding* default_binding = new DefaultWindowTreeBinding(
         tree_ptr.get(), this, std::move(tree_client));
     binding.reset(default_binding);
     window_tree_ptr = default_binding->CreateInterfacePtrAndBind();
   }
   AddTree(std::move(tree_ptr), std::move(binding), std::move(window_tree_ptr));
   tree->ConfigureWindowManager();
   return tree;
 }
 
 void WindowServer::DestroyTree(WindowTree* tree) {
-  scoped_ptr<WindowTree> tree_ptr;
+  std::unique_ptr<WindowTree> tree_ptr;
   {
     auto iter = tree_map_.find(tree->id());
     DCHECK(iter != tree_map_.end());
     tree_ptr = std::move(iter->second);
     tree_map_.erase(iter);
   }
 
   // Notify remaining connections so that they can cleanup.
   for (auto& pair : tree_map_)
     pair.second->OnWindowDestroyingTreeImpl(tree);
@@ skipping 524 matching lines @@
 void WindowServer::OnFirstDisplayReady() {
   delegate_->OnFirstDisplayReady();
 }
 
 void WindowServer::OnNoMoreDisplays() {
   delegate_->OnNoMoreDisplays();
 }
 
 }  // namespace ws
 }  // namespace mus