clang-format all of //ash

ash/root_window_controller_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/root_window_controller.h"
 
 #include <memory>
 
 #include "ash/common/material_design/material_design_controller.h"
 #include "ash/common/session/session_state_delegate.h"
@@ skipping 99 matching lines @@
 
   views::Widget* CreateModalWidget(const gfx::Rect& bounds) {
     views::Widget* widget = views::Widget::CreateWindowWithContextAndBounds(
         new TestDelegate(true), CurrentContext(), bounds);
     widget->Show();
     return widget;
   }
 
   views::Widget* CreateModalWidgetWithParent(const gfx::Rect& bounds,
                                              gfx::NativeWindow parent) {
-    views::Widget* widget =
-        views::Widget::CreateWindowWithParentAndBounds(new TestDelegate(true),
-                                                       parent,
-                                                       bounds);
+    views::Widget* widget = views::Widget::CreateWindowWithParentAndBounds(
+        new TestDelegate(true), parent, bounds);
     widget->Show();
     return widget;
   }
 
   aura::Window* GetModalContainer(aura::Window* root_window) {
     return Shell::GetContainer(root_window,
                                ash::kShellWindowId_SystemModalContainer);
   }
 };
 
@@ skipping 23 matching lines @@
   maximized->Maximize();
   EXPECT_EQ(root_windows[1], maximized->GetNativeView()->GetRootWindow());
   EXPECT_EQ(gfx::Rect(600, 0, 300, 253 + height_offset).ToString(),
             maximized->GetWindowBoundsInScreen().ToString());
   EXPECT_EQ(gfx::Rect(0, 0, 300, 253 + height_offset).ToString(),
             maximized->GetNativeView()->GetBoundsInRootWindow().ToString());
 
   views::Widget* minimized = CreateTestWidget(gfx::Rect(800, 10, 100, 100));
   minimized->Minimize();
   EXPECT_EQ(root_windows[1], minimized->GetNativeView()->GetRootWindow());
-  EXPECT_EQ("800,10 100x100",
-            minimized->GetWindowBoundsInScreen().ToString());
+  EXPECT_EQ("800,10 100x100", minimized->GetWindowBoundsInScreen().ToString());
 
   views::Widget* fullscreen = CreateTestWidget(gfx::Rect(850, 10, 100, 100));
   fullscreen->SetFullscreen(true);
   EXPECT_EQ(root_windows[1], fullscreen->GetNativeView()->GetRootWindow());
 
