clang-format all of //ash

ash/wm/workspace/workspace_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/workspace/workspace_layout_manager.h"
 
 #include <string>
 #include <utility>
 
 #include "ash/aura/wm_window_aura.h"
@@ skipping 28 matching lines @@
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
 #include "ui/wm/core/window_util.h"
 
 namespace ash {
 namespace {
 
 class MaximizeDelegateView : public views::WidgetDelegateView {
  public:
   explicit MaximizeDelegateView(const gfx::Rect& initial_bounds)
-      : initial_bounds_(initial_bounds) {
-  }
+      : initial_bounds_(initial_bounds) {}
   ~MaximizeDelegateView() override {}
 
   bool GetSavedWindowPlacement(const views::Widget* widget,
                                gfx::Rect* bounds,
                                ui::WindowShowState* show_state) const override {
     *bounds = initial_bounds_;
     *show_state = ui::SHOW_STATE_MAXIMIZED;
     return true;
   }
 
  private:
   const gfx::Rect initial_bounds_;
 
   DISALLOW_COPY_AND_ASSIGN(MaximizeDelegateView);
 };
 
 class TestShellObserver : public ShellObserver {
  public:
-  TestShellObserver() : call_count_(0),
-                        is_fullscreen_(false) {
+  TestShellObserver() : call_count_(0), is_fullscreen_(false) {
     WmShell::Get()->AddShellObserver(this);
   }
 
   ~TestShellObserver() override { WmShell::Get()->RemoveShellObserver(this); }
 
   void OnFullscreenStateChanged(bool is_fullscreen,
                                 WmWindow* root_window) override {
     call_count_++;
     is_fullscreen_ = is_fullscreen;
   }
 
-  int call_count() const {
-    return call_count_;
-  }
+  int call_count() const { return call_count_; }
 
-  bool is_fullscreen() const {
-    return is_fullscreen_;
-  }
+  bool is_fullscreen() const { return is_fullscreen_; }
 
  private:
   int call_count_;
   bool is_fullscreen_;
 
   DISALLOW_COPY_AND_ASSIGN(TestShellObserver);
 };
 
 }  // namespace
 
@@ skipping 171 matching lines @@
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 
   std::unique_ptr<aura::Window> window(
       CreateTestWindowInShellWithBounds(gfx::Rect(1, 2, 30, 40)));
   EXPECT_EQ(root_windows[0], window->GetRootWindow());
 
   wm::WindowState* window_state = wm::GetWindowState(window.get());
   window_state->SetRestoreBoundsInScreen(gfx::Rect(400, 0, 30, 40));
   // Maximize the window in 2nd display as the restore bounds
   // is inside 2nd display.
-  window->SetProperty(aura::client::kShowStateKey,
-                      ui::SHOW_STATE_FULLSCREEN);
+  window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_FULLSCREEN);
   EXPECT_EQ(root_windows[1], window->GetRootWindow());
   EXPECT_EQ("300,0 400x500", window->GetBoundsInScreen().ToString());
 
   window_state->Restore();
   EXPECT_EQ(root_windows[1], window->GetRootWindow());
   EXPECT_EQ("400,0 30x40", window->GetBoundsInScreen().ToString());
 
   // If the restore bounds intersects with the current display,
   // don't move.
   window_state->SetRestoreBoundsInScreen(gfx::Rect(295, 0, 30, 40));
-  window->SetProperty(aura::client::kShowStateKey,
-                      ui::SHOW_STATE_FULLSCREEN);
+  window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_FULLSCREEN);
   EXPECT_EQ(root_windows[1], window->GetRootWindow());
   EXPECT_EQ("300,0 400x500", window->GetBoundsInScreen().ToString());
 
   window_state->Restore();
   EXPECT_EQ(root_windows[1], window->GetRootWindow());
   EXPECT_EQ("295,0 30x40", window->GetBoundsInScreen().ToString());
 }
 
 // WindowObserver implementation used by DontClobberRestoreBoundsWindowObserver.
 // This code mirrors what BrowserFrameAsh does. In particular when this code
@@ skipping 47 matching lines @@
   wm::WindowState* window_state = wm::GetWindowState(window.get());
   window_state->Activate();
 
   std::unique_ptr<aura::Window> window2(
       CreateTestWindowInShellWithBounds(gfx::Rect(12, 20, 30, 40)));
   ::wm::AddTransientChild(window.get(), window2.get());
   window2->Show();
 
   window_observer.set_window(window2.get());
   window_state->Maximize();
