clang-format all of //ash

ash/wm/maximize_mode/maximize_mode_window_manager_unittest.cc

 // Copyright 2014 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/maximize_mode/maximize_mode_window_manager.h"
 
 #include <string>
 
 #include "ash/aura/wm_window_aura.h"
 #include "ash/common/wm/mru_window_tracker.h"
@@ skipping 29 matching lines @@
 #if !defined(OS_WIN)
 
 class MaximizeModeWindowManagerTest : public test::AshTestBase {
  public:
   MaximizeModeWindowManagerTest() {}
   ~MaximizeModeWindowManagerTest() override {}
 
   // Creates a window which has a fixed size.
   aura::Window* CreateFixedSizeNonMaximizableWindow(ui::wm::WindowType type,
                                                     const gfx::Rect& bounds) {
-    return CreateWindowInWatchedContainer(
-        type, bounds, gfx::Size(), false, false);
+    return CreateWindowInWatchedContainer(type, bounds, gfx::Size(), false,
+                                          false);
   }
 
   // Creates a window which can not be maximized, but resized. |max_size|
   // denotes the maximal possible size, if the size is empty, the window has no
   // upper limit. Note: This function will only work with a single root window.
   aura::Window* CreateNonMaximizableWindow(ui::wm::WindowType type,
                                            const gfx::Rect& bounds,
                                            const gfx::Size& max_size) {
     return CreateWindowInWatchedContainer(type, bounds, max_size, false, true);
   }
 
   // Creates a maximizable and resizable window.
-  aura::Window* CreateWindow(ui::wm::WindowType type,
-                             const gfx::Rect bounds) {
-    return CreateWindowInWatchedContainer(
-        type, bounds, gfx::Size(), true, true);
+  aura::Window* CreateWindow(ui::wm::WindowType type, const gfx::Rect bounds) {
+    return CreateWindowInWatchedContainer(type, bounds, gfx::Size(), true,
+                                          true);
   }
 
   // Creates a window which also has a widget.
   aura::Window* CreateWindowWithWidget(const gfx::Rect& bounds) {
     views::Widget* widget = new views::Widget();
     views::Widget::InitParams params;
     params.context = CurrentContext();
     // Note: The widget will get deleted with the window.
     widget->Init(params);
     widget->Show();
     aura::Window* window = widget->GetNativeWindow();
     window->SetBounds(bounds);
     window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
 
     return window;
   }
 
   // Create the Maximized mode window manager.
   ash::MaximizeModeWindowManager* CreateMaximizeModeWindowManager() {
     EXPECT_FALSE(maximize_mode_window_manager());
-    Shell::GetInstance()->maximize_mode_controller()->
-        EnableMaximizeModeWindowManager(true);
+    Shell::GetInstance()
+        ->maximize_mode_controller()
+        ->EnableMaximizeModeWindowManager(true);
     return maximize_mode_window_manager();
   }
 
   // Destroy the maximized mode window manager.
   void DestroyMaximizeModeWindowManager() {
-    Shell::GetInstance()->maximize_mode_controller()->
-        EnableMaximizeModeWindowManager(false);
+    Shell::GetInstance()
+        ->maximize_mode_controller()
+        ->EnableMaximizeModeWindowManager(false);
     EXPECT_FALSE(maximize_mode_window_manager());
   }
 
   // Get the maximze window manager.
   ash::MaximizeModeWindowManager* maximize_mode_window_manager() {
-    return Shell::GetInstance()->maximize_mode_controller()->
-        maximize_mode_window_manager_.get();
+    return Shell::GetInstance()
+        ->maximize_mode_controller()
+        ->maximize_mode_window_manager_.get();
   }
 
   // Resize our desktop.
   void ResizeDesktop(int width_delta) {
     gfx::Size size =
         display::Screen::GetScreen()
             ->GetDisplayNearestWindow(Shell::GetPrimaryRootWindow())
             .size();
     size.Enlarge(0, width_delta);
     UpdateDisplay(size.ToString());
@@ skipping 198 matching lines @@
       CreateNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect, max_size));
   std::unique_ptr<aura::Window> fixed_window(
       CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
   EXPECT_FALSE(wm::GetWindowState(unlimited_window.get())->IsMaximized());
   EXPECT_EQ(rect.ToString(), unlimited_window->bounds().ToString());
   EXPECT_FALSE(wm::GetWindowState(limited_window.get())->IsMaximized());
   EXPECT_EQ(rect.ToString(), limited_window->bounds().ToString());
   EXPECT_FALSE(wm::GetWindowState(fixed_window.get())->IsMaximized());
   EXPECT_EQ(rect.ToString(), fixed_window->bounds().ToString());
 
-  gfx::Size workspace_size = ScreenUtil::GetMaximizedWindowBoundsInParent(
-      unlimited_window.get()).size();
+  gfx::Size workspace_size =
+      ScreenUtil::GetMaximizedWindowBoundsInParent(unlimited_window.get())
+          .size();
 
   // Create the manager and make sure that all qualifying windows were detected
   // and changed.
   ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
   ASSERT_TRUE(manager);
   EXPECT_EQ(3, manager->GetNumberOfManagedWindows());
   // The unlimited window should have the size of the workspace / parent window.
   EXPECT_FALSE(wm::GetWindowState(unlimited_window.get())->IsMaximized());
   EXPECT_EQ("0,0", unlimited_window->bounds().origin().ToString());
   EXPECT_EQ(workspace_size.ToString(),
             unlimited_window->bounds().size().ToString());
   // The limited window should have the size of the upper possible bounds.
   EXPECT_FALSE(wm::GetWindowState(limited_window.get())->IsMaximized());
   EXPECT_NE(rect.origin().ToString(),
             limited_window->bounds().origin().ToString());
-  EXPECT_EQ(max_size.ToString(),
-            limited_window->bounds().size().ToString());
+  EXPECT_EQ(max_size.ToString(), limited_window->bounds().size().ToString());
   // The fixed size window should have the size of the original window.
   EXPECT_FALSE(wm::GetWindowState(fixed_window.get())->IsMaximized());
   EXPECT_NE(rect.origin().ToString(),
             fixed_window->bounds().origin().ToString());
-  EXPECT_EQ(rect.size().ToString(),
-            fixed_window->bounds().size().ToString());
+  EXPECT_EQ(rect.size().ToString(), fixed_window->bounds().size().ToString());
 
   // Destroy the manager again and check that the windows return to their
   // previous state.
   DestroyMaximizeModeWindowManager();
   EXPECT_FALSE(wm::GetWindowState(unlimited_window.get())->IsMaximized());
   EXPECT_EQ(rect.ToString(), unlimited_window->bounds().ToString());
   EXPECT_FALSE(wm::GetWindowState(limited_window.get())->IsMaximized());
   EXPECT_EQ(rect.ToString(), limited_window->bounds().ToString());
   EXPECT_FALSE(wm::GetWindowState(fixed_window.get())->IsMaximized());
   EXPECT_EQ(rect.ToString(), fixed_window->bounds().ToString());
@@ skipping 91 matching lines @@
   // Destroy the maximize mode and check that the resulting size of the window
   // is remaining as it is (but not maximized).
   DestroyMaximizeModeWindowManager();
 
   EXPECT_FALSE(wm::GetWindowState(window.get())->IsMaximized());
   EXPECT_EQ(maximized_size.ToString(), window->bounds().ToString());
 }
 
 // Test that non-maximizable windows get properly handled when created in
 // maximized mode.
-TEST_F(MaximizeModeWindowManagerTest,
-       CreateNonMaximizableButResizableWindows) {
+TEST_F(MaximizeModeWindowManagerTest, CreateNonMaximizableButResizableWindows) {
   // Create the manager and make sure that all qualifying windows were detected
   // and changed.
   ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
   ASSERT_TRUE(manager);
 
   gfx::Rect rect(10, 10, 200, 50);
   gfx::Size max_size(300, 200);
   gfx::Size empty_size;
   std::unique_ptr<aura::Window> unlimited_window(
       CreateNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect, empty_size));
   std::unique_ptr<aura::Window> limited_window(
       CreateNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect, max_size));
   std::unique_ptr<aura::Window> fixed_window(
       CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
 
-  gfx::Size workspace_size = ScreenUtil::GetMaximizedWindowBoundsInParent(
-      unlimited_window.get()).size();
+  gfx::Size workspace_size =
+      ScreenUtil::GetMaximizedWindowBoundsInParent(unlimited_window.get())
+          .size();
 
   // All windows should be sized now as big as possible and be centered.
   EXPECT_EQ(3, manager->GetNumberOfManagedWindows());
   // The unlimited window should have the size of the workspace / parent window.
   EXPECT_FALSE(wm::GetWindowState(unlimited_window.get())->IsMaximized());
   EXPECT_EQ("0,0", unlimited_window->bounds().origin().ToString());
   EXPECT_EQ(workspace_size.ToString(),
             unlimited_window->bounds().size().ToString());
   // The limited window should have the size of the upper possible bounds.
   EXPECT_FALSE(wm::GetWindowState(limited_window.get())->IsMaximized());
   EXPECT_NE(rect.origin().ToString(),
             limited_window->bounds().origin().ToString());
-  EXPECT_EQ(max_size.ToString(),
-            limited_window->bounds().size().ToString());
+  EXPECT_EQ(max_size.ToString(), limited_window->bounds().size().ToString());
   // The fixed size window should have the size of the original window.
   EXPECT_FALSE(wm::GetWindowState(fixed_window.get())->IsMaximized());
   EXPECT_NE(rect.origin().ToString(),
             fixed_window->bounds().origin().ToString());
-  EXPECT_EQ(rect.size().ToString(),
-            fixed_window->bounds().size().ToString());
+  EXPECT_EQ(rect.size().ToString(), fixed_window->bounds().size().ToString());
 
   // Destroy the manager again and check that the windows return to their
   // creation state.
   DestroyMaximizeModeWindowManager();
 
   EXPECT_FALSE(wm::GetWindowState(unlimited_window.get())->IsMaximized());
   EXPECT_EQ(rect.ToString(), unlimited_window->bounds().ToString());
   EXPECT_FALSE(wm::GetWindowState(limited_window.get())->IsMaximized());
   EXPECT_EQ(rect.ToString(), limited_window->bounds().ToString());
   EXPECT_FALSE(wm::GetWindowState(fixed_window.get())->IsMaximized());
@@ skipping 149 matching lines @@
       CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
   std::unique_ptr<aura::Window> initially_maximized_window(
       CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
   wm::GetWindowState(initially_minimized_window.get())->Minimize();
   wm::GetWindowState(initially_maximized_window.get())->Maximize();
 
   // Create the manager and make sure that the window gets detected.
   ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
   ASSERT_TRUE(manager);
   EXPECT_EQ(3, manager->GetNumberOfManagedWindows());
-  EXPECT_TRUE(wm::GetWindowState(
-      initially_minimized_window.get())->IsMinimized());
+  EXPECT_TRUE(
+      wm::GetWindowState(initially_minimized_window.get())->IsMinimized());
   EXPECT_TRUE(wm::GetWindowState(initially_normal_window.get())->IsMaximized());
-  EXPECT_TRUE(wm::GetWindowState(
-      initially_maximized_window.get())->IsMaximized());
+  EXPECT_TRUE(
+      wm::GetWindowState(initially_maximized_window.get())->IsMaximized());
   // Now minimize the second window to check that upon leaving the window
   // will get restored to its minimized state.
   wm::GetWindowState(initially_normal_window.get())->Minimize();
   wm::GetWindowState(initially_maximized_window.get())->Minimize();
-  EXPECT_TRUE(wm::GetWindowState(
-      initially_minimized_window.get())->IsMinimized());
-  EXPECT_TRUE(wm::GetWindowState(
-      initially_normal_window.get())->IsMinimized());
-  EXPECT_TRUE(wm::GetWindowState(
-      initially_maximized_window.get())->IsMinimized());
+  EXPECT_TRUE(
+      wm::GetWindowState(initially_minimized_window.get())->IsMinimized());
+  EXPECT_TRUE(wm::GetWindowState(initially_normal_window.get())->IsMinimized());
+  EXPECT_TRUE(
+      wm::GetWindowState(initially_maximized_window.get())->IsMinimized());
 
   // Destroy the manager again and check that the window will get minimized.
   DestroyMaximizeModeWindowManager();
-  EXPECT_TRUE(wm::GetWindowState(
-      initially_minimized_window.get())->IsMinimized());
-  EXPECT_FALSE(wm::GetWindowState(
-                   initially_normal_window.get())->IsMinimized());
-  EXPECT_TRUE(wm::GetWindowState(
-      initially_maximized_window.get())->IsMaximized());
+  EXPECT_TRUE(
+      wm::GetWindowState(initially_minimized_window.get())->IsMinimized());
+  EXPECT_FALSE(
+      wm::GetWindowState(initially_normal_window.get())->IsMinimized());
+  EXPECT_TRUE(
+      wm::GetWindowState(initially_maximized_window.get())->IsMaximized());
 }
 
 // Check that resizing the desktop does reposition unmaximizable, unresizable &
 // managed windows.
 TEST_F(MaximizeModeWindowManagerTest, DesktopSizeChangeMovesUnmaximizable) {
   UpdateDisplay("400x400");
   // This window will move because it does not fit the new bounds.
   gfx::Rect rect(20, 300, 100, 100);
   std::unique_ptr<aura::Window> window1(
       CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
@@ skipping 128 matching lines @@
   DestroyMaximizeModeWindowManager();
 }
 
 // Check that minimize and restore do the right thing.
 TEST_F(MaximizeModeWindowManagerTest, TestMinimize) {
   gfx::Rect rect(10, 10, 100, 100);
   std::unique_ptr<aura::Window> window(
       CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect));
   wm::WindowState* window_state = wm::GetWindowState(window.get());
   EXPECT_EQ(rect.ToString(), window->bounds().ToString());
-  ash::Shell::GetInstance()->maximize_mode_controller()->
-      EnableMaximizeModeWindowManager(true);
+  ash::Shell::GetInstance()
+      ->maximize_mode_controller()
+      ->EnableMaximizeModeWindowManager(true);
   EXPECT_TRUE(window_state->IsMaximized());
   EXPECT_FALSE(window_state->IsMinimized());
   EXPECT_TRUE(window->IsVisible());
 
   window_state->Minimize();
   EXPECT_FALSE(window_state->IsMaximized());
   EXPECT_TRUE(window_state->IsMinimized());
   EXPECT_FALSE(window->IsVisible());
 
   window_state->Maximize();
   EXPECT_TRUE(window_state->IsMaximized());
   EXPECT_FALSE(window_state->IsMinimized());
   EXPECT_TRUE(window->IsVisible());
 
-  ash::Shell::GetInstance()->maximize_mode_controller()->
-      EnableMaximizeModeWindowManager(false);
+  ash::Shell::GetInstance()
+      ->maximize_mode_controller()
+      ->EnableMaximizeModeWindowManager(false);
   EXPECT_FALSE(window_state->IsMaximized());
   EXPECT_FALSE(window_state->IsMinimized());
   EXPECT_TRUE(window->IsVisible());
 }
 
 // Check that a full screen window remains full screen upon entering maximize
 // mode. Furthermore, checks that this window is not full screen upon exiting
 // maximize mode if it was un-full-screened while in maximize mode.
 TEST_F(MaximizeModeWindowManagerTest, KeepFullScreenModeOn) {
   gfx::Rect rect(20, 140, 100, 100);
@@ skipping 214 matching lines @@
   generator.PressLeftButton();
   generator.MoveMouseBy(10, 5);
   RunAllPendingInMessageLoop();
   generator.ReleaseLeftButton();
   gfx::Point first_dragged_origin = window->bounds().origin();
   EXPECT_EQ(rect.x() + 10, first_dragged_origin.x());
   EXPECT_EQ(rect.y() + 5, first_dragged_origin.y());
 
   // 2. Check that turning on the manager will stop allowing the window from
   // dragging.
-  ash::Shell::GetInstance()->maximize_mode_controller()->
-      EnableMaximizeModeWindowManager(true);
+  ash::Shell::GetInstance()
+      ->maximize_mode_controller()
+      ->EnableMaximizeModeWindowManager(true);
   gfx::Rect center_bounds(window->bounds());
   EXPECT_NE(rect.origin().ToString(), center_bounds.origin().ToString());
-  generator.MoveMouseTo(gfx::Point(center_bounds.x() + 1,
-                                   center_bounds.y() + 1));
+  generator.MoveMouseTo(
+      gfx::Point(center_bounds.x() + 1, center_bounds.y() + 1));
   generator.PressLeftButton();
   generator.MoveMouseBy(10, 5);
   RunAllPendingInMessageLoop();
   generator.ReleaseLeftButton();
   EXPECT_EQ(center_bounds.x(), window->bounds().x());
   EXPECT_EQ(center_bounds.y(), window->bounds().y());
-  ash::Shell::GetInstance()->maximize_mode_controller()->
-      EnableMaximizeModeWindowManager(false);
+  ash::Shell::GetInstance()
+      ->maximize_mode_controller()
+      ->EnableMaximizeModeWindowManager(false);
 
   // 3. Releasing the mazimize manager again will restore the window to its
   // previous bounds and
-  generator.MoveMouseTo(gfx::Point(first_dragged_origin.x() + 1,
-                                   first_dragged_origin.y() + 1));
+  generator.MoveMouseTo(
+      gfx::Point(first_dragged_origin.x() + 1, first_dragged_origin.y() + 1));
   generator.PressLeftButton();
   generator.MoveMouseBy(10, 5);
   RunAllPendingInMessageLoop();
   generator.ReleaseLeftButton();
   EXPECT_EQ(first_dragged_origin.x() + 10, window->bounds().x());
   EXPECT_EQ(first_dragged_origin.y() + 5, window->bounds().y());
 }
 
 // Test that overview is exited before entering / exiting maximize mode so that
 // the window changes made by MaximizeModeWindowManager do not conflict with
@@ skipping 40 matching lines @@
   // Fullscreen both windows.
   wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN);
   background_window_state->OnWMEvent(&event);
   foreground_window_state->OnWMEvent(&event);
   EXPECT_TRUE(background_window_state->IsFullscreen());
   EXPECT_TRUE(foreground_window_state->IsFullscreen());
   EXPECT_EQ(foreground_window.get(), wm::GetActiveWindow());
 
   // Do an edge swipe top into screen.
   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
-  generator.GestureScrollSequence(gfx::Point(50, 0),
-                                  gfx::Point(50, 100),
-                                  base::TimeDelta::FromMilliseconds(20),
-                                  10);
+  generator.GestureScrollSequence(gfx::Point(50, 0), gfx::Point(50, 100),
+                                  base::TimeDelta::FromMilliseconds(20), 10);
 
   EXPECT_FALSE(foreground_window_state->IsFullscreen());
   EXPECT_TRUE(background_window_state->IsFullscreen());
 
   // Do a second edge swipe top into screen.
-  generator.GestureScrollSequence(gfx::Point(50, 0),
-                                  gfx::Point(50, 100),
-                                  base::TimeDelta::FromMilliseconds(20),
-                                  10);
+  generator.GestureScrollSequence(gfx::Point(50, 0), gfx::Point(50, 100),
+                                  base::TimeDelta::FromMilliseconds(20), 10);
 
   EXPECT_FALSE(foreground_window_state->IsFullscreen());
   EXPECT_TRUE(background_window_state->IsFullscreen());
 
   DestroyMaximizeModeWindowManager();
 }
 
 // Test that an edge swipe from the bottom will end full screen mode.
 TEST_F(MaximizeModeWindowManagerTest, ExitFullScreenWithEdgeSwipeFromBottom) {
   gfx::Rect rect(10, 10, 200, 50);
@@ skipping 12 matching lines @@
   wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN);
   background_window_state->OnWMEvent(&event);
   foreground_window_state->OnWMEvent(&event);
   EXPECT_TRUE(background_window_state->IsFullscreen());
   EXPECT_TRUE(foreground_window_state->IsFullscreen());
   EXPECT_EQ(foreground_window.get(), wm::GetActiveWindow());
 
   // Do an edge swipe bottom into screen.
   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
   int y = Shell::GetPrimaryRootWindow()->bounds().bottom();