-  EXPECT_EQ("600,0 300x300",
-            fullscreen->GetWindowBoundsInScreen().ToString());
+  EXPECT_EQ("600,0 300x300", fullscreen->GetWindowBoundsInScreen().ToString());
   EXPECT_EQ("0,0 300x300",
             fullscreen->GetNativeView()->GetBoundsInRootWindow().ToString());
 
   views::Widget* unparented_control = new Widget;
   Widget::InitParams params;
   params.bounds = gfx::Rect(650, 10, 100, 100);
   params.context = CurrentContext();
   params.type = Widget::InitParams::TYPE_CONTROL;
   unparented_control->Init(params);
   EXPECT_EQ(root_windows[1],
@@ skipping 41 matching lines @@
   // Set fullscreen to true, but maximized window's size won't change because
   // it's not visible. see crbug.com/504299.
   fullscreen->SetFullscreen(true);
   EXPECT_EQ(root_windows[0], maximized->GetNativeView()->GetRootWindow());
   EXPECT_EQ(gfx::Rect(0, 0, 600, 553 + height_offset).ToString(),
             maximized->GetWindowBoundsInScreen().ToString());
   EXPECT_EQ(gfx::Rect(0, 0, 600, 553 + height_offset).ToString(),
             maximized->GetNativeView()->GetBoundsInRootWindow().ToString());
 
   EXPECT_EQ(root_windows[0], minimized->GetNativeView()->GetRootWindow());
-  EXPECT_EQ("400,20 100x100",
-            minimized->GetWindowBoundsInScreen().ToString());
+  EXPECT_EQ("400,20 100x100", minimized->GetWindowBoundsInScreen().ToString());
 
   EXPECT_EQ(root_windows[0], fullscreen->GetNativeView()->GetRootWindow());
   EXPECT_TRUE(fullscreen->IsFullscreen());
-  EXPECT_EQ("0,0 600x600",
-            fullscreen->GetWindowBoundsInScreen().ToString());
+  EXPECT_EQ("0,0 600x600", fullscreen->GetWindowBoundsInScreen().ToString());
   EXPECT_EQ("0,0 600x600",
             fullscreen->GetNativeView()->GetBoundsInRootWindow().ToString());
 
   // Test if the restore bounds are correctly updated.
   wm::GetWindowState(maximized->GetNativeView())->Restore();
   EXPECT_EQ("200,20 100x100", maximized->GetWindowBoundsInScreen().ToString());
   EXPECT_EQ("200,20 100x100",
             maximized->GetNativeView()->GetBoundsInRootWindow().ToString());
 
   fullscreen->SetFullscreen(false);
-  EXPECT_EQ("500,20 100x100",
-            fullscreen->GetWindowBoundsInScreen().ToString());
+  EXPECT_EQ("500,20 100x100", fullscreen->GetWindowBoundsInScreen().ToString());
   EXPECT_EQ("500,20 100x100",
             fullscreen->GetNativeView()->GetBoundsInRootWindow().ToString());
 
   // Test if the unparented widget has moved.
   EXPECT_EQ(root_windows[0],
             unparented_control->GetNativeView()->GetRootWindow());
   EXPECT_EQ(kShellWindowId_UnparentedControlContainer,
             unparented_control->GetNativeView()->parent()->id());
 
   // Test if the panel has moved.
@@ skipping 11 matching lines @@
   // Emulate virtual screen coordinate system.
   root_windows[0]->SetBounds(gfx::Rect(0, 0, 500, 500));
   root_windows[1]->SetBounds(gfx::Rect(500, 0, 500, 500));
 
   views::Widget* normal = CreateTestWidget(gfx::Rect(300, 10, 100, 100));
   EXPECT_EQ(root_windows[0], normal->GetNativeView()->GetRootWindow());
   EXPECT_TRUE(wm::IsActiveWindow(normal->GetNativeView()));
 
   views::Widget* modal = CreateModalWidget(gfx::Rect(650, 10, 100, 100));
   EXPECT_EQ(root_windows[1], modal->GetNativeView()->GetRootWindow());
-  EXPECT_TRUE(GetModalContainer(root_windows[1])->Contains(
-      modal->GetNativeView()));
+  EXPECT_TRUE(
+      GetModalContainer(root_windows[1])->Contains(modal->GetNativeView()));
   EXPECT_TRUE(wm::IsActiveWindow(modal->GetNativeView()));
 
   ui::test::EventGenerator generator_1st(root_windows[0]);
   generator_1st.ClickLeftButton();
   EXPECT_TRUE(wm::IsActiveWindow(modal->GetNativeView()));
 
   UpdateDisplay("500x500");
   EXPECT_EQ(root_windows[0], modal->GetNativeView()->GetRootWindow());
   EXPECT_TRUE(wm::IsActiveWindow(modal->GetNativeView()));
   generator_1st.ClickLeftButton();
@@ skipping 156 matching lines @@
   SetSessionStarted(true);
   EXPECT_EQ(LoginStatus::USER,
             wm_shell->system_tray_delegate()->GetUserLoginStatus());
   EXPECT_EQ(1, shell->session_state_delegate()->NumberOfLoggedInUsers());
   EXPECT_TRUE(shell->session_state_delegate()->IsActiveUserSessionStarted());
   EXPECT_EQ(controller->GetContainer(kShellWindowId_SystemModalContainer)
                 ->layout_manager(),
             controller->GetSystemModalLayoutManager(NULL));
 
   views::Widget* session_modal_widget =
-        CreateModalWidget(gfx::Rect(300, 10, 100, 100));
+      CreateModalWidget(gfx::Rect(300, 10, 100, 100));
   EXPECT_EQ(controller->GetContainer(kShellWindowId_SystemModalContainer)
                 ->layout_manager(),
             controller->GetSystemModalLayoutManager(
                 session_modal_widget->GetNativeView()));
 }
 
 TEST_P(RootWindowControllerTest, ModalContainerBlockedSession) {
   UpdateDisplay("600x600");
   RootWindowController* controller = Shell::GetPrimaryRootWindowController();
   aura::Window* lock_container =
       controller->GetContainer(kShellWindowId_LockScreenContainer);
   for (int block_reason = FIRST_BLOCK_REASON;
-       block_reason < NUMBER_OF_BLOCK_REASONS;
-       ++block_reason) {
+       block_reason < NUMBER_OF_BLOCK_REASONS; ++block_reason) {
     views::Widget* session_modal_widget =
-          CreateModalWidget(gfx::Rect(300, 10, 100, 100));
+        CreateModalWidget(gfx::Rect(300, 10, 100, 100));
     EXPECT_EQ(controller->GetContainer(kShellWindowId_SystemModalContainer)
                   ->layout_manager(),
               controller->GetSystemModalLayoutManager(
                   session_modal_widget->GetNativeView()));
     EXPECT_EQ(controller->GetContainer(kShellWindowId_SystemModalContainer)
                   ->layout_manager(),
               controller->GetSystemModalLayoutManager(NULL));
     session_modal_widget->Close();
 
     BlockUserSession(static_cast<UserSessionBlockReason>(block_reason));
 
     EXPECT_EQ(controller->GetContainer(kShellWindowId_LockSystemModalContainer)
                   ->layout_manager(),
               controller->GetSystemModalLayoutManager(NULL));
 
-    views::Widget* lock_modal_widget =
-        CreateModalWidgetWithParent(gfx::Rect(300, 10, 100, 100),
-                                    lock_container);
+    views::Widget* lock_modal_widget = CreateModalWidgetWithParent(
+        gfx::Rect(300, 10, 100, 100), lock_container);
     EXPECT_EQ(controller->GetContainer(kShellWindowId_LockSystemModalContainer)
                   ->layout_manager(),
               controller->GetSystemModalLayoutManager(
                   lock_modal_widget->GetNativeView()));
 
-    session_modal_widget =
-          CreateModalWidget(gfx::Rect(300, 10, 100, 100));
+    session_modal_widget = CreateModalWidget(gfx::Rect(300, 10, 100, 100));
     EXPECT_EQ(controller->GetContainer(kShellWindowId_SystemModalContainer)
                   ->layout_manager(),
               controller->GetSystemModalLayoutManager(
                   session_modal_widget->GetNativeView()));
     session_modal_widget->Close();
 
     lock_modal_widget->Close();
     UnblockUserSession();
   }
 }
 
 TEST_P(RootWindowControllerTest, GetWindowForFullscreenMode) {
   UpdateDisplay("600x600");
   RootWindowController* controller =
       Shell::GetInstance()->GetPrimaryRootWindowController();
 
   Widget* w1 = CreateTestWidget(gfx::Rect(0, 0, 100, 100));
   w1->Maximize();
   Widget* w2 = CreateTestWidget(gfx::Rect(0, 0, 100, 100));
   w2->SetFullscreen(true);
   // |w3| is a transient child of |w2|.
-  Widget* w3 = Widget::CreateWindowWithParentAndBounds(NULL,
-      w2->GetNativeWindow(), gfx::Rect(0, 0, 100, 100));
+  Widget* w3 = Widget::CreateWindowWithParentAndBounds(
+      NULL, w2->GetNativeWindow(), gfx::Rect(0, 0, 100, 100));
 
   // Test that GetWindowForFullscreenMode() finds the fullscreen window when one
   // of its transient children is active.
   w3->Activate();
   EXPECT_EQ(w2->GetNativeWindow(), controller->GetWindowForFullscreenMode());
 
   // If the topmost window is not fullscreen, it returns NULL.
   w1->Activate();
   EXPECT_EQ(NULL, controller->GetWindowForFullscreenMode());
   w1->Close();
@@ skipping 76 matching lines @@
 }
 
 // Test that user session window can't be focused if user session blocked by
 // some overlapping UI.
 TEST_P(RootWindowControllerTest, FocusBlockedWindow) {
   UpdateDisplay("600x600");
   RootWindowController* controller =
       Shell::GetInstance()->GetPrimaryRootWindowController();
   aura::Window* lock_container =
       controller->GetContainer(kShellWindowId_LockScreenContainer);
-  aura::Window* lock_window = Widget::CreateWindowWithParentAndBounds(NULL,
-      lock_container, gfx::Rect(0, 0, 100, 100))->GetNativeView();
+  aura::Window* lock_window =
+      Widget::CreateWindowWithParentAndBounds(NULL, lock_container,
+                                              gfx::Rect(0, 0, 100, 100))
+          ->GetNativeView();
   lock_window->Show();
   aura::Window* session_window =
       CreateTestWidget(gfx::Rect(0, 0, 100, 100))->GetNativeView();
   session_window->Show();
 
   for (int block_reason = FIRST_BLOCK_REASON;
-       block_reason < NUMBER_OF_BLOCK_REASONS;
-       ++block_reason) {
+       block_reason < NUMBER_OF_BLOCK_REASONS; ++block_reason) {
     BlockUserSession(static_cast<UserSessionBlockReason>(block_reason));
     lock_window->Focus();
     EXPECT_TRUE(lock_window->HasFocus());
     session_window->Focus();
     EXPECT_FALSE(session_window->HasFocus());
     UnblockUserSession();
   }
 }
 
 // Tracks whether OnWindowDestroying() has been invoked.
