clang-format all of //ash

ash/wm/panels/panel_layout_manager_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/common/wm/panels/panel_layout_manager.h"
 
 #include "ash/aura/wm_window_aura.h"
 #include "ash/common/ash_switches.h"
 #include "ash/common/shelf/shelf_model.h"
 #include "ash/common/shelf/shelf_types.h"
@@ skipping 33 matching lines @@
 
 class PanelLayoutManagerTest : public test::AshTestBase {
  public:
   PanelLayoutManagerTest() {}
   ~PanelLayoutManagerTest() override {}
 
   void SetUp() override {
     test::AshTestBase::SetUp();
     ASSERT_TRUE(test::TestShelfDelegate::instance());
 
-    shelf_view_test_.reset(new test::ShelfViewTestAPI(
-        GetShelfView(Shelf::ForPrimaryDisplay())));
+    shelf_view_test_.reset(
+        new test::ShelfViewTestAPI(GetShelfView(Shelf::ForPrimaryDisplay())));
     shelf_view_test_->SetAnimationDuration(1);
   }
 
   aura::Window* CreateNormalWindow(const gfx::Rect& bounds) {
     return CreateTestWindowInShellWithBounds(bounds);
   }
 
   aura::Window* CreatePanelWindowWithDelegate(aura::WindowDelegate* delegate,
                                               const gfx::Rect& bounds) {
     aura::Window* window = CreateTestWindowInShellWithDelegateAndType(
@@ skipping 27 matching lines @@
   }
 
   void PanelInScreen(aura::Window* panel) {
     gfx::Rect panel_bounds = panel->GetBoundsInRootWindow();
     gfx::Point root_point = gfx::Point(panel_bounds.x(), panel_bounds.y());
     display::Display display =
         ScreenUtil::FindDisplayContainingPoint(root_point);
 
     gfx::Rect panel_bounds_in_screen = panel->GetBoundsInScreen();
     gfx::Point screen_bottom_right = gfx::Point(
-        panel_bounds_in_screen.right(),
-        panel_bounds_in_screen.bottom());
+        panel_bounds_in_screen.right(), panel_bounds_in_screen.bottom());
     gfx::Rect display_bounds = display.bounds();
     EXPECT_TRUE(screen_bottom_right.x() < display_bounds.width() &&
                 screen_bottom_right.y() < display_bounds.height());
   }
 
   void PanelsNotOverlapping(aura::Window* panel1, aura::Window* panel2) {
     // Waits until all shelf view animations are done.
     shelf_view_test()->RunMessageLoopUntilAnimationsDone();
     gfx::Rect window1_bounds = panel1->GetBoundsInRootWindow();
     gfx::Rect window2_bounds = panel2->GetBoundsInRootWindow();
@@ skipping 53 matching lines @@
     ShelfAlignment alignment = GetAlignment(panel->GetRootWindow());
     if (alignment == SHELF_ALIGNMENT_LEFT)
       EXPECT_EQ(panel_bounds.x(), callout_bounds.right());
     else if (alignment == SHELF_ALIGNMENT_RIGHT)
       EXPECT_EQ(panel_bounds.right(), callout_bounds.x());
     else
       EXPECT_EQ(panel_bounds.bottom(), callout_bounds.y());
 
     if (IsHorizontal(alignment)) {
       EXPECT_NEAR(icon_bounds.CenterPoint().x(),
-                  widget->GetWindowBoundsInScreen().CenterPoint().x(),
-                  1);
+                  widget->GetWindowBoundsInScreen().CenterPoint().x(), 1);
     } else {
       EXPECT_NEAR(icon_bounds.CenterPoint().y(),
-                  widget->GetWindowBoundsInScreen().CenterPoint().y(),
-                  1);
+                  widget->GetWindowBoundsInScreen().CenterPoint().y(), 1);
     }
   }
 
   bool IsPanelCalloutVisible(aura::Window* panel) {
     views::Widget* widget = GetCalloutWidgetForPanel(panel);
     return widget->IsVisible();
   }
 