-  EXPECT_EQ("10,20 30x40",
-            window_state->GetRestoreBoundsInScreen().ToString());
+  EXPECT_EQ("10,20 30x40", window_state->GetRestoreBoundsInScreen().ToString());
   window->RemoveObserver(&window_observer);
 }
 
 // Verifies when a window is maximized all descendant windows have a size.
 TEST_F(WorkspaceLayoutManagerTest, ChildBoundsResetOnMaximize) {
   std::unique_ptr<aura::Window> window(
       CreateTestWindowInShellWithBounds(gfx::Rect(10, 20, 30, 40)));
   window->Show();
   wm::WindowState* window_state = wm::GetWindowState(window.get());
   window_state->Activate();
@@ skipping 85 matching lines @@
   bounds.Intersect(root_window_bounds);
   EXPECT_GT(bounds.width(), out_window->bounds().width() * 0.29);
   EXPECT_GT(bounds.height(), out_window->bounds().height() * 0.29);
 }
 
 // Verifies the size of a window is enforced to be smaller than the work area.
 TEST_F(WorkspaceLayoutManagerTest, SizeToWorkArea) {
   // Normal window bounds shouldn't be changed.
   gfx::Size work_area(
       display::Screen::GetScreen()->GetPrimaryDisplay().work_area().size());
-  const gfx::Rect window_bounds(
-      100, 101, work_area.width() + 1, work_area.height() + 2);
+  const gfx::Rect window_bounds(100, 101, work_area.width() + 1,
+                                work_area.height() + 2);
   std::unique_ptr<aura::Window> window(
       CreateTestWindowInShellWithBounds(window_bounds));
   EXPECT_EQ(gfx::Rect(gfx::Point(100, 101), work_area).ToString(),
-      window->bounds().ToString());
+            window->bounds().ToString());
 
   // Directly setting the bounds triggers a slightly different code path. Verify
   // that too.
   window->SetBounds(window_bounds);
   EXPECT_EQ(gfx::Rect(gfx::Point(100, 101), work_area).ToString(),
-      window->bounds().ToString());
+            window->bounds().ToString());
 }
 
 TEST_F(WorkspaceLayoutManagerTest, NotifyFullscreenChanges) {
   TestShellObserver observer;
   std::unique_ptr<aura::Window> window1(
       CreateTestWindowInShellWithBounds(gfx::Rect(1, 2, 30, 40)));
   std::unique_ptr<aura::Window> window2(
       CreateTestWindowInShellWithBounds(gfx::Rect(1, 2, 30, 40)));
   wm::WindowState* window_state1 = wm::GetWindowState(window1.get());
   wm::WindowState* window_state2 = wm::GetWindowState(window2.get());
@@ skipping 416 matching lines @@
   // Return the order of windows (top most first) as they are in the default
   // container. If the window is visible it will be a big letter, otherwise a
   // small one. The backdrop will be an X and unknown windows will be shown as
   // '!'.
   std::string GetWindowOrderAsString(aura::Window* backdrop,
                                      aura::Window* wa,
                                      aura::Window* wb,
                                      aura::Window* wc) {
     std::string result;
     for (int i = static_cast<int>(default_container()->children().size()) - 1;
-         i >= 0;
-         --i) {
+         i >= 0; --i) {
       if (!result.empty())
         result += ",";
       if (default_container()->children()[i] == wa)
         result += default_container()->children()[i]->IsVisible() ? "A" : "a";
       else if (default_container()->children()[i] == wb)
         result += default_container()->children()[i]->IsVisible() ? "B" : "b";
       else if (default_container()->children()[i] == wc)
         result += default_container()->children()[i]->IsVisible() ? "C" : "c";
       else if (default_container()->children()[i] == backdrop)
         result += default_container()->children()[i]->IsVisible() ? "X" : "x";
@@ skipping 63 matching lines @@
 
   // Create 2 more windows and check that they are also in the container.
   std::unique_ptr<aura::Window> window2(
       CreateTestWindow(gfx::Rect(10, 2, 3, 4)));
   std::unique_ptr<aura::Window> window3(
       CreateTestWindow(gfx::Rect(20, 2, 3, 4)));
   window2->Show();
   window3->Show();
 
   aura::Window* backdrop = nullptr;
-  EXPECT_EQ("C,B,A",
-            GetWindowOrderAsString(backdrop, window1.get(), window2.get(),
-                                   window3.get()));
+  EXPECT_EQ("C,B,A", GetWindowOrderAsString(backdrop, window1.get(),
+                                            window2.get(), window3.get()));
 
   // Turn on the backdrop mode and check that the window shows up where it
   // should be (second highest number).
   ShowTopWindowBackdrop(true);
   backdrop = default_container()->children()[2];
-  EXPECT_EQ("C,X,B,A",
-            GetWindowOrderAsString(backdrop, window1.get(), window2.get(),
-                                   window3.get()));
+  EXPECT_EQ("C,X,B,A", GetWindowOrderAsString(backdrop, window1.get(),
+                                              window2.get(), window3.get()));
 
   // Switch the order of windows and check that it still remains in that
   // location.
   default_container()->StackChildAtTop(window2.get());
-  EXPECT_EQ("B,X,C,A",
-            GetWindowOrderAsString(backdrop, window1.get(), window2.get(),
-                                   window3.get()));
+  EXPECT_EQ("B,X,C,A", GetWindowOrderAsString(backdrop, window1.get(),
+                                              window2.get(), window3.get()));
 
   // Make the top window invisible and check.
   window2.get()->Hide();
-  EXPECT_EQ("b,C,X,A",
-            GetWindowOrderAsString(backdrop, window1.get(), window2.get(),
-                                   window3.get()));
+  EXPECT_EQ("b,C,X,A", GetWindowOrderAsString(backdrop, window1.get(),
+                                              window2.get(), window3.get()));
   // Then delete window after window and see that everything is in order.
   window1.reset();
-  EXPECT_EQ("b,C,X",
-            GetWindowOrderAsString(backdrop, window1.get(), window2.get(),
-                                   window3.get()));
+  EXPECT_EQ("b,C,X", GetWindowOrderAsString(backdrop, window1.get(),
+                                            window2.get(), window3.get()));
   window3.reset();
-  EXPECT_EQ("b,x",
-            GetWindowOrderAsString(backdrop, window1.get(), window2.get(),
-                                   window3.get()));
+  EXPECT_EQ("b,x", GetWindowOrderAsString(backdrop, window1.get(),
+                                          window2.get(), window3.get()));
   ShowTopWindowBackdrop(false);
   EXPECT_EQ("b", GetWindowOrderAsString(nullptr, window1.get(), window2.get(),
                                         window3.get()));
 }
 
 // Tests that when hidding the shelf, that the backdrop resizes to fill the
 // entire workspace area.
 TEST_F(WorkspaceLayoutManagerBackdropTest, ShelfVisibilityChangesBounds) {
   Shelf* shelf = Shelf::ForPrimaryDisplay();
   ShelfLayoutManager* shelf_layout_manager = shelf->shelf_layout_manager();
@@ skipping 40 matching lines @@
     layout_manager_->OnKeyboardBoundsChanging(keyboard_bounds_);
     restore_work_area_insets_ =
         display::Screen::GetScreen()->GetPrimaryDisplay().GetWorkAreaInsets();
     Shell::GetInstance()->SetDisplayWorkAreaInsets(
         Shell::GetPrimaryRootWindow(),
         gfx::Insets(0, 0, keyboard_bounds_.height(), 0));
   }
 
   void HideKeyboard() {
     Shell::GetInstance()->SetDisplayWorkAreaInsets(
-        Shell::GetPrimaryRootWindow(),
-        restore_work_area_insets_);
+        Shell::GetPrimaryRootWindow(), restore_work_area_insets_);
     layout_manager_->OnKeyboardBoundsChanging(gfx::Rect());
   }
 
-  void SetKeyboardBounds(const gfx::Rect& bounds) {
-    keyboard_bounds_ = bounds;
-  }
+  void SetKeyboardBounds(const gfx::Rect& bounds) { keyboard_bounds_ = bounds; }
 
  private:
   gfx::Insets restore_work_area_insets_;
   gfx::Rect keyboard_bounds_;
   WorkspaceLayoutManager* layout_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(WorkspaceLayoutManagerKeyboardTest);
 };
 
 // Tests that when a child window gains focus the top level window containing it
 // is resized to fit the remaining workspace area.
 TEST_F(WorkspaceLayoutManagerKeyboardTest, ChildWindowFocused) {
   gfx::Rect work_area(
       display::Screen::GetScreen()->GetPrimaryDisplay().work_area());
   gfx::Rect keyboard_bounds(work_area.x(),
                             work_area.y() + work_area.height() / 2,
-                            work_area.width(),
-                            work_area.height() / 2);
+                            work_area.width(), work_area.height() / 2);
 
   SetKeyboardBounds(keyboard_bounds);
 
   aura::test::TestWindowDelegate delegate1;
   std::unique_ptr<aura::Window> parent_window(
       CreateTestWindowInShellWithDelegate(&delegate1, -1, work_area));
   aura::test::TestWindowDelegate delegate2;
   std::unique_ptr<aura::Window> window(
       CreateTestWindowInShellWithDelegate(&delegate2, -1, work_area));
   parent_window->AddChild(window.get());
