Convert //ash from scoped_ptr to std::unique_ptr

ash/display/display_manager.h

 // Copyright (c) 2012 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 ASH_DISPLAY_DISPLAY_MANAGER_H_
 #define ASH_DISPLAY_DISPLAY_MANAGER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "ash/ash_export.h"
 #include "ash/display/display_info.h"
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "ui/display/manager/display_layout.h"
 #include "ui/gfx/display.h"
 
 #if defined(OS_CHROMEOS)
 #include "ui/display/chromeos/display_configurator.h"
 #endif
 
 namespace aura {
 class Window;
@@ skipping 101 matching lines @@
   void RefreshFontParams();
 
   // Returns the display layout used for current displays.
   const display::DisplayLayout& GetCurrentDisplayLayout() const;
 
   // Returns the current display list.
   display::DisplayIdList GetCurrentDisplayIdList() const;
 
   // Sets the layout for the current display pair. The |layout| specifies
   // the locaion of the displays relative to their parents.
-  void SetLayoutForCurrentDisplays(scoped_ptr<display::DisplayLayout> layout);
+  void SetLayoutForCurrentDisplays(
+      std::unique_ptr<display::DisplayLayout> layout);
 
   // Returns display for given |id|;
   const gfx::Display& GetDisplayForId(int64_t id) const;
 
   // Finds the display that contains |point| in screeen coordinates.
   // Returns invalid display if there is no display that can satisfy
   // the condition.
   const gfx::Display& FindDisplayContainingPoint(
       const gfx::Point& point_in_screen) const;
 
@@ skipping 158 matching lines @@
   // Update the bounds of the display given by |display_id|.
   bool UpdateDisplayBounds(int64_t display_id, const gfx::Rect& new_bounds);
 
   // Creates mirror window asynchronously if the software mirror mode
   // is enabled.
   void CreateMirrorWindowAsyncIfAny();
 
   // Creates a MouseWarpController for the current display
   // configuration. |drag_source| is the window where dragging
   // started, or nullptr otherwise.
-  scoped_ptr<MouseWarpController> CreateMouseWarpController(
+  std::unique_ptr<MouseWarpController> CreateMouseWarpController(
       aura::Window* drag_source) const;
 
   // Create a screen instance to be used during shutdown.
   void CreateScreenForShutdown() const;
 
   // A unit test may change the internal display id (which never happens on
   // a real device). This will update the mode list for internal display
   // for this test scenario.
   void UpdateInternalDisplayModeListForTest();
 
@@ skipping 71 matching lines @@
                           display::DisplayList* display_list,
                           std::vector<int64_t>* updated_ids);
 
   // Apply the display placement to the display layout.
   // Returns true if the display bounds has been updated.
   bool ApplyDisplayPlacement(const display::DisplayPlacement& placement,
                              display::DisplayList* display_list);
 
   Delegate* delegate_;  // not owned.
 
-  scoped_ptr<ScreenAsh> screen_;
+  std::unique_ptr<ScreenAsh> screen_;
 
-  scoped_ptr<DisplayLayoutStore> layout_store_;
+  std::unique_ptr<DisplayLayoutStore> layout_store_;
 
   int64_t first_display_id_;
 
   // List of current active displays.
   display::DisplayList active_display_list_;
 
   int num_connected_displays_;
 
   bool force_bounds_changed_;
 
@@ skipping 25 matching lines @@
   bool unified_desktop_enabled_;
 
   base::WeakPtrFactory<DisplayManager> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DisplayManager);
 };
 
 }  // namespace ash
 
 #endif  // ASH_DISPLAY_DISPLAY_MANAGER_H_