clang-format all of //ash

ash/wm/overview/window_selector_unittest.cc

 // Copyright 2013 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 <algorithm>
 #include <vector>
 
 #include "ash/aura/wm_window_aura.h"
 #include "ash/common/accessibility_delegate.h"
 #include "ash/common/accessibility_types.h"
@@ skipping 170 matching lines @@
   WindowSelector* window_selector() {
     return window_selector_controller()->window_selector_.get();
   }
 
   void ToggleOverview() { window_selector_controller()->ToggleOverview(); }
 
   gfx::RectF GetTransformedBounds(aura::Window* window) {
     gfx::RectF bounds(ScreenUtil::ConvertRectToScreen(
         window->parent(), window->layer()->bounds()));
     gfx::Transform transform(gfx::TransformAboutPivot(
-        gfx::ToFlooredPoint(bounds.origin()),
-        window->layer()->transform()));
+        gfx::ToFlooredPoint(bounds.origin()), window->layer()->transform()));
     transform.TransformRect(&bounds);
     return bounds;
   }
 
   gfx::RectF GetTransformedTargetBounds(aura::Window* window) {
     gfx::RectF bounds(ScreenUtil::ConvertRectToScreen(
         window->parent(), window->layer()->GetTargetBounds()));
-    gfx::Transform transform(gfx::TransformAboutPivot(
-        gfx::ToFlooredPoint(bounds.origin()),
-        window->layer()->GetTargetTransform()));
+    gfx::Transform transform(
+        gfx::TransformAboutPivot(gfx::ToFlooredPoint(bounds.origin()),
+                                 window->layer()->GetTargetTransform()));
     transform.TransformRect(&bounds);
     return bounds;
   }
 
   gfx::RectF GetTransformedBoundsInRootWindow(aura::Window* window) {
     gfx::RectF bounds = gfx::RectF(gfx::SizeF(window->bounds().size()));
     aura::Window* root = window->GetRootWindow();
     CHECK(window->layer());
     CHECK(root->layer());
     gfx::Transform transform;
     if (!window->layer()->GetTargetTransformRelativeTo(root->layer(),
                                                        &transform)) {
       return gfx::RectF();
     }
     transform.TransformRect(&bounds);
     return bounds;
   }
 
   void ClickWindow(aura::Window* window) {
     ui::test::EventGenerator event_generator(window->GetRootWindow(), window);
     event_generator.ClickLeftButton();
   }
 
   void SendKey(ui::KeyboardCode key) {
     ui::test::EventGenerator event_generator(Shell::GetPrimaryRootWindow());
-      event_generator.PressKey(key, 0);
-      event_generator.ReleaseKey(key, 0);
+    event_generator.PressKey(key, 0);
+    event_generator.ReleaseKey(key, 0);
   }
 
   bool IsSelecting() { return window_selector_controller()->IsSelecting(); }
 
   aura::Window* GetFocusedWindow() {
-    return aura::client::GetFocusClient(
-        Shell::GetPrimaryRootWindow())->GetFocusedWindow();
-    }
+    return aura::client::GetFocusClient(Shell::GetPrimaryRootWindow())
+        ->GetFocusedWindow();
+  }
 
   const std::vector<WindowSelectorItem*>& GetWindowItemsForRoot(int index) {
     return window_selector()->grid_list_[index]->window_list_.get();
   }
 
   WindowSelectorItem* GetWindowItemForWindow(int grid_index,
                                              aura::Window* window) {
     const std::vector<WindowSelectorItem*>& windows =
         GetWindowItemsForRoot(grid_index);
     auto iter = std::find_if(windows.cbegin(), windows.cend(),
@@ skipping 63 matching lines @@
         ToEnclosingRect(GetTransformedTargetBounds(window))));
     EXPECT_TRUE(root_window->GetBoundsInScreen().Contains(
         ToEnclosingRect(GetTransformedTargetBounds(
             GetCloseButton(window_item)->GetNativeView()))));
   }
 
   void FilterItems(const base::StringPiece& pattern) {
     window_selector()->ContentsChanged(nullptr, base::UTF8ToUTF16(pattern));
   }
 
-  test::ShelfViewTestAPI* shelf_view_test() {
-    return shelf_view_test_.get();
-  }
+  test::ShelfViewTestAPI* shelf_view_test() { return shelf_view_test_.get(); }
 
   views::Widget* text_filter_widget() {
     return window_selector()->text_filter_widget_.get();
   }
 
  private:
   aura::test::TestWindowDelegate delegate_;
   NonActivatableActivationDelegate non_activatable_activation_delegate_;
   std::unique_ptr<test::ShelfViewTestAPI> shelf_view_test_;
   std::unique_ptr<test::MaterialDesignControllerTestAPI> material_design_state_;
