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

ash/accelerators/accelerator_controller_unittest.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/accelerators/accelerator_controller.h"
 #include "ash/accelerators/accelerator_table.h"
 #include "ash/caps_lock_delegate.h"
 #include "ash/display/display_manager.h"
 #include "ash/ime_control_delegate.h"
 #include "ash/screenshot_delegate.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/system/brightness/brightness_control_delegate.h"
 #include "ash/system/keyboard_brightness/keyboard_brightness_control_delegate.h"
 #include "ash/system/tray/system_tray_delegate.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/display_manager_test_api.h"
 #include "ash/test/test_shell_delegate.h"
 #include "ash/volume_control_delegate.h"
 #include "ash/wm/window_util.h"
+#include "ash/wm/workspace/snap_sizer.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/test/test_windows.h"
 #include "ui/aura/window.h"
 #include "ui/base/events/event.h"
 
 #if defined(USE_X11)
 #include <X11/Xlib.h>
 #include "ui/base/x/x11_util.h"
 #endif
@@ skipping 463 matching lines @@
 }
 
 TEST_F(AcceleratorControllerTest, WindowSnap) {
   scoped_ptr<aura::Window> window(
       CreateTestWindowInShellWithBounds(gfx::Rect(5, 5, 20, 20)));
   const ui::Accelerator dummy;
 
   wm::ActivateWindow(window.get());
 
   {
-    GetController()->PerformAction(WINDOW_SNAP_LEFT, dummy);
-    gfx::Rect snap_left = window->bounds();
-    GetController()->PerformAction(WINDOW_SNAP_LEFT, dummy);
-    EXPECT_NE(window->bounds().ToString(), snap_left.ToString());
-    GetController()->PerformAction(WINDOW_SNAP_LEFT, dummy);
+    internal::SnapSizer snap_sizer_left(window.get(),
+                                        gfx::Point(),
+                                        internal::SnapSizer::LEFT_EDGE,
+                                        internal::SnapSizer::STEP_NO);
+    gfx::Rect snap_left = snap_sizer_left.target_bounds();
     EXPECT_NE(window->bounds().ToString(), snap_left.ToString());
 
-    // It should cycle back to the first snapped position.
     GetController()->PerformAction(WINDOW_SNAP_LEFT, dummy);
     EXPECT_EQ(window->bounds().ToString(), snap_left.ToString());
-  }
-  {
-    GetController()->PerformAction(WINDOW_SNAP_RIGHT, dummy);
-    gfx::Rect snap_right = window->bounds();
-    GetController()->PerformAction(WINDOW_SNAP_RIGHT, dummy);
-    EXPECT_NE(window->bounds().ToString(), snap_right.ToString());
-    GetController()->PerformAction(WINDOW_SNAP_RIGHT, dummy);
+
+    internal::SnapSizer snap_sizer_right(window.get(),
+                                         gfx::Point(),
+                                         internal::SnapSizer::RIGHT_EDGE,
+                                         internal::SnapSizer::STEP_NO);
+    gfx::Rect snap_right = snap_sizer_right.target_bounds();
+    EXPECT_NE(snap_left.ToString(), snap_right.ToString());
     EXPECT_NE(window->bounds().ToString(), snap_right.ToString());
 
-    // It should cycle back to the first snapped position.
     GetController()->PerformAction(WINDOW_SNAP_RIGHT, dummy);
     EXPECT_EQ(window->bounds().ToString(), snap_right.ToString());
+
+    // Restore the window because side maximizing stores restore bounds.
+    wm::RestoreWindow(window.get());
   }
   {
     gfx::Rect normal_bounds = window->bounds();
 
     GetController()->PerformAction(TOGGLE_MAXIMIZED, dummy);
     EXPECT_TRUE(wm::IsWindowMaximized(window.get()));
     EXPECT_NE(normal_bounds.ToString(), window->bounds().ToString());
 
     GetController()->PerformAction(TOGGLE_MAXIMIZED, dummy);
     EXPECT_FALSE(wm::IsWindowMaximized(window.get()));
@@ skipping 798 matching lines @@
     EXPECT_EQ(volume_down, delegate->last_accelerator());
     EXPECT_EQ(0, delegate->handle_volume_up_count());
     EXPECT_TRUE(ProcessWithContext(volume_up));
     EXPECT_EQ(1, delegate->handle_volume_up_count());
     EXPECT_EQ(volume_up, delegate->last_accelerator());
   }
 }
 #endif
 
 }  // namespace ash