@@ skipping 14 matching lines @@
   HideKeyboard();
   EXPECT_EQ(initial_window_bounds.ToString(),
             parent_window->bounds().ToString());
 }
 
 TEST_F(WorkspaceLayoutManagerKeyboardTest, AdjustWindowForA11yKeyboard) {
   gfx::Rect work_area(
       display::Screen::GetScreen()->GetPrimaryDisplay().work_area());
   gfx::Rect keyboard_bounds(work_area.x(),
                             work_area.y() + work_area.height() / 2,
-                            work_area.width(),
-                            work_area.height() / 2);
+                            work_area.width(), work_area.height() / 2);
 
   SetKeyboardBounds(keyboard_bounds);
 
   aura::test::TestWindowDelegate delegate;
   std::unique_ptr<aura::Window> window(
       CreateTestWindowInShellWithDelegate(&delegate, -1, work_area));
 
   int available_height =
       display::Screen::GetScreen()->GetPrimaryDisplay().bounds().height() -
       keyboard_bounds.height();
 
   wm::ActivateWindow(window.get());
 
   EXPECT_EQ(gfx::Rect(work_area).ToString(), window->bounds().ToString());
   ShowKeyboard();
   EXPECT_EQ(gfx::Rect(work_area.origin(),
-            gfx::Size(work_area.width(), available_height)).ToString(),
+                      gfx::Size(work_area.width(), available_height))
+                .ToString(),
             window->bounds().ToString());
   HideKeyboard();
   EXPECT_EQ(gfx::Rect(work_area).ToString(), window->bounds().ToString());
 
   gfx::Rect small_window_bound(50, 50, 100, 500);
   window->SetBounds(small_window_bound);
   EXPECT_EQ(small_window_bound.ToString(), window->bounds().ToString());
   ShowKeyboard();
   EXPECT_EQ(gfx::Rect(50, 0, 100, available_height).ToString(),
             window->bounds().ToString());
   HideKeyboard();
   EXPECT_EQ(small_window_bound.ToString(), window->bounds().ToString());
 
-  gfx::Rect occluded_window_bounds(50,
-      keyboard_bounds.y() + keyboard_bounds.height()/2, 50,
-      keyboard_bounds.height()/2);
+  gfx::Rect occluded_window_bounds(
+      50, keyboard_bounds.y() + keyboard_bounds.height() / 2, 50,
+      keyboard_bounds.height() / 2);
   window->SetBounds(occluded_window_bounds);
   EXPECT_EQ(occluded_window_bounds.ToString(),
-      occluded_window_bounds.ToString());
+            occluded_window_bounds.ToString());
   ShowKeyboard();
-  EXPECT_EQ(gfx::Rect(50,
-                      keyboard_bounds.y() - keyboard_bounds.height()/2,
-                      occluded_window_bounds.width(),
-                      occluded_window_bounds.height()).ToString(),
-            window->bounds().ToString());
+  EXPECT_EQ(
+      gfx::Rect(50, keyboard_bounds.y() - keyboard_bounds.height() / 2,
+                occluded_window_bounds.width(), occluded_window_bounds.height())
+          .ToString(),
+      window->bounds().ToString());
   HideKeyboard();
   EXPECT_EQ(occluded_window_bounds.ToString(), window->bounds().ToString());
 }
 
 }  // namespace ash