clang-format all of //ash

ash/wm/window_state_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/common/wm/window_state.h"
 
 #include <utility>
 
 #include "ash/common/material_design/material_design_controller.h"
 #include "ash/common/wm/window_state.h"
@@ skipping 58 matching lines @@
   const gfx::Rect kPrimaryDisplayWorkAreaBounds =
       display::Screen::GetScreen()->GetPrimaryDisplay().work_area();
   const gfx::Rect kSecondaryDisplayWorkAreaBounds =
       ScreenUtil::GetSecondaryDisplay().work_area();
 
   std::unique_ptr<aura::Window> window(
       CreateTestWindowInShellWithBounds(gfx::Rect(100, 100, 100, 100)));
   WindowState* window_state = GetWindowState(window.get());
   const WMEvent snap_left(WM_EVENT_SNAP_LEFT);
   window_state->OnWMEvent(&snap_left);
-  gfx::Rect expected = gfx::Rect(
-      kPrimaryDisplayWorkAreaBounds.x(),
-      kPrimaryDisplayWorkAreaBounds.y(),
-      kPrimaryDisplayWorkAreaBounds.width() / 2,
-      kPrimaryDisplayWorkAreaBounds.height());
+  gfx::Rect expected = gfx::Rect(kPrimaryDisplayWorkAreaBounds.x(),
+                                 kPrimaryDisplayWorkAreaBounds.y(),
+                                 kPrimaryDisplayWorkAreaBounds.width() / 2,
+                                 kPrimaryDisplayWorkAreaBounds.height());
   EXPECT_EQ(expected.ToString(), window->GetBoundsInScreen().ToString());
 
   const WMEvent snap_right(WM_EVENT_SNAP_RIGHT);
   window_state->OnWMEvent(&snap_right);
   expected.set_x(kPrimaryDisplayWorkAreaBounds.right() - expected.width());
   EXPECT_EQ(expected.ToString(), window->GetBoundsInScreen().ToString());
 
   // Move the window to the secondary display.
   window->SetBoundsInScreen(gfx::Rect(600, 0, 100, 100),
                             ScreenUtil::GetSecondaryDisplay());
 
   window_state->OnWMEvent(&snap_right);
