Windows docking should get triggered by pressing against the screen edge

ash/wm/workspace/snap_sizer.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_WM_WORKSPACE_SNAP_SIZER_H_
 #define ASH_WM_WORKSPACE_SNAP_SIZER_H_
 
 #include <vector>
 
 #include "ash/ash_export.h"
 #include "base/basictypes.h"
 #include "base/time/time.h"
 #include "ui/gfx/rect.h"
 
 namespace aura {
 class Window;
 }
 
 namespace ash {
 namespace internal {
 
+class DockedWindowLayoutManager;
+
 // SnapSizer is responsible for determining the resulting bounds of a window
 // that is being snapped to the left or right side of the screen.
 // The bounds used in this class are in the container's coordinates.
 class ASH_EXPORT SnapSizer {
  public:
   enum Edge {
     LEFT_EDGE,
     RIGHT_EDGE
   };
 
   enum InputType {
     TOUCH_MAXIMIZE_BUTTON_INPUT,
+    WORKSPACE_DRAG_INPUT,
     OTHER_INPUT
   };
 
   // Set |input_type| to |TOUCH_MAXIMIZE_BUTTON_INPUT| when called by a touch
   // operation by the maximize button. This will allow the user to snap resize
   // the window beginning close to the border.
   SnapSizer(aura::Window* window,
             const gfx::Point& start,
             Edge edge,
             InputType input_type);
@@ skipping 12 matching lines @@
   // then it returns the next snap-bounds).
   gfx::Rect GetSnapBounds(const gfx::Rect& bounds);
 
   // Set the snap sizer to the button press default size and prevent resizing.
   void SelectDefaultSizeAndDisableResize();
 
   // Returns the target bounds based on the edge and the provided |size_index|.
   // For unit test purposes this function is not private.
   gfx::Rect GetTargetBoundsForSize(size_t size_index) const;
 
+  // Returns true when snapping sequence is at its last (docking) step.

[sky, 2013/09/11 19:38:40]

Why do we need snapsizer to know about docked windows? Could we keep this class
at only the snap behavior and transition to another one when we need to dock?

[varkha, 2013/09/11 20:02:10]

We moved to the model where docking is the last step in tiling sequence. Most of
the logic that deals with iterating along the sequence still applies. I agree
that most of the awareness about docked layout can be weeded out (it is in
CanWindowDock which is static and can be taken out easily) but I think the
docking guide target bounds can stay in this class for both tiled and docked
cases. This simplifies the resizer logic and leaves concerns better separated in
the resizer chain.
Consider that with a mouse drag it is possible to go back and forth between
tiling and docking and this simple class is all that coordinates those.

[varkha, 2013/09/12 19:49:23]

Done.

+  bool ShouldDockWindow() const;
+
+  // Returns true when a window can be docked. Windows cannot be docked at the
+  // edge used by the launcher shelf or the edge opposite from existing dock.
+  static bool CanDockWindow(aura::Window* window, SnapSizer::Edge edge);
+
  private:
   // Calculates the amount to increment by. This returns one of -1, 0 or 1 and
   // is intended to by applied to |size_index_|. |x| is the current
   // x-coordinate, and |reference_x| is used to determine whether to increase
   // or decrease the position. It's one of |last_adjust_x_| or |last_update_x_|.
   int CalculateIncrement(int x, int reference_x) const;
 
   // Changes the bounds. |x| is the current x-coordinate and |delta| the amount
   // to increase by. |delta| comes from CalculateIncrement() and is applied
   // to |size_index_|.
   void ChangeBounds(int x, int delta);
 
   // Returns the target bounds based on the edge and |size_index_|.
   gfx::Rect GetTargetBounds() const;
 
   // Returns true if the specified point is along the edge of the screen.
   bool AlongEdge(int x) const;
 
+  // Dock when a window is at its last step in snapping sequence, undock
+  // otherwise.
+  void UpdateDockedState();
+
   // Window being snapped.
   aura::Window* window_;
 
   const Edge edge_;
 
   // Current target bounds for the snap.
   gfx::Rect target_bounds_;
 
   // Time Update() was last invoked.
   base::TimeTicks time_last_update_;
@@ skipping 17 matching lines @@
 
   // Initial x-coordinate.
   const int start_x_;
 
   // |TOUCH_MAXIMIZE_BUTTON_INPUT| if the snap sizer was created through a
   // touch & drag operation of the maximizer button. It changes the behavior of
   // the drag / resize behavior when the dragging starts close to the border.
   const InputType input_type_;
 
   // A list of usable window widths for size. This gets created when the
-  // sizer gets created.
-  const std::vector<int> usable_width_;
+  // sizer gets created. Possible last 0 entry indicates that computing bounds
+  // needs to be delegated to DockedWindowLayoutManager.
+  std::vector<int> usable_width_;
+
+  // Dock container window layout manager.
+  DockedWindowLayoutManager* dock_layout_;
 
   DISALLOW_COPY_AND_ASSIGN(SnapSizer);
 };
 
 }  // namespace internal
 }  // namespace ash
 
 #endif  // ASH_WM_WORKSPACE_SNAP_SIZER_H_