Removes the grid from ash.

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 "ash/display/display_controller.h"
 #include "ash/display/mouse_cursor_event_filter.h"
 #include "ash/screen_ash.h"
 #include "ash/shell.h"
 #include "ash/wm/coordinate_conversion.h"
 #include "ash/wm/cursor_manager.h"
 #include "ash/wm/property_util.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/workspace/phantom_window_controller.h"
 #include "ash/wm/workspace/snap_sizer.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/base/hit_test.h"
 #include "ui/compositor/layer.h"
-#include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/transform.h"
 
 namespace ash {
 namespace internal {
 
 namespace {
 
 // Duration of the animation when snapping the window into place.
 const int kSnapDurationMS = 100;
 
 // The maximum opacity of the drag phantom window.
 const float kMaxOpacity = 0.8f;
 
 // Returns true if should snap to the edge.
 bool ShouldSnapToEdge(int distance_from_edge, int grid_size) {
-  return distance_from_edge <= grid_size / 2 &&
+  return distance_from_edge < grid_size &&
       distance_from_edge > -grid_size * 2;
 }
 
 // Returns true if Ash has more than one root window.
 bool HasSecondaryRootWindow() {
   return Shell::GetAllRootWindows().size() > 1;
 }
 
 // When there are two root windows, returns one of the root windows which is not
 // |root_window|. Returns NULL if only one root window exists.
 aura::RootWindow* GetAnotherRootWindow(aura::RootWindow* root_window) {
   Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
   if (root_windows.size() < 2)
     return NULL;
   DCHECK_EQ(2U, root_windows.size());
   if (root_windows[0] == root_window)
     return root_windows[1];
   return root_windows[0];
 }
 
 }  // namespace
 
 // static
 const int WorkspaceWindowResizer::kMinOnscreenSize = 20;
 
 // static
 const int WorkspaceWindowResizer::kMinOnscreenHeight = 32;
 
+// static
+const int WorkspaceWindowResizer::kScreenEdgeInset = 8;
+
 WorkspaceWindowResizer::~WorkspaceWindowResizer() {
   Shell* shell = Shell::GetInstance();
   shell->mouse_cursor_filter()->set_mouse_warp_mode(
       MouseCursorEventFilter::WARP_ALWAYS);
   shell->mouse_cursor_filter()->HideSharedEdgeIndicator();
   shell->cursor_manager()->UnlockCursor();
 
   // Delete phantom controllers first so that they will never see the deleted
   // |layer_|.
   snap_phantom_window_controller_.reset();
@@ skipping 27 matching lines @@
                                      &location_in_parent);
   last_mouse_location_ = location_in_parent;
 
   // Do not use |location| below this point, use |location_in_parent| instead.
   // When the pointer is on |window()->GetRootWindow()|, |location| and
   // |location_in_parent| have the same value and both of them are in
   // |window()->parent()|'s coordinates, but once the pointer enters the
   // other root window, you will see an unexpected value on the former. See
   // comments in wm::GetRootWindowRelativeToWindow() for details.
 
-  int grid_size = event_flags & ui::EF_CONTROL_DOWN ?
-                  0 : ash::Shell::GetInstance()->GetGridSize();
+  int grid_size = event_flags & ui::EF_CONTROL_DOWN ? 0 : kScreenEdgeInset;
   gfx::Rect bounds =  // in |window()->parent()|'s coordinates.
-      CalculateBoundsForDrag(details_, location_in_parent, grid_size);
+      CalculateBoundsForDrag(details_, location_in_parent);
 
   if (wm::IsWindowNormal(window()))
     AdjustBoundsForMainWindow(&bounds, grid_size);
   if (bounds != window()->bounds()) {
     if (!did_move_or_resize_)
       RestackWindows();
     did_move_or_resize_ = true;
   }
 
   const bool in_original_root = (window()->GetRootWindow() == current_root);
   // Hide a phantom window for snapping if the cursor is in another root window.
   if (in_original_root)
-    UpdateSnapPhantomWindow(location_in_parent, bounds, grid_size);
+    UpdateSnapPhantomWindow(location_in_parent, bounds);
   else
     snap_phantom_window_controller_.reset();
 
   if (!attached_windows_.empty())
-    LayoutAttachedWindows(bounds, grid_size);
+    LayoutAttachedWindows(bounds);
   if (bounds != window()->bounds()) {
     bool destroyed = false;
     destroyed_ = &destroyed;
     window()->SetBounds(bounds);
     if (destroyed)
       return;
     destroyed_ = NULL;
   }
   // Show a phantom window for dragging in another root window.
   if (HasSecondaryRootWindow())
@@ skipping 10 matching lines @@
   if (!did_move_or_resize_ || details_.window_component != HTCAPTION)
     return;
 
   if (snap_type_ == SNAP_LEFT_EDGE || snap_type_ == SNAP_RIGHT_EDGE) {
     if (!GetRestoreBoundsInScreen(window()))
       SetRestoreBoundsInParent(window(), details_.initial_bounds);
     window()->SetBounds(snap_sizer_->target_bounds());
     return;
   }
 
-  int grid_size = event_flags & ui::EF_CONTROL_DOWN ?
-                  0 : ash::Shell::GetInstance()->GetGridSize();
-  gfx::Rect bounds(GetFinalBounds(window()->bounds(), grid_size));
+  gfx::Rect bounds(GetFinalBounds(window()->bounds()));
 
   // Check if the destination is another display.
   gfx::Point last_mouse_location_in_screen = last_mouse_location_;
   wm::ConvertPointToScreen(window()->parent(), &last_mouse_location_in_screen);
   const gfx::Display dst_display =
       gfx::Screen::GetDisplayNearestPoint(last_mouse_location_in_screen);
 
   if (dst_display.id() !=
       gfx::Screen::GetDisplayNearestWindow(window()->GetRootWindow()).id()) {
     // Don't animate when moving to another display.
     const gfx::Rect dst_bounds =
         ScreenAsh::ConvertRectToScreen(window()->parent(), bounds);
     window()->SetBoundsInScreen(dst_bounds, dst_display);
-    return;
   }
-
-  if (grid_size <= 1 || bounds == window()->bounds())
-    return;
-
-  if (bounds.size() != window()->bounds().size()) {
-    // Don't attempt to animate a size change.
-    window()->SetBounds(bounds);
-    return;
-  }
-
-  ui::ScopedLayerAnimationSettings scoped_setter(
-      window()->layer()->GetAnimator());
-  // Use a small duration since the grid is small.
-  scoped_setter.SetTransitionDuration(
-      base::TimeDelta::FromMilliseconds(kSnapDurationMS));
-  window()->SetBounds(bounds);
 }
 
 void WorkspaceWindowResizer::RevertDrag() {
   window()->layer()->SetOpacity(details_.initial_opacity);
   drag_phantom_window_controller_.reset();
   snap_phantom_window_controller_.reset();
   Shell::GetInstance()->mouse_cursor_filter()->HideSharedEdgeIndicator();
 
   if (!did_move_or_resize_)
     return;
@@ skipping 57 matching lines @@
 
   // Only support attaching to the right/bottom.
   DCHECK(attached_windows_.empty() ||
          (details.window_component == HTRIGHT ||
           details.window_component == HTBOTTOM));
 
   // TODO: figure out how to deal with window going off the edge.
 
   // Calculate sizes so that we can maintain the ratios if we need to resize.
   int total_available = 0;
-  int grid_size = ash::Shell::GetInstance()->GetGridSize();
   for (size_t i = 0; i < attached_windows_.size(); ++i) {
     gfx::Size min(attached_windows_[i]->delegate()->GetMinimumSize());
     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));
-    // Make sure the min size falls on the grid.
-    if (grid_size > 1 && min_size % grid_size != 0)
-      min_size = (min_size / grid_size + 1) * grid_size;
     min_size_.push_back(min_size);
     total_min_ += min_size;
     total_initial_size_ += initial_size;
     total_available += std::max(min_size, initial_size) - min_size;
   }
 
   for (size_t i = 0; i < attached_windows_.size(); ++i) {
     expand_fraction_.push_back(
           static_cast<float>(initial_size_[i]) /
           static_cast<float>(total_initial_size_));
     if (total_initial_size_ != total_min_) {
       compress_fraction_.push_back(
           static_cast<float>(initial_size_[i] - min_size_[i]) /
           static_cast<float>(total_available));
     } else {
       compress_fraction_.push_back(0.0f);
     }
   }
 }
 
 gfx::Rect WorkspaceWindowResizer::GetFinalBounds(
-    const gfx::Rect& bounds,
-    int grid_size) const {
+    const gfx::Rect& bounds) const {
   if (snap_phantom_window_controller_.get() &&
       snap_phantom_window_controller_->IsShowing()) {
     return snap_phantom_window_controller_->bounds();
   }
-  return AdjustBoundsToGrid(bounds, grid_size);
+  return bounds;
 }
 
 void WorkspaceWindowResizer::LayoutAttachedWindows(
-    const gfx::Rect& bounds,
-    int grid_size) {
+    const gfx::Rect& bounds) {
   gfx::Rect work_area(ScreenAsh::GetDisplayWorkAreaBoundsInParent(window()));
   std::vector<int> sizes;
   CalculateAttachedSizes(
       PrimaryAxisSize(details_.initial_bounds.size()),
       PrimaryAxisSize(bounds.size()),
       PrimaryAxisCoordinate(bounds.right(), bounds.bottom()),
       PrimaryAxisCoordinate(work_area.right(), work_area.bottom()),
-      grid_size,
       &sizes);
   DCHECK_EQ(attached_windows_.size(), sizes.size());
   int last = PrimaryAxisCoordinate(bounds.right(), bounds.bottom());
   for (size_t i = 0; i < attached_windows_.size(); ++i) {
     gfx::Rect attached_bounds(attached_windows_[i]->bounds());
     if (details_.window_component == HTRIGHT) {
       attached_bounds.set_x(last);
       attached_bounds.set_width(sizes[i]);
     } else {
       attached_bounds.set_y(last);
       attached_bounds.set_height(sizes[i]);
     }
     attached_windows_[i]->SetBounds(attached_bounds);
     last += sizes[i];
   }
 }
 
 void WorkspaceWindowResizer::CalculateAttachedSizes(
     int initial_size,
     int current_size,
     int start,
     int end,
-    int grid_size,
     std::vector<int>* sizes) const {
   sizes->clear();
   if (current_size < initial_size) {
     // If the primary window is sized smaller, resize the attached windows.
     int current = start;
     int delta = initial_size - current_size;
     for (size_t i = 0; i < attached_windows_.size(); ++i) {
-      int next = AlignToGrid(
-          current + initial_size_[i] + expand_fraction_[i] * delta,
-          grid_size);
-      if (i == attached_windows_.size())
-        next = end;
+      int next = current + initial_size_[i] + expand_fraction_[i] * delta;
+      if (i + 1 == attached_windows_.size())
+        next = start + total_initial_size_ + (initial_size - current_size);
       sizes->push_back(next - current);
       current = next;
     }
   } else if (start <= end - total_initial_size_) {
     // All the windows fit at their initial size; tile them horizontally.
     for (size_t i = 0; i < attached_windows_.size(); ++i)
       sizes->push_back(initial_size_[i]);
   } else {
     DCHECK_NE(total_initial_size_, total_min_);
     int delta = total_initial_size_ - (end - start);
     int current = start;
     for (size_t i = 0; i < attached_windows_.size(); ++i) {
       int size = initial_size_[i] -
           static_cast<int>(compress_fraction_[i] * delta);
-      size = AlignToGrid(size, grid_size);
-      if (i == attached_windows_.size())
+      if (i + 1 == attached_windows_.size())
         size = end - current;
       current += size;
       sizes->push_back(size);
     }
   }
 }
 
 void WorkspaceWindowResizer::AdjustBoundsForMainWindow(
-    gfx::Rect* bounds, int grid_size) const {
+    gfx::Rect* bounds,
+    int grid_size) const {
   // Always keep kMinOnscreenHeight on the bottom except when an extended
   // display is available and a window is being dragged.
-  gfx::Rect work_area(
-      ScreenAsh::GetDisplayWorkAreaBoundsInParent(window()));
-  int max_y = AlignToGridRoundUp(work_area.bottom() - kMinOnscreenHeight,
-                                 grid_size);
+  gfx::Rect work_area(ScreenAsh::GetDisplayWorkAreaBoundsInParent(window()));
+  int max_y = work_area.bottom() - kMinOnscreenHeight;
   if ((details_.window_component != HTCAPTION || !HasSecondaryRootWindow()) &&
       bounds->y() > max_y) {
     bounds->set_y(max_y);
   }
 
   // Don't allow dragging above the top of the display except when an extended
   // display is available and a window is being dragged.
   if ((details_.window_component != HTCAPTION || !HasSecondaryRootWindow()) &&
       bounds->y() <= work_area.y()) {
     bounds->set_y(work_area.y());
@@ skipping 12 matching lines @@
     DCHECK_EQ(HTBOTTOM, details_.window_component);
     bounds->set_height(std::min(bounds->height(),
                                 work_area.bottom() - total_min_ - bounds->y()));
   }
 }
 
 void WorkspaceWindowResizer::SnapToWorkAreaEdges(
     const gfx::Rect& work_area,
     gfx::Rect* bounds,
     int grid_size) const {
-  int left_edge = AlignToGridRoundUp(work_area.x(), grid_size);
-  int right_edge = AlignToGridRoundDown(work_area.right(), grid_size);
-  int top_edge = AlignToGridRoundUp(work_area.y(), grid_size);
-  int bottom_edge = AlignToGridRoundDown(work_area.bottom(),
-                                         grid_size);
+  int left_edge = work_area.x();
+  int right_edge = work_area.right();
+  int top_edge = work_area.y();
+  int bottom_edge = work_area.bottom();
   if (ShouldSnapToEdge(bounds->x() - left_edge, grid_size)) {
     bounds->set_x(left_edge);
   } else if (ShouldSnapToEdge(right_edge - bounds->right(),
                               grid_size)) {
     bounds->set_x(right_edge - bounds->width());
   }
   if (ShouldSnapToEdge(bounds->y() - top_edge, grid_size)) {
     bounds->set_y(top_edge);
   } else if (ShouldSnapToEdge(bottom_edge - bounds->bottom(), grid_size) &&
              bounds->height() < (bottom_edge - top_edge)) {
@@ skipping 71 matching lines @@
     }
     drag_phantom_window_controller_->SetOpacity(phantom_opacity);
     window()->layer()->SetOpacity(window_opacity);
   } else {
     drag_phantom_window_controller_.reset();
     window()->layer()->SetOpacity(1.0f);
   }
 }
 
 void WorkspaceWindowResizer::UpdateSnapPhantomWindow(const gfx::Point& location,
-                                                     const gfx::Rect& bounds,
-                                                     int grid_size) {
+                                                     const gfx::Rect& bounds) {
   if (!did_move_or_resize_ || details_.window_component != HTCAPTION)
     return;
 
   SnapType last_type = snap_type_;
   snap_type_ = GetSnapType(location);
   if (snap_type_ == SNAP_NONE || snap_type_ != last_type) {
     snap_phantom_window_controller_.reset();
     snap_sizer_.reset();
     if (snap_type_ == SNAP_NONE)
       return;
   }
   if (!snap_sizer_.get()) {
     SnapSizer::Edge edge = (snap_type_ == SNAP_LEFT_EDGE) ?
         SnapSizer::LEFT_EDGE : SnapSizer::RIGHT_EDGE;
-    snap_sizer_.reset(
-        new SnapSizer(window(), location, edge, grid_size));
+    snap_sizer_.reset(new SnapSizer(window(), location, edge));
   } else {
     snap_sizer_->Update(location);
   }
   if (!snap_phantom_window_controller_.get()) {
     snap_phantom_window_controller_.reset(
         new PhantomWindowController(window()));
   }
   snap_phantom_window_controller_->Show(ScreenAsh::ConvertRectToScreen(
       window()->parent(), snap_sizer_->target_bounds()), NULL);
 }
@@ skipping 58 matching lines @@
   gfx::Rect layer_bounds = layer_->bounds();
   layer_bounds.set_origin(gfx::Point(0, 0));
   layer_->SetBounds(layer_bounds);
   layer_->SetVisible(false);
   // Detach it from the current container.
   layer_->parent()->Remove(layer_);
 }
 
 }  // namespace internal
 }  // namespace ash