Enables docked windows by default

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>
@@ skipping 77 matching lines @@
         window, point_in_parent, window_component, source);
   }
   if (window_resizer) {
     window_resizer = internal::DragWindowResizer::Create(
         window_resizer, window, point_in_parent, window_component, source);
   }
   if (window_resizer && window->type() == aura::client::WINDOW_TYPE_PANEL) {
     window_resizer = PanelWindowResizer::Create(
         window_resizer, window, point_in_parent, window_component, source);
   }
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kAshEnableDockedWindows) &&
+  if (switches::UseDockedWindows() &&
       window_resizer && window->parent() &&
       !window->transient_parent() &&
       (window->parent()->id() == internal::kShellWindowId_DefaultContainer ||
        window->parent()->id() == internal::kShellWindowId_DockedContainer ||
        window->parent()->id() == internal::kShellWindowId_PanelContainer)) {
     window_resizer = internal::DockedWindowResizer::Create(
         window_resizer, window, point_in_parent, window_component, source);
   }
   window_state->set_window_resizer_(window_resizer);
   return make_scoped_ptr<WindowResizer>(window_resizer);
 }
 
 namespace internal {
 
 namespace {
 
 // Snapping distance used instead of WorkspaceWindowResizer::kScreenEdgeInset
 // when resizing a window using touchscreen.
 const int kScreenEdgeInsetForTouchResize = 32;
 
-// Returns true if the window should stick to the edge.
-bool ShouldStickToEdge(int distance_from_edge, int sticky_size) {
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kAshEnableStickyEdges) ||
-      CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kAshEnableDockedWindows)) {
-    return distance_from_edge < 0 &&
-           distance_from_edge > -sticky_size;
-  }
-  return distance_from_edge < sticky_size &&
-         distance_from_edge > -sticky_size * 2;
-}
-
 // Returns the coordinate along the secondary axis to snap to.
 int CoordinateAlongSecondaryAxis(SecondaryMagnetismEdge edge,
                                  int leading,
                                  int trailing,
                                  int none) {
   switch (edge) {
     case SECONDARY_MAGNETISM_EDGE_LEADING:
       return leading;
     case SECONDARY_MAGNETISM_EDGE_TRAILING:
       return trailing;
@@ skipping 123 matching lines @@
 
 // static
 const int WorkspaceWindowResizer::kMinOnscreenHeight = 32;
 
 // static
 const int WorkspaceWindowResizer::kScreenEdgeInset = 8;
 
 // static
 const int WorkspaceWindowResizer::kStickyDistancePixels = 64;
 
+// static
+WorkspaceWindowResizer* WorkspaceWindowResizer::instance_ = NULL;
+
 // Represents the width or height of a window with constraints on its minimum
 // and maximum size. 0 represents a lack of a constraint.
 class WindowSize {
  public:
   WindowSize(int size, int min, int max)
       : size_(size),
         min_(min),
         max_(max) {
     // Grow the min/max bounds to include the starting size.
     if (is_underflowing())
@@ skipping 52 matching lines @@
 
  private:
   int size_;
   int min_;
   int max_;
 };
 
 WorkspaceWindowResizer::~WorkspaceWindowResizer() {
   Shell* shell = Shell::GetInstance();
   shell->cursor_manager()->UnlockCursor();
+  if (instance_ == this)
+    instance_ = NULL;
 }
 
 // static
 WorkspaceWindowResizer* WorkspaceWindowResizer::Create(
     aura::Window* window,
     const gfx::Point& location_in_parent,
     int window_component,
     aura::client::WindowMoveSource source,
     const std::vector<aura::Window*>& attached_windows) {
   Details details(window, location_in_parent, window_component, source);
   return details.is_resizable ?
       new WorkspaceWindowResizer(details, attached_windows) : NULL;
 }
 
 void WorkspaceWindowResizer::Drag(const gfx::Point& location_in_parent,
                                   int event_flags) {
   last_mouse_location_ = location_in_parent;
 
   int sticky_size;
   if (event_flags & ui::EF_CONTROL_DOWN) {
     sticky_size = 0;
   } else if (CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kAshEnableStickyEdges) ||
-      CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kAshEnableDockedWindows)) {
+      switches::kAshEnableStickyEdges)) {
     sticky_size = kStickyDistancePixels;
   } else if ((details_.bounds_change & kBoundsChange_Resizes) &&
       details_.source == aura::client::WINDOW_MOVE_SOURCE_TOUCH) {
     sticky_size = kScreenEdgeInsetForTouchResize;
   } else {
     sticky_size = kScreenEdgeInset;
   }
   // |bounds| is in |window()->parent()|'s coordinates.
   gfx::Rect bounds = CalculateBoundsForDrag(details_, location_in_parent);
   if (window_state()->IsNormalShowState())
@@ skipping 152 matching lines @@
     int initial_size = PrimaryAxisSize(attached_windows_[i]->bounds().size());
     initial_size_.push_back(initial_size);
     // If current size is smaller than the min, use the current size as the min.
     // This way we don't snap on resize.
     int min_size = std::min(initial_size,
                             std::max(PrimaryAxisSize(min), kMinOnscreenSize));
     total_min_ += min_size;
     total_initial_size_ += initial_size;
     total_available += std::max(min_size, initial_size) - min_size;
   }
+  instance_ = this;
 }
 
 gfx::Rect WorkspaceWindowResizer::GetFinalBounds(
     const gfx::Rect& bounds) const {
   if (snap_phantom_window_controller_.get() &&
       snap_phantom_window_controller_->IsShowing()) {
     return snap_phantom_window_controller_->bounds_in_screen();
   }
   return bounds;
 }
@@ skipping 256 matching lines @@
   if (details_.window_component == HTRIGHT) {
     bounds->set_width(std::min(bounds->width(),
                                work_area.right() - total_min_ - bounds->x()));
   } else {
     DCHECK_EQ(HTBOTTOM, details_.window_component);
     bounds->set_height(std::min(bounds->height(),
                                 work_area.bottom() - total_min_ - bounds->y()));
   }
 }
 
+bool WorkspaceWindowResizer::ShouldStickToEdge(int distance_from_edge,
+                                               int sticky_size) const {
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kAshEnableStickyEdges)) {
+    int snapping_distance = 0;
+    if ((details_.bounds_change & kBoundsChange_Resizes) &&
+      details_.source == aura::client::WINDOW_MOVE_SOURCE_TOUCH) {
+      snapping_distance = sticky_size / 2;
+    }
+    return distance_from_edge < snapping_distance &&
+           distance_from_edge > -sticky_size;
+  }
+  return distance_from_edge < sticky_size &&
+         distance_from_edge > -sticky_size * 2;
+}
+
 bool WorkspaceWindowResizer::StickToWorkAreaOnMove(
     const gfx::Rect& work_area,
     int sticky_size,
     gfx::Rect* bounds) const {
   const int left_edge = work_area.x();
   const int right_edge = work_area.right();
   const int top_edge = work_area.y();
   const int bottom_edge = work_area.bottom();
   bool updated = false;
   if (ShouldStickToEdge(bounds->x() - left_edge, sticky_size)) {
@@ skipping 178 matching lines @@
     if (!dock_layout_->is_dragged_window_docked())
       dock_layout_->DockDraggedWindow(window());
   } else {
     if (dock_layout_->is_dragged_window_docked())
       dock_layout_->UndockDraggedWindow();
   }
 }
 
 }  // namespace internal
 }  // namespace ash