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

components/mus/ws/window_server.h

 // 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.
 
 #ifndef COMPONENTS_MUS_WS_WINDOW_SERVER_H_
 #define COMPONENTS_MUS_WS_WINDOW_SERVER_H_
 
 #include <stdint.h>
 
 #include <map>
+#include <memory>
 #include <vector>
 
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "components/mus/public/interfaces/window_manager_factory.mojom.h"
 #include "components/mus/public/interfaces/window_tree.mojom.h"
 #include "components/mus/public/interfaces/window_tree_host.mojom.h"
 #include "components/mus/surfaces/surfaces_state.h"
 #include "components/mus/ws/display.h"
 #include "components/mus/ws/display_manager_delegate.h"
 #include "components/mus/ws/ids.h"
 #include "components/mus/ws/operation.h"
 #include "components/mus/ws/server_window_delegate.h"
 #include "components/mus/ws/server_window_observer.h"
@@ skipping 41 matching lines @@
       const std::map<std::string, std::vector<uint8_t>>& properties);
 
   // Returns the id for the next WindowTree.
   ConnectionSpecificId GetAndAdvanceNextConnectionId();
 
   // See description of WindowTree::Embed() for details. This assumes
   // |transport_window_id| is valid.
   WindowTree* EmbedAtWindow(ServerWindow* root,
                             const UserId& user_id,
                             mojom::WindowTreeClientPtr client,
-                            scoped_ptr<AccessPolicy> access_policy);
+                            std::unique_ptr<AccessPolicy> access_policy);
 
   // Adds |tree_impl_ptr| to the set of known trees. Use DestroyTree() to
   // destroy the tree.
-  WindowTree* AddTree(scoped_ptr<WindowTree> tree_impl_ptr,
-                      scoped_ptr<WindowTreeBinding> binding,
+  WindowTree* AddTree(std::unique_ptr<WindowTree> tree_impl_ptr,
+                      std::unique_ptr<WindowTreeBinding> binding,
                       mojom::WindowTreePtr tree_ptr);
   WindowTree* CreateTreeForWindowManager(Display* display,
                                          mojom::WindowManagerFactory* factory,
                                          ServerWindow* root,
                                          const UserId& user_id);
   // Invoked when a WindowTree's connection encounters an error.
   void DestroyTree(WindowTree* tree);
 
   // Returns the connection by id.
   WindowTree* GetTreeWithId(ConnectionSpecificId connection_id);
@@ skipping 96 matching lines @@
   void ProcessWillChangeWindowPredefinedCursor(ServerWindow* window,
                                                int32_t cursor_id);
 
   // Sets a callback to be called whenever a ServerWindow is scheduled for
   // a [re]paint. This should only be called in a test configuration.
   void SetPaintCallback(const base::Callback<void(ServerWindow*)>& callback);
 
  private:
   friend class Operation;
 
-  using WindowTreeMap = std::map<ConnectionSpecificId, scoped_ptr<WindowTree>>;
+  using WindowTreeMap =
+      std::map<ConnectionSpecificId, std::unique_ptr<WindowTree>>;
 
   struct InFlightWindowManagerChange {
     // Identifies the client that initiated the change.
     ConnectionSpecificId connection_id;
 
     // Change id supplied by the client.
     uint32_t client_change_id;
   };
 
   using InFlightWindowManagerChangeMap =
@@ skipping 70 matching lines @@
   UserIdTracker user_id_tracker_;
 
   WindowServerDelegate* delegate_;
 
   // State for rendering into a Surface.
   scoped_refptr<mus::SurfacesState> surfaces_state_;
 
   // ID to use for next WindowTree.
   ConnectionSpecificId next_connection_id_;
 
-  scoped_ptr<DisplayManager> display_manager_;
+  std::unique_ptr<DisplayManager> display_manager_;
 
   // Set of WindowTrees.
   WindowTreeMap tree_map_;
 
   // If non-null then we're processing a client operation. The Operation is
   // not owned by us (it's created on the stack by WindowTree).
   Operation* current_operation_;
 
   bool in_destructor_;
 
   // Maps from window manager change id to the client that initiated the
   // request.
   InFlightWindowManagerChangeMap in_flight_wm_change_map_;
 
   // Next id supplied to the window manager.
   uint32_t next_wm_change_id_;
 
   base::Callback<void(ServerWindow*)> window_paint_callback_;
 
   WindowManagerFactoryRegistry window_manager_factory_registry_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowServer);
 };
 
 }  // namespace ws
 }  // namespace mus
 
 #endif  // COMPONENTS_MUS_WS_WINDOW_SERVER_H_