clang-format all of //ash

ash/wm/toplevel_window_event_handler_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/wm/toplevel_window_event_handler.h"
 
 #include "ash/common/shell_window_ids.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/root_window_controller.h"
 #include "ash/shell.h"
@@ skipping 74 matching lines @@
   void TouchDragFromCenterBy(aura::Window* window, int dx, int dy) {
     ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(), window);
     generator.PressMoveAndReleaseTouchBy(dx, dy);
   }
 
   std::unique_ptr<ToplevelWindowEventHandler> handler_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ToplevelWindowEventHandlerTest);
 };
-
 }
 
 TEST_F(ToplevelWindowEventHandlerTest, Caption) {
   std::unique_ptr<aura::Window> w1(CreateWindow(HTCAPTION));
   gfx::Size size = w1->bounds().size();
   DragFromCenterBy(w1.get(), 100, 100);
   // Position should have been offset by 100,100.
   EXPECT_EQ("100,100", w1->bounds().origin().ToString());
   // Size should not have.
   EXPECT_EQ(size.ToString(), w1->bounds().size().ToString());
@@ skipping 328 matching lines @@
                                      target.get());
   gfx::Rect old_bounds = target->bounds();
   gfx::Point location(5, 5);
   target->SetProperty(aura::client::kCanMaximizeKey, true);
 
   gfx::Point end = location;
 
   // Snap right;
   end.Offset(100, 0);
   generator.GestureScrollSequence(location, end,
-      base::TimeDelta::FromMilliseconds(5),
-      10);
+                                  base::TimeDelta::FromMilliseconds(5), 10);
   RunAllPendingInMessageLoop();
 
   // Verify that the window has moved after the gesture.
   EXPECT_NE(old_bounds.ToString(), target->bounds().ToString());
   EXPECT_EQ(wm::WINDOW_STATE_TYPE_RIGHT_SNAPPED, window_state->GetStateType());
 
   old_bounds = target->bounds();
 
   // Snap left.
   end = location = target->GetBoundsInRootWindow().CenterPoint();
   end.Offset(-100, 0);
   generator.GestureScrollSequence(location, end,
-      base::TimeDelta::FromMilliseconds(5),
-      10);
+                                  base::TimeDelta::FromMilliseconds(5), 10);
   RunAllPendingInMessageLoop();
 
   EXPECT_NE(old_bounds.ToString(), target->bounds().ToString());
   EXPECT_EQ(wm::WINDOW_STATE_TYPE_LEFT_SNAPPED, window_state->GetStateType());
 
   gfx::Rect bounds_before_maximization = target->bounds();
   bounds_before_maximization.Offset(0, 100);
   target->SetBounds(bounds_before_maximization);
   old_bounds = target->bounds();
 
   // Maximize.
   end = location = target->GetBoundsInRootWindow().CenterPoint();
   end.Offset(0, -100);
   generator.GestureScrollSequence(location, end,
-      base::TimeDelta::FromMilliseconds(5),
-      10);
+                                  base::TimeDelta::FromMilliseconds(5), 10);
   RunAllPendingInMessageLoop();
 
   EXPECT_NE(old_bounds.ToString(), target->bounds().ToString());
   EXPECT_TRUE(window_state->IsMaximized());
   EXPECT_EQ(old_bounds.ToString(),
             window_state->GetRestoreBoundsInScreen().ToString());
 
   window_state->Restore();
   target->SetBounds(old_bounds);
 
   // Minimize.
   end = location = target->GetBoundsInRootWindow().CenterPoint();
   end.Offset(0, 100);
   generator.GestureScrollSequence(location, end,
-      base::TimeDelta::FromMilliseconds(5),
-      10);
+                                  base::TimeDelta::FromMilliseconds(5), 10);
   RunAllPendingInMessageLoop();
   EXPECT_NE(old_bounds.ToString(), target->bounds().ToString());
   EXPECT_TRUE(window_state->IsMinimized());
   EXPECT_TRUE(window_state->unminimize_to_restore_bounds());
   EXPECT_EQ(old_bounds.ToString(),
             window_state->GetRestoreBoundsInScreen().ToString());
 }
 
 // Tests that a gesture cannot minimize an unminimizeable window.
 TEST_F(ToplevelWindowEventHandlerTest,
        GestureAttemptMinimizeUnminimizeableWindow) {
   std::unique_ptr<aura::Window> target(CreateWindow(HTCAPTION));
   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
                                      target.get());
   gfx::Point location(5, 5);
   target->SetProperty(aura::client::kCanMaximizeKey, true);
   target->SetProperty(aura::client::kCanMinimizeKey, false);
 
   gfx::Point end = location;
   end.Offset(0, 100);
   generator.GestureScrollSequence(location, end,
-      base::TimeDelta::FromMilliseconds(5),
-      10);
+                                  base::TimeDelta::FromMilliseconds(5), 10);
   RunAllPendingInMessageLoop();
   EXPECT_FALSE(wm::GetWindowState(target.get())->IsMinimized());
 }
 
 TEST_F(ToplevelWindowEventHandlerTest, GestureDragToRestore) {
   std::unique_ptr<aura::Window> window(CreateTestWindowInShellWithDelegate(
       new TestWindowDelegate(HTCAPTION), 0, gfx::Rect(10, 20, 30, 40)));
   window->Show();
   wm::WindowState* window_state = wm::GetWindowState(window.get());
   window_state->Activate();
 
   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
                                      window.get());
   gfx::Rect old_bounds = window->bounds();
   gfx::Point location, end;
   end = location = window->GetBoundsInRootWindow().CenterPoint();
   end.Offset(0, 100);
   generator.GestureScrollSequence(location, end,
-      base::TimeDelta::FromMilliseconds(5),
-      10);
+                                  base::TimeDelta::FromMilliseconds(5), 10);
   RunAllPendingInMessageLoop();
   EXPECT_NE(old_bounds.ToString(), window->bounds().ToString());
   EXPECT_TRUE(window_state->IsMinimized());
   EXPECT_TRUE(window_state->unminimize_to_restore_bounds());
   EXPECT_EQ(old_bounds.ToString(),
             window_state->GetRestoreBoundsInScreen().ToString());
 }
 
 // Tests that an unresizable window cannot be dragged or snapped using gestures.
 TEST_F(ToplevelWindowEventHandlerTest, GestureDragForUnresizableWindow) {
   std::unique_ptr<aura::Window> target(CreateWindow(HTCAPTION));
   wm::WindowState* window_state = wm::GetWindowState(target.get());
 
   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
                                      target.get());
   gfx::Rect old_bounds = target->bounds();
   gfx::Point location(5, 5);
 
   target->SetProperty(aura::client::kCanResizeKey, false);
 
   gfx::Point end = location;
 
   // Try to snap right. The window is not resizable. So it should not snap.
   end.Offset(100, 0);
   generator.GestureScrollSequence(location, end,
-      base::TimeDelta::FromMilliseconds(5),
-      10);
+                                  base::TimeDelta::FromMilliseconds(5), 10);
   RunAllPendingInMessageLoop();
 
   // Verify that the window has moved after the gesture.
   gfx::Rect expected_bounds(old_bounds);
   expected_bounds.Offset(gfx::Vector2d(100, 0));
   EXPECT_EQ(expected_bounds.ToString(), target->bounds().ToString());
 
   // Verify that the window did not snap left.
   EXPECT_TRUE(window_state->IsNormalStateType());
 
   old_bounds = target->bounds();
 
   // Try to snap left. It should not snap.
   end = location = target->GetBoundsInRootWindow().CenterPoint();
   end.Offset(-100, 0);
   generator.GestureScrollSequence(location, end,
-      base::TimeDelta::FromMilliseconds(5),
-      10);
+                                  base::TimeDelta::FromMilliseconds(5), 10);
   RunAllPendingInMessageLoop();
 
   // Verify that the window has moved after the gesture.
   expected_bounds = old_bounds;
   expected_bounds.Offset(gfx::Vector2d(-100, 0));
   EXPECT_EQ(expected_bounds.ToString(), target->bounds().ToString());
 
   // Verify that the window did not snap left.
   EXPECT_TRUE(window_state->IsNormalStateType());
 }
