clang-format all of //ash

ash/wm/dock/docked_window_layout_manager_unittest.cc

 // Copyright (c) 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 "ash/common/wm/dock/docked_window_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 96 matching lines @@
     return CreateWindowResizer(WmWindowAura::Get(window), point_in_parent,
                                window_component,
                                aura::client::WINDOW_MOVE_SOURCE_MOUSE)
         .release();
   }
 
   void DragStart(aura::Window* window) {
     DragStartAtOffsetFromwindowOrigin(window, 0, 0);
   }
 
-  void DragStartAtOffsetFromwindowOrigin(aura::Window* window,
-                                         int dx, int dy) {
+  void DragStartAtOffsetFromwindowOrigin(aura::Window* window, int dx, int dy) {
     initial_location_in_parent_ =
         window->bounds().origin() + gfx::Vector2d(dx, dy);
-    resizer_.reset(CreateSomeWindowResizer(window,
-                                           initial_location_in_parent_,
+    resizer_.reset(CreateSomeWindowResizer(window, initial_location_in_parent_,
                                            HTCAPTION));
     ASSERT_TRUE(resizer_.get());
   }
 
   void DragMove(int dx, int dy) {
     resizer_->Drag(initial_location_in_parent_ + gfx::Vector2d(dx, dy), 0);
   }
 
   void DragEnd() {
     resizer_->CompleteDrag();
@@ skipping 12 matching lines @@
   int CorrectContainerIdDuringDrag() {
     if (window_type_ == ui::wm::WINDOW_TYPE_PANEL)
       return kShellWindowId_PanelContainer;
     return kShellWindowId_DockedContainer;
   }
 
   // Test dragging the window vertically (to detach if it is a panel) and then
   // horizontally to the edge with an added offset from the edge of |dx|.
   void DragRelativeToEdge(DockedEdge edge, aura::Window* window, int dx) {
     DragVerticallyAndRelativeToEdge(
-        edge,
-        window,
-        dx,
+        edge, window, dx,
         window_type_ == ui::wm::WINDOW_TYPE_PANEL ? -100 : 20);
   }
 
   void DragToVerticalPositionAndToEdge(DockedEdge edge,
                                        aura::Window* window,
                                        int y) {
     DragToVerticalPositionRelativeToEdge(edge, window, 0, y);
   }
 
   void DragToVerticalPositionRelativeToEdge(DockedEdge edge,
                                             aura::Window* window,
                                             int dx,
                                             int y) {
     gfx::Rect initial_bounds = window->GetBoundsInScreen();
     DragVerticallyAndRelativeToEdge(edge, window, dx, y - initial_bounds.y());
   }
 
   // Detach if our window is a panel, then drag it vertically by |dy| and
   // horizontally to the edge with an added offset from the edge of |dx|.
   void DragVerticallyAndRelativeToEdge(DockedEdge edge,
                                        aura::Window* window,
-                                       int dx, int dy) {
+                                       int dx,
+                                       int dy) {
     gfx::Rect initial_bounds = window->GetBoundsInScreen();
     // avoid snap by clicking away from the border
     ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromwindowOrigin(window, 25, 5));
 
     gfx::Rect work_area = display::Screen::GetScreen()
                               ->GetDisplayNearestWindow(window)
                               .work_area();
     gfx::Point initial_location_in_screen = initial_location_in_parent_;
     ::wm::ConvertPointToScreen(window->parent(), &initial_location_in_screen);
     // Drag the window left or right to the edge (or almost to it).
@@ skipping 79 matching lines @@
       DockedWindowLayoutManager::Get(WmWindowAura::Get(window.get()));
 
   // Create two additional windows and test their auto-placement
   std::unique_ptr<aura::Window> window1(CreateTestWindowInShellWithId(1));
   gfx::Rect desktop_area = window1->parent()->bounds();
   wm::GetWindowState(window1.get())->set_window_position_managed(true);
   window1->Hide();
   window1->SetBounds(gfx::Rect(250, 32, 231, 320));
   window1->Show();
   // |window1| should be centered in work area.
-  EXPECT_EQ(base::IntToString(
-      docked_width(manager) + min_dock_gap() +
-      (desktop_area.width() - docked_width(manager) -
-       min_dock_gap() - window1->bounds().width()) / 2) +
-      ",32 231x320", window1->bounds().ToString());
+  EXPECT_EQ(base::IntToString(docked_width(manager) + min_dock_gap() +
+                              (desktop_area.width() - docked_width(manager) -
+                               min_dock_gap() - window1->bounds().width()) /
+                                  2) +
+                ",32 231x320",
+            window1->bounds().ToString());
 
   std::unique_ptr<aura::Window> window2(CreateTestWindowInShellWithId(2));
   wm::GetWindowState(window2.get())->set_window_position_managed(true);
   // To avoid any auto window manager changes due to SetBounds, the window
   // gets first hidden and then shown again.
   window2->Hide();
   window2->SetBounds(gfx::Rect(250, 48, 150, 300));
   window2->Show();
 
   // |window1| should be flush left and |window2| flush right.
   EXPECT_EQ(
-      base::IntToString(docked_width(manager) + min_dock_gap()) +
-      ",32 231x320", window1->bounds().ToString());
+      base::IntToString(docked_width(manager) + min_dock_gap()) + ",32 231x320",
+      window1->bounds().ToString());
   EXPECT_EQ(
-      base::IntToString(
-          desktop_area.width() - window2->bounds().width()) +
-      ",48 150x300", window2->bounds().ToString());
+      base::IntToString(desktop_area.width() - window2->bounds().width()) +
+          ",48 150x300",
+      window2->bounds().ToString());
 }
 
 // Tests that with a window docked on the right the auto-placing logic in
 // RearrangeVisibleWindowOnShow places windows flush with work area edges.
 TEST_P(DockedWindowLayoutManagerTest, AutoPlacingRight) {
   if (!SupportsHostWindowResize())
     return;
 
   gfx::Rect bounds(0, 0, 201, 201);
   std::unique_ptr<aura::Window> window(CreateTestWindow(bounds));
   DragRelativeToEdge(DOCKED_EDGE_RIGHT, window.get(), 0);
 
   // The window should be attached and snapped to the right side of the screen.
   EXPECT_EQ(window->GetRootWindow()->bounds().right(),
             window->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id());
 
   DockedWindowLayoutManager* manager =
       DockedWindowLayoutManager::Get(WmWindowAura::Get(window.get()));
 
   // Create two additional windows and test their auto-placement
   std::unique_ptr<aura::Window> window1(CreateTestWindowInShellWithId(1));
   gfx::Rect desktop_area = window1->parent()->bounds();
   wm::GetWindowState(window1.get())->set_window_position_managed(true);
   window1->Hide();
   window1->SetBounds(gfx::Rect(16, 32, 231, 320));
   window1->Show();
 
   // |window1| should be centered in work area.
-  EXPECT_EQ(base::IntToString(
-      (desktop_area.width() - docked_width(manager) -
-       min_dock_gap() - window1->bounds().width()) / 2) +
-      ",32 231x320", window1->bounds().ToString());
+  EXPECT_EQ(base::IntToString((desktop_area.width() - docked_width(manager) -
+                               min_dock_gap() - window1->bounds().width()) /
+                              2) +
+                ",32 231x320",
+            window1->bounds().ToString());
 
   std::unique_ptr<aura::Window> window2(CreateTestWindowInShellWithId(2));
   wm::GetWindowState(window2.get())->set_window_position_managed(true);
   // To avoid any auto window manager changes due to SetBounds, the window
   // gets first hidden and then shown again.
   window2->Hide();
   window2->SetBounds(gfx::Rect(32, 48, 256, 512));
   window2->Show();
 
   // |window1| should be flush left and |window2| flush right.
   EXPECT_EQ("0,32 231x320", window1->bounds().ToString());
-  EXPECT_EQ(
-      base::IntToString(
-          desktop_area.width() - window2->bounds().width() -
-          docked_width(manager) - min_dock_gap()) +
-      ",48 256x512", window2->bounds().ToString());
+  EXPECT_EQ(base::IntToString(desktop_area.width() - window2->bounds().width() -
+                              docked_width(manager) - min_dock_gap()) +
+                ",48 256x512",
+            window2->bounds().ToString());
 }
 
 // Tests that with a window docked on the right the auto-placing logic in
 // RearrangeVisibleWindowOnShow places windows flush with work area edges.
 // Test case for the secondary screen.
 TEST_P(DockedWindowLayoutManagerTest, AutoPlacingRightSecondScreen) {
   if (!SupportsMultipleDisplays() || !SupportsHostWindowResize())
     return;
 
   // Create a dual screen layout.
@@ skipping 15 matching lines @@
   // Create two additional windows and test their auto-placement
   bounds = gfx::Rect(616, 32, 231, 320);
   std::unique_ptr<aura::Window> window1(
       CreateTestWindowInShellWithDelegate(nullptr, 1, bounds));
   gfx::Rect desktop_area = window1->parent()->bounds();
   wm::GetWindowState(window1.get())->set_window_position_managed(true);
   window1->Hide();
   window1->Show();
 
   // |window1| should be centered in work area.
-  EXPECT_EQ(base::IntToString(
-      600 + (desktop_area.width() - docked_width(manager) -
-          min_dock_gap() - window1->bounds().width()) / 2) +
-      ",32 231x320", window1->GetBoundsInScreen().ToString());
+  EXPECT_EQ(base::IntToString(600 +
+                              (desktop_area.width() - docked_width(manager) -
+                               min_dock_gap() - window1->bounds().width()) /
+                                  2) +
+                ",32 231x320",
+            window1->GetBoundsInScreen().ToString());
 
   bounds = gfx::Rect(632, 48, 256, 512);
   std::unique_ptr<aura::Window> window2(
       CreateTestWindowInShellWithDelegate(nullptr, 2, bounds));
   wm::GetWindowState(window2.get())->set_window_position_managed(true);
   // To avoid any auto window manager changes due to SetBounds, the window
   // gets first hidden and then shown again.
   window2->Hide();
   window2->Show();
 
   // |window1| should be flush left and |window2| flush right.
   EXPECT_EQ("600,32 231x320", window1->GetBoundsInScreen().ToString());
   EXPECT_EQ(
-      base::IntToString(
-          600 + desktop_area.width() - window2->bounds().width() -
-          docked_width(manager) - min_dock_gap()) +
-      ",48 256x512", window2->GetBoundsInScreen().ToString());
+      base::IntToString(600 + desktop_area.width() - window2->bounds().width() -
+                        docked_width(manager) - min_dock_gap()) +
+          ",48 256x512",
+      window2->GetBoundsInScreen().ToString());
 }
 
 // Adds two windows and tests that the gaps are evenly distributed.
 TEST_P(DockedWindowLayoutManagerTest, AddTwoWindows) {
   if (!SupportsHostWindowResize())
     return;
 
   std::unique_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   std::unique_ptr<aura::Window> w2(CreateTestWindow(gfx::Rect(0, 0, 210, 202)));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20);