-  generator.GestureScrollSequence(gfx::Point(50, y),
-                                  gfx::Point(50, y - 100),
-                                  base::TimeDelta::FromMilliseconds(20),
-                                  10);
+  generator.GestureScrollSequence(gfx::Point(50, y), gfx::Point(50, y - 100),
+                                  base::TimeDelta::FromMilliseconds(20), 10);
 
   EXPECT_FALSE(foreground_window_state->IsFullscreen());
   EXPECT_TRUE(background_window_state->IsFullscreen());
 
   DestroyMaximizeModeWindowManager();
 }
 
 // Test that an edge touch press at the top will end full screen mode.
 TEST_F(MaximizeModeWindowManagerTest, ExitFullScreenWithEdgeTouchAtTop) {
   gfx::Rect rect(10, 10, 200, 50);
@@ skipping 81 matching lines @@
   wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN);
   window_state->OnWMEvent(&event);
   EXPECT_TRUE(window_state->IsFullscreen());
   EXPECT_FALSE(window_state->in_immersive_fullscreen());
   EXPECT_EQ(window.get(), wm::GetActiveWindow());
 
   window_state->set_in_immersive_fullscreen(true);
 
   // Do an edge swipe top into screen.
   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
-  generator.GestureScrollSequence(gfx::Point(50, 0),
-                                  gfx::Point(50, 100),
-                                  base::TimeDelta::FromMilliseconds(20),
-                                  10);
+  generator.GestureScrollSequence(gfx::Point(50, 0), gfx::Point(50, 100),
+                                  base::TimeDelta::FromMilliseconds(20), 10);
 
   // It should have not exited full screen or immersive mode.
   EXPECT_TRUE(window_state->IsFullscreen());
   EXPECT_TRUE(window_state->in_immersive_fullscreen());
 
   DestroyMaximizeModeWindowManager();
 }
 
 // Test that an edge swipe from the bottom will not end immersive mode.
 TEST_F(MaximizeModeWindowManagerTest,
        NoExitImmersiveModeWithEdgeSwipeFromBottom) {
   std::unique_ptr<aura::Window> window(
       CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, gfx::Rect(10, 10, 200, 50)));
   wm::WindowState* window_state = wm::GetWindowState(window.get());
   wm::ActivateWindow(window.get());
   CreateMaximizeModeWindowManager();
 
   // Fullscreen the window.
   wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN);
   window_state->OnWMEvent(&event);
   EXPECT_TRUE(window_state->IsFullscreen());
   EXPECT_FALSE(window_state->in_immersive_fullscreen());
   EXPECT_EQ(window.get(), wm::GetActiveWindow());
   window_state->set_in_immersive_fullscreen(true);
   EXPECT_TRUE(window_state->in_immersive_fullscreen());
 
   // Do an edge swipe bottom into screen.
   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
   int y = Shell::GetPrimaryRootWindow()->bounds().bottom();
-  generator.GestureScrollSequence(gfx::Point(50, y),
-                                  gfx::Point(50, y - 100),
-                                  base::TimeDelta::FromMilliseconds(20),
-                                  10);
+  generator.GestureScrollSequence(gfx::Point(50, y), gfx::Point(50, y - 100),
+                                  base::TimeDelta::FromMilliseconds(20), 10);
 
   // The window should still be full screen and immersive.
   EXPECT_TRUE(window_state->IsFullscreen());
   EXPECT_TRUE(window_state->in_immersive_fullscreen());
 
   DestroyMaximizeModeWindowManager();
 }
 
 // Tests that windows with the always-on-top property are not managed by
 // the MaximizeModeWindowManager while maximize mode is engaged (i.e.,
@@ skipping 80 matching lines @@
 
   ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager();
   EXPECT_TRUE(wm::GetWindowState(window.get())->IsDocked());
   EXPECT_FALSE(wm::GetWindowState(window.get())->IsMaximized());
   EXPECT_EQ(0, manager->GetNumberOfManagedWindows());
 }
 
 #endif  // OS_WIN
 
 }  // namespace ash