@@ skipping 15 matching lines @@
   generator.PressTouch();
   location.Offset(40, 5);
   generator.MoveTouch(location);
 
   // Try to drag |notmoved| window. This should not move the window.
   {
     gfx::Rect bounds = notmoved->bounds();
     ui::test::EventGenerator gen(Shell::GetPrimaryRootWindow(), notmoved.get());
     gfx::Point start = notmoved->bounds().origin() + gfx::Vector2d(10, 10);
     gfx::Point end = start + gfx::Vector2d(100, 10);
-    gen.GestureScrollSequence(start, end,
-        base::TimeDelta::FromMilliseconds(10),
-        10);
+    gen.GestureScrollSequence(start, end, base::TimeDelta::FromMilliseconds(10),
+                              10);
     EXPECT_EQ(bounds.ToString(), notmoved->bounds().ToString());
   }
 }
 
 // Verifies pressing escape resets the bounds to the original bounds.
 // Disabled crbug.com/166219.
 #if defined(OS_WIN)
 #define MAYBE_EscapeReverts DISABLED_EscapeReverts
 #else
 #define MAYBE_EscapeReverts EscapeReverts
@@ skipping 75 matching lines @@
                                      window1.get());
   window1->Focus();
   generator.PressLeftButton();
   generator.MoveMouseBy(10, 11);
   EXPECT_EQ("10,11 100x100", window1->bounds().ToString());
 
   aura::client::WindowMoveClient* move_client =
       aura::client::GetWindowMoveClient(window2->GetRootWindow());
   EXPECT_EQ(aura::client::MOVE_CANCELED,
             move_client->RunMoveLoop(window2.get(), gfx::Vector2d(),
-                aura::client::WINDOW_MOVE_SOURCE_MOUSE));
+                                     aura::client::WINDOW_MOVE_SOURCE_MOUSE));
 
   generator.ReleaseLeftButton();
   EXPECT_EQ("10,11 100x100", window1->bounds().ToString());
 }
 
 namespace {
 
 void SendMouseReleaseAndReleaseCapture(ui::test::EventGenerator* generator,
                                        aura::Window* window) {
   generator->ReleaseLeftButton();
@@ skipping 12 matching lines @@
   window->SetCapture();
 
   aura::client::WindowMoveClient* move_client =
       aura::client::GetWindowMoveClient(window->GetRootWindow());
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&SendMouseReleaseAndReleaseCapture,
                  base::Unretained(&generator), base::Unretained(window.get())));
   EXPECT_EQ(aura::client::MOVE_SUCCESSFUL,
             move_client->RunMoveLoop(window.get(), gfx::Vector2d(),
-                aura::client::WINDOW_MOVE_SOURCE_MOUSE));
+                                     aura::client::WINDOW_MOVE_SOURCE_MOUSE));
 }
 
 namespace {
 
 // Checks that |window| has capture and releases capture.
 void CheckHasCaptureAndReleaseCapture(aura::Window* window) {
   ASSERT_TRUE(window->HasCapture());
   window->ReleaseCapture();
 }
 
@@ skipping 13 matching lines @@
   EXPECT_EQ(aura::client::MOVE_SUCCESSFUL,
             move_client->RunMoveLoop(window.get(), gfx::Vector2d(),
                                      aura::client::WINDOW_MOVE_SOURCE_TOUCH));
 }
 
 // Showing the resize shadows when the mouse is over the window edges is tested
 // in resize_shadow_and_cursor_test.cc
 
 }  // namespace test
 }  // namespace ash