clang-format all of //ash

ash/wm/system_modal_container_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/wm/system_modal_container_layout_manager.h"
 
 #include <memory>
 
 #include "ash/common/session/session_state_delegate.h"
 #include "ash/common/shell_window_ids.h"
@@ skipping 32 matching lines @@
       ash::kShellWindowId_SystemModalContainer);
 }
 
 bool AllRootWindowsHaveModalBackgroundsForContainer(int container_id) {
   std::vector<aura::Window*> containers =
       Shell::GetContainersFromAllRootWindows(container_id, NULL);
   bool has_modal_screen = !containers.empty();
   for (std::vector<aura::Window*>::iterator iter = containers.begin();
        iter != containers.end(); ++iter) {
     has_modal_screen &= static_cast<SystemModalContainerLayoutManager*>(
-                            (*iter)->layout_manager())->has_modal_background();
+                            (*iter)->layout_manager())
+                            ->has_modal_background();
   }
   return has_modal_screen;
 }
 
 bool AllRootWindowsHaveLockedModalBackgrounds() {
   return AllRootWindowsHaveModalBackgroundsForContainer(
       kShellWindowId_LockSystemModalContainer);
 }
 
 bool AllRootWindowsHaveModalBackgrounds() {
@@ skipping 22 matching lines @@
   }
 
  private:
   bool modal_;
 
   DISALLOW_COPY_AND_ASSIGN(TestWindow);
 };
 
 class EventTestWindow : public TestWindow {
  public:
-  explicit EventTestWindow(bool modal) : TestWindow(modal),
-                                         mouse_presses_(0) {}
+  explicit EventTestWindow(bool modal) : TestWindow(modal), mouse_presses_(0) {}
   ~EventTestWindow() override {}
 
   aura::Window* OpenTestWindowWithContext(aura::Window* context) {
     views::Widget* widget =
         views::Widget::CreateWindowWithContext(this, context);
     widget->Show();
     return widget->GetNativeView();
   }
 
   aura::Window* OpenTestWindowWithParent(aura::Window* parent) {
     DCHECK(parent);
-    views::Widget* widget =
-        views::Widget::CreateWindowWithParent(this, parent);
+    views::Widget* widget = views::Widget::CreateWindowWithParent(this, parent);
     widget->Show();
     return widget->GetNativeView();
   }
 
   // Overridden from views::View:
   bool OnMousePressed(const ui::MouseEvent& event) override {
     mouse_presses_++;
     return false;
   }
 
   int mouse_presses() const { return mouse_presses_; }
+
  private:
   int mouse_presses_;
 
   DISALLOW_COPY_AND_ASSIGN(EventTestWindow);
 };
 
 class TransientWindowObserver : public aura::WindowObserver {
  public:
   TransientWindowObserver() : destroyed_(false) {}
   ~TransientWindowObserver() override {}
@@ skipping 56 matching lines @@
         keyboard->ui()->GetKeyboardWindow()->SetBounds(
             keyboard::FullWidthKeyboardBoundsFromRootBounds(
                 Shell::GetPrimaryRootWindow()->bounds(), 100));
       }
     } else {
       keyboard->HideKeyboard(keyboard::KeyboardController::HIDE_REASON_MANUAL);
     }
 
     DCHECK_EQ(show, keyboard->keyboard_visible());
   }
-
 };
 
 TEST_F(SystemModalContainerLayoutManagerTest, NonModalTransient) {
   std::unique_ptr<aura::Window> parent(OpenToplevelTestWindow(false));
   aura::Window* transient = OpenTestWindowWithParent(parent.get(), false);
   TransientWindowObserver destruction_observer;
   transient->AddObserver(&destruction_observer);
 
   EXPECT_EQ(parent.get(), ::wm::GetTransientParent(transient));
   EXPECT_EQ(parent->parent(), transient->parent());
@@ skipping 131 matching lines @@
   // Create a modal window for the main window and verify that the main window
   // no longer receives mouse events.
   EventTestWindow* transient_delegate = new EventTestWindow(true);
   aura::Window* transient =
       transient_delegate->OpenTestWindowWithParent(main.get());
   EXPECT_TRUE(wm::IsActiveWindow(transient));
   e1.ClickLeftButton();
   EXPECT_EQ(1, transient_delegate->mouse_presses());
 
   for (int block_reason = FIRST_BLOCK_REASON;
-       block_reason < NUMBER_OF_BLOCK_REASONS;
-       ++block_reason) {
+       block_reason < NUMBER_OF_BLOCK_REASONS; ++block_reason) {
     // Create a window in the lock screen container and ensure that it receives
     // the mouse event instead of the modal window (crbug.com/110920).
     BlockUserSession(static_cast<UserSessionBlockReason>(block_reason));
     EventTestWindow* lock_delegate = new EventTestWindow(false);
     std::unique_ptr<aura::Window> lock(lock_delegate->OpenTestWindowWithParent(
         Shell::GetPrimaryRootWindowController()->GetContainer(
             ash::kShellWindowId_LockScreenContainer)));
     EXPECT_TRUE(wm::IsActiveWindow(lock.get()));
     e1.ClickLeftButton();
     EXPECT_EQ(1, lock_delegate->mouse_presses());
@@ skipping 95 matching lines @@
   // Normal system modal window.  Shows normal system modal background and not
   // locked.
   EXPECT_TRUE(AllRootWindowsHaveModalBackgrounds());
   EXPECT_FALSE(AllRootWindowsHaveLockedModalBackgrounds());
 
   TestWindow::CloseTestWindow(modal_window.release());
   EXPECT_FALSE(AllRootWindowsHaveModalBackgrounds());
   EXPECT_FALSE(AllRootWindowsHaveLockedModalBackgrounds());
 
   for (int block_reason = FIRST_BLOCK_REASON;
-       block_reason < NUMBER_OF_BLOCK_REASONS;
-       ++block_reason) {
+       block_reason < NUMBER_OF_BLOCK_REASONS; ++block_reason) {
     // Normal system modal window while blocked.  Shows blocked system modal
     // background.
     BlockUserSession(static_cast<UserSessionBlockReason>(block_reason));
     std::unique_ptr<aura::Window> lock_parent(OpenTestWindowWithParent(
         Shell::GetPrimaryRootWindowController()->GetContainer(
             ash::kShellWindowId_LockScreenContainer),
         false));
     std::unique_ptr<aura::Window> lock_modal_window(
         OpenTestWindowWithParent(lock_parent.get(), true));
     lock_parent->Show();
@@ skipping 294 matching lines @@
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("500x500, 500x500");
   InputTestDelegate delegate;
   delegate.RunTest(this);
 }
 
 }  // namespace test
 }  // namespace ash