Convert //ash from scoped_ptr to std::unique_ptr

ash/wm/workspace/workspace_window_resizer.cc

 // 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.
 
 #include "ash/wm/workspace/workspace_window_resizer.h"
 
 #include <algorithm>
 #include <cmath>
 #include <utility>
 #include <vector>
 
 #include "ash/display/window_tree_host_manager.h"
 #include "ash/metrics/user_metrics_recorder.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/default_window_resizer.h"
 #include "ash/wm/dock/docked_window_layout_manager.h"
 #include "ash/wm/dock/docked_window_resizer.h"
 #include "ash/wm/drag_window_resizer.h"
 #include "ash/wm/panels/panel_window_resizer.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/wm_event.h"
 #include "ash/wm/workspace/phantom_window_controller.h"
 #include "ash/wm/workspace/two_step_edge_cycler.h"
 #include "base/command_line.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/base/hit_test.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/transform.h"
 #include "ui/wm/core/coordinate_conversion.h"
 #include "ui/wm/core/window_util.h"
 #include "ui/wm/public/window_types.h"
 
 namespace ash {
 
-scoped_ptr<WindowResizer> CreateWindowResizer(
+std::unique_ptr<WindowResizer> CreateWindowResizer(
     aura::Window* window,
     const gfx::Point& point_in_parent,
     int window_component,
     aura::client::WindowMoveSource source) {
   DCHECK(window);
   wm::WindowState* window_state = wm::GetWindowState(window);
   // No need to return a resizer when the window cannot get resized or when a
   // resizer already exists for this window.
   if ((!window_state->CanResize() && window_component != HTCAPTION) ||
       window_state->drag_details()) {
-    return scoped_ptr<WindowResizer>();
+    return std::unique_ptr<WindowResizer>();
   }
 
   if (window_component == HTCAPTION && !window_state->can_be_dragged())
-    return scoped_ptr<WindowResizer>();
+    return std::unique_ptr<WindowResizer>();
 
   // TODO(varkha): The chaining of window resizers causes some of the logic
   // to be repeated and the logic flow difficult to control. With some windows
   // classes using reparenting during drag operations it becomes challenging to
   // implement proper transition from one resizer to another during or at the
   // end of the drag. This also causes http://crbug.com/247085.
   // It seems the only thing the panel or dock resizer needs to do is notify the
   // layout manager when a docked window is being dragged. We should have a
   // better way of doing this, perhaps by having a way of observing drags or
   // having a generic drag window wrapper which informs a layout manager that a
   // drag has started or stopped.
   // It may be possible to refactor and eliminate chaining.
   WindowResizer* window_resizer = NULL;
 
   if (!window_state->IsNormalOrSnapped() && !window_state->IsDocked())
-    return scoped_ptr<WindowResizer>();
+    return std::unique_ptr<WindowResizer>();
 
   int bounds_change = WindowResizer::GetBoundsChangeForWindowComponent(
       window_component);
   if (bounds_change == WindowResizer::kBoundsChangeDirection_None)
-    return scoped_ptr<WindowResizer>();
+    return std::unique_ptr<WindowResizer>();
 
   window_state->CreateDragDetails(window, point_in_parent, window_component,
       source);
   if (window->parent() &&
       (window->parent()->id() == kShellWindowId_DefaultContainer ||
        window->parent()->id() == kShellWindowId_DockedContainer ||
        window->parent()->id() == kShellWindowId_PanelContainer)) {
     window_resizer = WorkspaceWindowResizer::Create(
         window_state, std::vector<aura::Window*>());
   } else {
     window_resizer = DefaultWindowResizer::Create(window_state);
   }
   window_resizer = DragWindowResizer::Create(window_resizer, window_state);
   if (window->type() == ui::wm::WINDOW_TYPE_PANEL)
     window_resizer = PanelWindowResizer::Create(window_resizer, window_state);
   if (window_resizer && window->parent() &&
       !::wm::GetTransientParent(window) &&
       (window->parent()->id() == kShellWindowId_DefaultContainer ||
        window->parent()->id() == kShellWindowId_DockedContainer ||
        window->parent()->id() == kShellWindowId_PanelContainer)) {
     window_resizer = DockedWindowResizer::Create(window_resizer, window_state);
   }
-  return make_scoped_ptr<WindowResizer>(window_resizer);
+  return base::WrapUnique<WindowResizer>(window_resizer);
 }
 
 namespace {
 
 // Snapping distance used instead of WorkspaceWindowResizer::kScreenEdgeInset
 // when resizing a window using touchscreen.
 const int kScreenEdgeInsetForTouchDrag = 32;
 
 // Current instance for use by the WorkspaceWindowResizerTest.
 WorkspaceWindowResizer* instance = NULL;
@@ skipping 940 matching lines @@
          snapped_type == wm::WINDOW_STATE_TYPE_RIGHT_SNAPPED);
   gfx::Rect snapped_bounds = ScreenUtil::GetDisplayWorkAreaBoundsInParent(
       GetTarget());
   if (snapped_type == wm::WINDOW_STATE_TYPE_RIGHT_SNAPPED)
     snapped_bounds.set_x(snapped_bounds.right() - bounds_in_parent.width());
   snapped_bounds.set_width(bounds_in_parent.width());
   return bounds_in_parent == snapped_bounds;
 }
 
 }  // namespace ash