-  expected = gfx::Rect(
-      kSecondaryDisplayWorkAreaBounds.x() +
-          kSecondaryDisplayWorkAreaBounds.width() / 2,
-      kSecondaryDisplayWorkAreaBounds.y(),
-      kSecondaryDisplayWorkAreaBounds.width() / 2,
-      kSecondaryDisplayWorkAreaBounds.height());
+  expected = gfx::Rect(kSecondaryDisplayWorkAreaBounds.x() +
+                           kSecondaryDisplayWorkAreaBounds.width() / 2,
+                       kSecondaryDisplayWorkAreaBounds.y(),
+                       kSecondaryDisplayWorkAreaBounds.width() / 2,
+                       kSecondaryDisplayWorkAreaBounds.height());
   EXPECT_EQ(expected.ToString(), window->GetBoundsInScreen().ToString());
 
   window_state->OnWMEvent(&snap_left);
   expected.set_x(kSecondaryDisplayWorkAreaBounds.x());
   EXPECT_EQ(expected.ToString(), window->GetBoundsInScreen().ToString());
 }
 
 // Test how the minimum and maximum size specified by the aura::WindowDelegate
 // affect snapping.
 TEST_P(WindowStateTest, SnapWindowMinimumSize) {
   if (!SupportsHostWindowResize())
     return;
 
   UpdateDisplay("0+0-600x900");
   const gfx::Rect kWorkAreaBounds =
       display::Screen::GetScreen()->GetPrimaryDisplay().work_area();
 
   aura::test::TestWindowDelegate delegate;
   std::unique_ptr<aura::Window> window(CreateTestWindowInShellWithDelegate(
       &delegate, -1, gfx::Rect(0, 100, kWorkAreaBounds.width() - 1, 100)));
 
   // It should be possible to snap a window with a minimum size.
   delegate.set_minimum_size(gfx::Size(kWorkAreaBounds.width() - 1, 0));
   WindowState* window_state = GetWindowState(window.get());
   EXPECT_TRUE(window_state->CanSnap());
   const WMEvent snap_right(WM_EVENT_SNAP_RIGHT);
   window_state->OnWMEvent(&snap_right);
-  gfx::Rect expected = gfx::Rect(kWorkAreaBounds.x() + 1,
-                                 kWorkAreaBounds.y(),
-                                 kWorkAreaBounds.width() - 1,
-                                 kWorkAreaBounds.height());
+  gfx::Rect expected =
+      gfx::Rect(kWorkAreaBounds.x() + 1, kWorkAreaBounds.y(),
+                kWorkAreaBounds.width() - 1, kWorkAreaBounds.height());
   EXPECT_EQ(expected.ToString(), window->GetBoundsInScreen().ToString());
 
   // It should not be possible to snap a window with a maximum size, or if it
   // cannot be maximized.
   delegate.set_maximum_size(gfx::Size(kWorkAreaBounds.width() - 1, 0));
   EXPECT_FALSE(window_state->CanSnap());
   delegate.set_maximum_size(gfx::Size(0, kWorkAreaBounds.height() - 1));
   EXPECT_FALSE(window_state->CanSnap());
   delegate.set_maximum_size(gfx::Size());
   window->SetProperty(aura::client::kCanMaximizeKey, false);
@@ skipping 69 matching lines @@
   UpdateDisplay("0+0-900x600");
   const gfx::Rect kWorkAreaBounds =
       display::Screen::GetScreen()->GetPrimaryDisplay().work_area();
 
   std::unique_ptr<aura::Window> window(
       CreateTestWindowInShellWithBounds(gfx::Rect(100, 100, 100, 100)));
   WindowState* window_state = GetWindowState(window.get());
   const WMEvent snap_left(WM_EVENT_SNAP_LEFT);
   window_state->OnWMEvent(&snap_left);
   EXPECT_EQ(WINDOW_STATE_TYPE_LEFT_SNAPPED, window_state->GetStateType());
-  gfx::Rect expected = gfx::Rect(kWorkAreaBounds.x(),
-                                 kWorkAreaBounds.y(),
-                                 kWorkAreaBounds.width() / 2,
-                                 kWorkAreaBounds.height());
+  gfx::Rect expected =
+      gfx::Rect(kWorkAreaBounds.x(), kWorkAreaBounds.y(),
+                kWorkAreaBounds.width() / 2, kWorkAreaBounds.height());
   EXPECT_EQ(expected.ToString(), window->GetBoundsInScreen().ToString());
 
   // Snapped windows can have any width.
   expected.set_width(500);
   window->SetBounds(gfx::Rect(10, 10, 500, 300));
   EXPECT_EQ(expected.ToString(), window->GetBoundsInScreen().ToString());
   EXPECT_EQ(WINDOW_STATE_TYPE_LEFT_SNAPPED, window_state->GetStateType());
 }
 
 // Test that snapping left/right preserves the restore bounds.
@@ skipping 46 matching lines @@
   window->SetBounds(gfx::Rect(100, 100, 100, 100));
   window->Show();
 
   window_state->Maximize();
   const WMEvent snap_right(WM_EVENT_SNAP_RIGHT);
   window_state->OnWMEvent(&snap_right);
 
   const gfx::Rect kWorkAreaBounds =
       display::Screen::GetScreen()->GetPrimaryDisplay().work_area();
   gfx::Rect expected_snapped_bounds(
-      kWorkAreaBounds.x() + kWorkAreaBounds.width() / 2,
-      kWorkAreaBounds.y(),
-      kWorkAreaBounds.width() / 2,
-      kWorkAreaBounds.height());
+      kWorkAreaBounds.x() + kWorkAreaBounds.width() / 2, kWorkAreaBounds.y(),
+      kWorkAreaBounds.width() / 2, kWorkAreaBounds.height());
   EXPECT_EQ(expected_snapped_bounds.ToString(),
             window->GetBoundsInScreen().ToString());
 
   // The window should still be auto managed despite being right maximized.
   EXPECT_TRUE(window_state->window_position_managed());
 }
 
 // Test that the replacement of a State object works as expected.
 TEST_P(WindowStateTest, SimpleStateSwap) {
   std::unique_ptr<aura::Window> window(CreateTestWindowInShellWithId(0));
@@ skipping 73 matching lines @@
   // Exiting fullscreen will update the maximized window to the work area.
   EXPECT_EQ(gfx::Rect(0, 0, 900, 653 + height_offset).ToString(),
             maximized->GetBoundsInScreen().ToString());
 }
 
 // TODO(skuhne): Add more unit test to verify the correctness for the restore
 // operation.
 
 }  // namespace wm
 }  // namespace ash