@@ skipping 84 matching lines @@
     Shell::GetPrimaryRootWindowController()->ActivateKeyboard(
         keyboard::KeyboardController::GetInstance());
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(VirtualKeyboardRootWindowControllerTest);
 };
 
 class MockTextInputClient : public ui::DummyTextInputClient {
  public:
-  MockTextInputClient() :
-      ui::DummyTextInputClient(ui::TEXT_INPUT_TYPE_TEXT) {}
+  MockTextInputClient() : ui::DummyTextInputClient(ui::TEXT_INPUT_TYPE_TEXT) {}
 
   void EnsureCaretInRect(const gfx::Rect& rect) override {
     visible_rect_ = rect;
   }
 
-  const gfx::Rect& visible_rect() const {
-    return visible_rect_;
-  }
+  const gfx::Rect& visible_rect() const { return visible_rect_; }
 
  private:
   gfx::Rect visible_rect_;
 
   DISALLOW_COPY_AND_ASSIGN(MockTextInputClient);
 };
 
 class TargetHitTestEventHandler : public ui::test::TestEventHandler {
  public:
   TargetHitTestEventHandler() {}
@@ skipping 13 matching lines @@
 // on primary root window.
 TEST_F(VirtualKeyboardRootWindowControllerTest,
        VirtualKeyboardOnPrimaryRootWindowOnly) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("500x500,500x500");
 
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
   aura::Window* primary_root_window = Shell::GetPrimaryRootWindow();
-  aura::Window* secondary_root_window =
-      root_windows[0] == primary_root_window ?
-          root_windows[1] : root_windows[0];
+  aura::Window* secondary_root_window = root_windows[0] == primary_root_window
+                                            ? root_windows[1]
+                                            : root_windows[0];
 
   ASSERT_TRUE(Shell::GetContainer(primary_root_window,
                                   kShellWindowId_VirtualKeyboardContainer));
   ASSERT_FALSE(Shell::GetContainer(secondary_root_window,
                                    kShellWindowId_VirtualKeyboardContainer));
 }
 
 // Test for http://crbug.com/263599. Virtual keyboard should be able to receive
 // events at blocked user session.
 TEST_F(VirtualKeyboardRootWindowControllerTest,
@@ skipping 13 matching lines @@
 
   ui::test::TestEventHandler handler;
   root_window->AddPreTargetHandler(&handler);
 
   ui::test::EventGenerator event_generator(root_window, keyboard_window);
   event_generator.ClickLeftButton();
   int expected_mouse_presses = 1;
   EXPECT_EQ(expected_mouse_presses, handler.num_mouse_events() / 2);
 
   for (int block_reason = FIRST_BLOCK_REASON;
-       block_reason < NUMBER_OF_BLOCK_REASONS;
-       ++block_reason) {
+       block_reason < NUMBER_OF_BLOCK_REASONS; ++block_reason) {
     BlockUserSession(static_cast<UserSessionBlockReason>(block_reason));
     event_generator.ClickLeftButton();
     expected_mouse_presses++;
     EXPECT_EQ(expected_mouse_presses, handler.num_mouse_events() / 2);
     UnblockUserSession();
   }
   root_window->RemovePreTargetHandler(&handler);
 }
 
 // Test for http://crbug.com/299787. RootWindowController should delete