@@ skipping 273 matching lines @@
     return;
 
   aura::test::TestWindowDelegate delegate;
   delegate.set_minimum_size(gfx::Size(400, 0));
   std::unique_ptr<aura::Window> window(
       CreateTestWindowWithDelegate(gfx::Rect(0, 0, 400, 201), &delegate));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, window.get(), 20);
 
   // Secondary drag ensures that we are testing the minimum size restriction
   // and not just failure to get past the tiling step in SnapSizer.
-  ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromwindowOrigin(window.get(),
-                                                            25, 5));
-  DragMove(150,0);
+  ASSERT_NO_FATAL_FAILURE(
+      DragStartAtOffsetFromwindowOrigin(window.get(), 25, 5));
+  DragMove(150, 0);
   DragEnd();
 
   // The window should not get docked even though it is dragged past the edge.
   EXPECT_NE(window->GetRootWindow()->bounds().right(),
             window->GetBoundsInScreen().right());
   EXPECT_NE(kShellWindowId_DockedContainer, window->parent()->id());
 }
 
 // Docks three windows and tests that the very first window gets minimized.
 TEST_P(DockedWindowLayoutManagerTest, ThreeWindowsMinimize) {
@@ skipping 48 matching lines @@
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(w2->GetRootWindow()->bounds().right(),
             w2->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id());
 
   // The two windows should be same size vertically and almost 1/2 of work area.
   gfx::Rect work_area = display::Screen::GetScreen()
                             ->GetDisplayNearestWindow(w1.get())
                             .work_area();
   EXPECT_NEAR(w1->GetBoundsInScreen().height(),
-              w2->GetBoundsInScreen().height(),
-              1);
+              w2->GetBoundsInScreen().height(), 1);
   EXPECT_NEAR(work_area.height() / 2, w1->GetBoundsInScreen().height(),
               min_dock_gap() * 2);
 
   // Create and dock the third window.
   std::unique_ptr<aura::Window> w3(CreateTestWindow(gfx::Rect(0, 0, 220, 204)));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w3.get(), 300);
 
   // All three windows should be docked and snapped to the right edge.
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id());
   EXPECT_EQ(kShellWindowId_DockedContainer, w3->parent()->id());
 
   // All windows should be near same size vertically and about 1/3 of work area.
   EXPECT_NEAR(w1->GetBoundsInScreen().height(),
-              w2->GetBoundsInScreen().height(),
-              1);
+              w2->GetBoundsInScreen().height(), 1);
   EXPECT_NEAR(w2->GetBoundsInScreen().height(),
-              w3->GetBoundsInScreen().height(),
-              1);
+              w3->GetBoundsInScreen().height(), 1);
   EXPECT_NEAR(work_area.height() / 3, w1->GetBoundsInScreen().height(),
               min_dock_gap() * 2);
 }
 
 // Docks two windows and tests that restrictions on vertical size are honored.
 TEST_P(DockedWindowLayoutManagerTest, TwoWindowsHeightRestrictions) {
   if (!SupportsHostWindowResize())
     return;
 
   // The first window is fixed height.
@@ skipping 61 matching lines @@
   EXPECT_EQ(work_area.height(), window->GetBoundsInScreen().height());
 }
 
 // Tests run twice - on both panels and normal windows
 INSTANTIATE_TEST_CASE_P(NormalOrPanel,
                         DockedWindowLayoutManagerTest,
                         testing::Values(ui::wm::WINDOW_TYPE_NORMAL,
                                         ui::wm::WINDOW_TYPE_PANEL));
 
 }  // namespace ash