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

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 404 matching lines @@
       (window()->type() != aura::client::WINDOW_TYPE_PANEL ||
        !window()->GetProperty(kPanelAttachedKey)) &&
       (snap_type_ == SNAP_LEFT_EDGE || snap_type_ == SNAP_RIGHT_EDGE)) {
     if (!GetRestoreBoundsInScreen(window())) {
       gfx::Rect initial_bounds = ScreenAsh::ConvertRectToScreen(
           window()->parent(), details_.initial_bounds_in_parent);
       SetRestoreBoundsInScreen(window(), details_.restore_bounds.IsEmpty() ?
                                initial_bounds :
                                details_.restore_bounds);
     }
-    window()->SetBounds(snap_sizer_->target_bounds());
-    return;
+    snap_sizer_->Snap();
   }
 }
 
 void WorkspaceWindowResizer::RevertDrag() {
   snap_phantom_window_controller_.reset();
 
   if (!did_move_or_resize_)
     return;
 
   window()->SetBounds(details_.initial_bounds_in_parent);
@@ skipping 411 matching lines @@
       NOTREACHED();
   }
   return 0;
 }
 
 void WorkspaceWindowResizer::UpdateSnapPhantomWindow(const gfx::Point& location,
                                                      const gfx::Rect& bounds) {
   if (!did_move_or_resize_ || details_.window_component != HTCAPTION)
     return;
 
-  if (!wm::CanSnapWindow(window()))
-    return;
-
   if (window()->type() == aura::client::WINDOW_TYPE_PANEL &&
       window()->GetProperty(kPanelAttachedKey)) {
     return;
   }
 
   SnapType last_type = snap_type_;
   snap_type_ = GetSnapType(location);
-  if (snap_type_ == SNAP_NONE || snap_type_ != last_type) {
+  using internal::SnapSizer;
+  SnapSizer::Edge edge = (snap_type_ == SNAP_LEFT_EDGE) ?
+      SnapSizer::LEFT_EDGE : SnapSizer::RIGHT_EDGE;
+  if (snap_type_ == SNAP_NONE ||
+      !SnapSizer::CanSnapWindow(window(), edge)) {
+    snap_type_ = SNAP_NONE;
     snap_phantom_window_controller_.reset();
     snap_sizer_.reset();
-    if (snap_type_ == SNAP_NONE)
-      return;
+    return;
   }
-  if (!snap_sizer_) {
-    SnapSizer::Edge edge = (snap_type_ == SNAP_LEFT_EDGE) ?
-        SnapSizer::LEFT_EDGE : SnapSizer::RIGHT_EDGE;
-    snap_sizer_.reset(new SnapSizer(window(),
-                                    location,
-                                    edge,
-                                    internal::SnapSizer::OTHER_INPUT));
+
+  if (snap_type_ != last_type ||

[varkha, 2013/08/30 17:13:25]

Will the animations be smoother if we don't re-create the snap-sizer and / or
snap_phantom_window_controller_ when alternating between left and right edges?

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

I believe that you always transition through SNAP_NONE when alternating between
the left and right edges.

+      !snap_sizer_ ||
+      !snap_phantom_window_controller_) {
+    snap_sizer_.reset(
+        new SnapSizer(window(), location, edge, SnapSizer::STEP_YES));
+    snap_phantom_window_controller_.reset(
+        new PhantomWindowController(window()));
   } else {
     snap_sizer_->Update(location);
   }
-  if (!snap_phantom_window_controller_) {
-    snap_phantom_window_controller_.reset(
-        new PhantomWindowController(window()));
-  }
   snap_phantom_window_controller_->Show(ScreenAsh::ConvertRectToScreen(
       window()->parent(), snap_sizer_->target_bounds()));
 }
 
 void WorkspaceWindowResizer::RestackWindows() {
   if (attached_windows_.empty())
     return;
   // Build a map from index in children to window, returning if there is a
   // window with a different parent.
   typedef std::map<size_t, aura::Window*> IndexToWindowMap;
@@ skipping 29 matching lines @@
   gfx::Rect area(ScreenAsh::GetDisplayBoundsInParent(window()));
   if (location.x() <= area.x())
     return SNAP_LEFT_EDGE;
   if (location.x() >= area.right() - 1)
     return SNAP_RIGHT_EDGE;
   return SNAP_NONE;
 }
 
 }  // namespace internal
 }  // namespace ash