@@ skipping 63 matching lines @@
   keyboard_window->set_owned_by_parent(false);
   keyboard_window->SetBounds(keyboard::FullWidthKeyboardBoundsFromRootBounds(
       root_window->bounds(), 100));
 
   ui::test::TestEventHandler handler;
   root_window->AddPreTargetHandler(&handler);
   ui::test::EventGenerator root_window_event_generator(root_window);
   ui::test::EventGenerator keyboard_event_generator(root_window,
                                                     keyboard_window);
 
-  views::Widget* modal_widget =
-      CreateModalWidget(gfx::Rect(300, 10, 100, 100));
+  views::Widget* modal_widget = CreateModalWidget(gfx::Rect(300, 10, 100, 100));
 
   // Verify that mouse events to the root window are block with a visble modal
   // dialog.
   root_window_event_generator.ClickLeftButton();
   EXPECT_EQ(0, handler.num_mouse_events());
 
   // Verify that event dispatch to the virtual keyboard is unblocked.
   keyboard_event_generator.ClickLeftButton();
   EXPECT_EQ(1, handler.num_mouse_events() / 2);
 
@@ skipping 144 matching lines @@
   keyboard_controller->ui()->GetKeyboardWindow()->SetBounds(
       gfx::Rect(0, 400, 800, 200));
   EXPECT_EQ("0,400 800x200", keyboard_container->bounds().ToString());
 
   UpdateDisplay("600x800");
   EXPECT_EQ("0,600 600x200", keyboard_container->bounds().ToString());
 }
 
 }  // namespace test
 }  // namespace ash