Only support left/right maximizing at 50% width when the --ash-enable-alternate-caption-button

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 {
 
-// 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.
+// SnapSizer is responsible for determining how a window should be snapped to
+// the left or right of the screen. The bounds used in this class are in the
+// container's coordinates.
+// The SnapSizer currently only supports side maximizing the window but we want
+// to use this class for docking as well.
+// TODO(varkha): Add docking functionality to SnapSizer.
 class ASH_EXPORT SnapSizer {
  public:
   enum Edge {
     LEFT_EDGE,
     RIGHT_EDGE
   };
 
-  enum InputType {
-    TOUCH_MAXIMIZE_BUTTON_INPUT,
-    OTHER_INPUT
+  enum StepBehavior {
+    STEP_YES,
+    STEP_NO
   };
 
-  // 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.
+  // If |step_behavior| is STEP_NO, the SnapSizer will always snap to the
+  // default state and will always return the bounds for the default state.
+  // The value of |start| matters only if SnapSizer::Update() is called.
   SnapSizer(aura::Window* window,
             const gfx::Point& start,
             Edge edge,
-            InputType input_type);
+            StepBehavior step_behavior);
   virtual ~SnapSizer();
 
+  // Returns true if a window can be snapped to |edge|.
+  static bool CanSnapWindow(aura::Window* window);
+
   // Snaps a window left or right.
-  static void SnapWindow(aura::Window* window, Edge edge);
+  // If |step_behavior| is STEP_NO or if |window| is not snapped, the window
+  // is snapped with the default state.
+  // If |step_behavior| is STEP_YES and |window| is already snapped, the window
+  // is snapped to the next state.
+  static void SnapWindow(aura::Window* window,

[pkotwicz, 2013/08/30 21:10:57]

I believe that passing in |step_behavior| is useful. It makes the expected
behavior a lot more explicit. Previously, SnapWindow() would always go to the
next size even though this was not always the desired effect.
Going forward, we want the maximize button to only be able to side maximize the
window and not dock the window. In particular, if the window is already side
maximized, the side maximize button should not dock the window.

+                         Edge edge,
+                         StepBehavior step_behavior);
+
+  // Snaps the window to the current state.
+  void Snap();
 
   // Updates the target bounds based on a mouse move.
   void Update(const gfx::Point& location);
 
   // Bounds to position the window at.
   const gfx::Rect& target_bounds() const { return target_bounds_; }
 
-  // Returns the appropriate snap bounds (e.g. if a window is already snapped,
-  // then it returns the next snap-bounds).
-  gfx::Rect GetSnapBounds(const gfx::Rect& bounds);
+ private:
+  enum State {
+    SIDE_MAXIMIZE
+  };
 
-  // Set the snap sizer to the button press default size and prevent resizing.
-  void SelectDefaultSizeAndDisableResize();
+  // Returns a list of valid states ordered from the state with the largest
+  // width to the state with the smallest width.
+  static std::vector<State> BuildValidStatesList(aura::Window* window,
+                                                 StepBehavior step_behavior);
 
-  // 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;
-
- 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
+  // is intended to by applied to |state_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 |edge_| and |state_index_|.
+  gfx::Rect GetTargetBounds() const;
 
-  // Returns the target bounds based on the edge and |size_index_|.
-  gfx::Rect GetTargetBounds() const;
+
+  // Increments the current state (aka |state_index_|) by |delta| and updates
+  // |target_bounds_|.
+  void IncrementState(int delta);
 
   // Returns true if the specified point is along the edge of the screen.
   bool AlongEdge(int x) const;
 
   // 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_;
 
-  // Index into |kSizes| that dictates the width of the screen the target
-  // bounds should get.
-  int size_index_;
-
-  // If set, |size_index_| will get ignored and the single button default
-  // setting will be used instead.
-  bool resize_disabled_;
-
-  // Number of times Update() has been invoked since last ChangeBounds().
+  // Number of times Update() has been invoked since last IncrementState().
   int num_moves_since_adjust_;
 
-  // X-coordinate the last time ChangeBounds() was invoked.
+  // X-coordinate the last time IncrementState() was invoked.
   int last_adjust_x_;
 
   // X-coordinate last supplied to Update().
   int last_update_x_;
 
   // 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_;
+  // Index into |states_| that dictates the target bounds.
+  int state_index_;
 
-  // A list of usable window widths for size. This gets created when the
-  // sizer gets created.
-  const std::vector<int> usable_width_;
+  // The states that |window_| can step through, ordered from the state with
+  // the largest width to the state with the smallest width.
+  const std::vector<State> states_;
 
   DISALLOW_COPY_AND_ASSIGN(SnapSizer);
 };
 
 }  // namespace internal
 }  // namespace ash
 
 #endif  // ASH_WM_WORKSPACE_SNAP_SIZER_H_