@@ skipping 289 matching lines @@
 TEST_P(WindowSelectorTest, BasicGesture) {
   gfx::Rect bounds(0, 0, 400, 400);
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
   wm::ActivateWindow(window1.get());
   EXPECT_EQ(window1.get(), GetFocusedWindow());
   ToggleOverview();
   EXPECT_EQ(text_filter_widget()->GetNativeWindow(), GetFocusedWindow());
   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
                                      window2.get());
-  generator.GestureTapAt(gfx::ToEnclosingRect(
-      GetTransformedTargetBounds(window2.get())).CenterPoint());
+  generator.GestureTapAt(
+      gfx::ToEnclosingRect(GetTransformedTargetBounds(window2.get()))
+          .CenterPoint());
   EXPECT_EQ(window2.get(), GetFocusedWindow());
 }
 
 // Tests that the user action WindowSelector_ActiveWindowChanged is
 // recorded when the mouse/touchscreen/keyboard are used to select a window
 // in overview mode which is different from the previously-active window.
 TEST_P(WindowSelectorTest, ActiveWindowChangedUserActionRecorded) {
   base::UserActionTester user_action_tester;
   gfx::Rect bounds(0, 0, 400, 400);
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
@@ skipping 296 matching lines @@
   EXPECT_TRUE(shelf->GetDimsShelf());
 }
 
 // Tests that entering overview when a fullscreen window is active in maximized
 // mode correctly applies the transformations to the window and correctly
 // updates the window bounds on exiting overview mode: http://crbug.com/401664.
 TEST_P(WindowSelectorTest, FullscreenWindowMaximizeMode) {
   gfx::Rect bounds(0, 0, 400, 400);
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
-  Shell::GetInstance()->maximize_mode_controller()->
-      EnableMaximizeModeWindowManager(true);
+  Shell::GetInstance()
+      ->maximize_mode_controller()
+      ->EnableMaximizeModeWindowManager(true);
   wm::ActivateWindow(window2.get());
   wm::ActivateWindow(window1.get());
   gfx::Rect normal_window_bounds(window1->bounds());
   const wm::WMEvent toggle_fullscreen_event(wm::WM_EVENT_TOGGLE_FULLSCREEN);
   wm::GetWindowState(window1.get())->OnWMEvent(&toggle_fullscreen_event);
   gfx::Rect fullscreen_window_bounds(window1->bounds());
   EXPECT_NE(normal_window_bounds.ToString(),
             fullscreen_window_bounds.ToString());
   EXPECT_EQ(fullscreen_window_bounds.ToString(),
             window2->GetTargetBounds().ToString());
@@ skipping 131 matching lines @@
   window1.reset();
   window2.reset();
   EXPECT_FALSE(IsSelecting());
 }
 
 // Tests that entering overview mode restores a window to its original
 // target location.
 TEST_P(WindowSelectorTest, QuickReentryRestoresInitialTransform) {
   gfx::Rect bounds(0, 0, 400, 400);
   std::unique_ptr<aura::Window> window(CreateWindow(bounds));
-  gfx::Rect initial_bounds = ToEnclosingRect(
-      GetTransformedBounds(window.get()));
+  gfx::Rect initial_bounds =
+      ToEnclosingRect(GetTransformedBounds(window.get()));
   ToggleOverview();
   // Quickly exit and reenter overview mode. The window should still be
   // animating when we reenter. We cannot short circuit animations for this but
   // we also don't have to wait for them to complete.
   {
     ui::ScopedAnimationDurationScaleMode test_duration_mode(
         ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
     ToggleOverview();
     ToggleOverview();
   }
-  EXPECT_NE(initial_bounds, ToEnclosingRect(
-      GetTransformedTargetBounds(window.get())));
+  EXPECT_NE(initial_bounds,
+            ToEnclosingRect(GetTransformedTargetBounds(window.get())));
   ToggleOverview();
   EXPECT_FALSE(IsSelecting());
-  EXPECT_EQ(initial_bounds, ToEnclosingRect(
-      GetTransformedTargetBounds(window.get())));
+  EXPECT_EQ(initial_bounds,
+            ToEnclosingRect(GetTransformedTargetBounds(window.get())));
 }
 
 // Tests that windows with modal child windows are transformed with the modal
 // child even though not activatable themselves.
 TEST_P(WindowSelectorTest, ModalChild) {
   gfx::Rect bounds(0, 0, 400, 400);
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   std::unique_ptr<aura::Window> child1(CreateWindow(bounds));
   child1->SetProperty(aura::client::kModalKey, ui::MODAL_TYPE_WINDOW);
   ::wm::AddTransientChild(window1.get(), child1.get());
   EXPECT_EQ(window1->parent(), child1->parent());
   ToggleOverview();
   EXPECT_TRUE(window1->IsVisible());
   EXPECT_TRUE(child1->IsVisible());
   EXPECT_EQ(ToEnclosingRect(GetTransformedTargetBounds(child1.get())),
-      ToEnclosingRect(GetTransformedTargetBounds(window1.get())));
+            ToEnclosingRect(GetTransformedTargetBounds(window1.get())));
   ToggleOverview();
 }
 
 // Tests that clicking a modal window's parent activates the modal window in
 // overview.
 TEST_P(WindowSelectorTest, ClickModalWindowParent) {
   std::unique_ptr<aura::Window> window1(
       CreateWindow(gfx::Rect(0, 0, 180, 180)));
   std::unique_ptr<aura::Window> child1(
       CreateWindow(gfx::Rect(200, 0, 180, 180)));
@@ skipping 131 matching lines @@
   ash::DragDropController* drag_drop_controller =
       shell_test_api.drag_drop_controller();
   ui::OSExchangeData data;
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&WindowSelectorTest::ToggleOverview, base::Unretained(this)));
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&CancelDrag, drag_drop_controller, &drag_canceled_by_test));
   data.SetString(base::UTF8ToUTF16("I am being dragged"));