-  test::ShelfViewTestAPI* shelf_view_test() {
-    return shelf_view_test_.get();
-  }
+  test::ShelfViewTestAPI* shelf_view_test() { return shelf_view_test_.get(); }
 
   // Clicks the shelf items on |shelf_view| that is associated with given
   // |window|.
   void ClickShelfItemForWindow(ShelfView* shelf_view, aura::Window* window) {
     test::ShelfViewTestAPI test_api(shelf_view);
     test_api.SetAnimationDuration(1);
     test_api.RunMessageLoopUntilAnimationsDone();
     ShelfModel* model = test::ShellTestApi(Shell::GetInstance()).shelf_model();
     int index = model->ItemIndexByID(GetShelfIDForWindow(window));
     gfx::Rect bounds = test_api.GetButton(index)->GetBoundsInScreen();
@@ skipping 100 matching lines @@
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 
   std::unique_ptr<aura::Window> normal_window(
       CreateNormalWindow(gfx::Rect(450, 0, 100, 100)));
   std::unique_ptr<aura::Window> panel(
       CreatePanelWindow(gfx::Rect(400, 0, 50, 50)));
   EXPECT_EQ(root_windows[1], panel->GetRootWindow());
   EXPECT_NO_FATAL_FAILURE(IsPanelAboveLauncherIcon(panel.get()));
   gfx::Rect shelf_visible_position = panel->GetBoundsInScreen();
 
-  SetShelfAutoHideBehavior(root_windows[1],
-                           SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
+  SetShelfAutoHideBehavior(root_windows[1], SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
   // Expect the panel X position to remain the same after the shelf is hidden
   // but the Y to move down.
   EXPECT_NO_FATAL_FAILURE(IsPanelAboveLauncherIcon(panel.get()));
   EXPECT_EQ(shelf_visible_position.x(), panel->GetBoundsInScreen().x());
   EXPECT_GT(panel->GetBoundsInScreen().y(), shelf_visible_position.y());
 }
 
 // Tests interactions between multiple panels
 TEST_F(PanelLayoutManagerTest, MultiplePanelsAreAboveIcons) {
   gfx::Rect odd_bounds(0, 0, 201, 201);
@@ skipping 251 matching lines @@
   std::unique_ptr<aura::Window> p1_d1(
       CreatePanelWindow(gfx::Rect(0, 0, 50, 50)));
   std::unique_ptr<aura::Window> p2_d1(
       CreatePanelWindow(gfx::Rect(0, 0, 50, 50)));
   std::unique_ptr<aura::Window> p1_d2(
       CreatePanelWindow(gfx::Rect(600, 0, 50, 50)));
   std::unique_ptr<aura::Window> p2_d2(
       CreatePanelWindow(gfx::Rect(600, 0, 50, 50)));
 
   ShelfView* shelf_view_1st = GetShelfView(Shelf::ForPrimaryDisplay());
-  ShelfView* shelf_view_2nd =
-      GetShelfView(Shelf::ForWindow(root_windows[1]));
+  ShelfView* shelf_view_2nd = GetShelfView(Shelf::ForWindow(root_windows[1]));
 
   EXPECT_EQ(root_windows[0], p1_d1->GetRootWindow());
   EXPECT_EQ(root_windows[0], p2_d1->GetRootWindow());
   EXPECT_EQ(root_windows[1], p1_d2->GetRootWindow());
   EXPECT_EQ(root_windows[1], p2_d2->GetRootWindow());
 
   EXPECT_EQ(kShellWindowId_PanelContainer, p1_d1->parent()->id());
   EXPECT_EQ(kShellWindowId_PanelContainer, p2_d1->parent()->id());
   EXPECT_EQ(kShellWindowId_PanelContainer, p1_d2->parent()->id());
   EXPECT_EQ(kShellWindowId_PanelContainer, p2_d2->parent()->id());
@@ skipping 174 matching lines @@
   // arbitrarily-selected small numbers which will ensure the point is
   // within the default extended region surrounding the panel. This value
   // is calculated as
   // kResizeOutsideBoundsSize * kResizeOutsideBoundsScaleForTouch
   // in src/ash/root_window_controller.cc.
 
   // Hit test outside the right edge with a bottom-aligned shelf.
   SetAlignment(Shell::GetPrimaryRootWindow(), SHELF_ALIGNMENT_BOTTOM);
   gfx::Rect bounds(w->bounds());
   ui::TouchEvent touch(ui::ET_TOUCH_PRESSED,
-                       gfx::Point(bounds.right() + 3, bounds.y() + 2),
-                       0, ui::EventTimeForNow());
+                       gfx::Point(bounds.right() + 3, bounds.y() + 2), 0,
+                       ui::EventTimeForNow());
   ui::EventTarget* target = targeter->FindTargetForEvent(root, &touch);
   EXPECT_EQ(w.get(), target);
 
   // Hit test outside the bottom edge with a bottom-aligned shelf.
   touch.set_location(gfx::Point(bounds.x() + 6, bounds.bottom() + 5));
   target = targeter->FindTargetForEvent(root, &touch);
   EXPECT_NE(w.get(), target);
 
   // Hit test outside the bottom edge with a right-aligned shelf.
   SetAlignment(Shell::GetPrimaryRootWindow(), SHELF_ALIGNMENT_RIGHT);
@@ skipping 13 matching lines @@
   touch.set_location(gfx::Point(bounds.x() + 4, bounds.y() - 6));
   target = targeter->FindTargetForEvent(root, &touch);
   EXPECT_EQ(w.get(), target);
 
   // Hit test outside the left edge with a left-aligned shelf.
   touch.set_location(gfx::Point(bounds.x() - 1, bounds.y() + 5));
   target = targeter->FindTargetForEvent(root, &touch);
   EXPECT_NE(w.get(), target);
 }
 
-INSTANTIATE_TEST_CASE_P(LtrRtl, PanelLayoutManagerTextDirectionTest,
+INSTANTIATE_TEST_CASE_P(LtrRtl,
+                        PanelLayoutManagerTextDirectionTest,
                         testing::Bool());
 
 }  // namespace ash