-  drag_drop_controller->StartDragAndDrop(data, window->GetRootWindow(),
-      window.get(), gfx::Point(5, 5), ui::DragDropTypes::DRAG_MOVE,
-      ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE);
+  drag_drop_controller->StartDragAndDrop(
+      data, window->GetRootWindow(), window.get(), gfx::Point(5, 5),
+      ui::DragDropTypes::DRAG_MOVE, ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE);
   RunAllPendingInMessageLoop();
   EXPECT_FALSE(drag_canceled_by_test);
   ASSERT_TRUE(IsSelecting());
   RunAllPendingInMessageLoop();
 }
 
 // Test that a label is created under the window on entering overview mode.
 TEST_P(WindowSelectorTest, CreateLabelUnderWindow) {
   std::unique_ptr<aura::Window> window(CreateWindow(gfx::Rect(0, 0, 300, 500)));
   base::string16 window_title = base::UTF8ToUTF16("My window");
@@ skipping 77 matching lines @@
 // possible direction.
 TEST_P(WindowSelectorTest, BasicArrowKeyNavigation) {
   if (!SupportsHostWindowResize())
     return;
   const size_t test_windows = 9;
   UpdateDisplay("800x600");
   ScopedVector<aura::Window> windows;
   for (size_t i = test_windows; i > 0; i--)
     windows.push_back(CreateWindowWithId(gfx::Rect(0, 0, 100, 100), i));
 
-  ui::KeyboardCode arrow_keys[] = {
-      ui::VKEY_RIGHT,
-      ui::VKEY_DOWN,
-      ui::VKEY_LEFT,
-      ui::VKEY_UP
-  };
+  ui::KeyboardCode arrow_keys[] = {ui::VKEY_RIGHT, ui::VKEY_DOWN, ui::VKEY_LEFT,
+                                   ui::VKEY_UP};
   // Expected window layout, assuming that the text filtering feature is
   // enabled by default (i.e., --ash-disable-text-filtering-in-overview-mode
   // is not being used).
   // +-------+  +-------+  +-------+  +-------+
   // |   1   |  |   2   |  |   3   |  |   4   |
   // +-------+  +-------+  +-------+  +-------+
   // +-------+  +-------+  +-------+  +-------+
   // |   5   |  |   6   |  |   7   |  |   8   |
   // +-------+  +-------+  +-------+  +-------+
   // +-------+
@@ skipping 422 matching lines @@
       bounds.y());
   EXPECT_LE(transformed_rect.bottom(), bounds.bottom());
   EXPECT_NEAR(transformed_rect.x() - bounds.x(),
               bounds.right() - transformed_rect.right(), 1);
   EXPECT_NEAR(
       transformed_rect.y() + (int)(scale * inset) - header_height - bounds.y(),
       bounds.bottom() - transformed_rect.bottom(), 1);
 }
 
 }  // namespace ash