clang-format all of //ash

ash/wm/maximize_mode/maximize_mode_window_manager.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/wm/maximize_mode/maximize_mode_window_manager.h"
 
 #include "ash/aura/wm_window_aura.h"
 #include "ash/common/ash_switches.h"
 #include "ash/common/session/session_state_delegate.h"
 #include "ash/common/shell_window_ids.h"
@@ skipping 127 matching lines @@
 }
 
 void MaximizeModeWindowManager::OnWindowBoundsChanged(
     aura::Window* window,
     const gfx::Rect& old_bounds,
     const gfx::Rect& new_bounds) {
   if (!IsContainerWindow(window))
     return;
   // Reposition all non maximizeable windows.
   for (WindowToState::iterator it = window_state_map_.begin();
-       it != window_state_map_.end();
-       ++it) {
+       it != window_state_map_.end(); ++it) {
     it->second->UpdateWindowPosition(wm::GetWindowState(it->first));
   }
 }
 
 void MaximizeModeWindowManager::OnDisplayAdded(
     const display::Display& display) {
   DisplayConfigurationChanged();
 }
 
 void MaximizeModeWindowManager::OnDisplayRemoved(
@@ skipping 41 matching lines @@
     return;
   }
 
   // Leave full screen mode.
   event->StopPropagation();
   wm::WMEvent toggle_fullscreen(wm::WM_EVENT_TOGGLE_FULLSCREEN);
   window_state->OnWMEvent(&toggle_fullscreen);
 }
 
 MaximizeModeWindowManager::MaximizeModeWindowManager()
-      : backdrops_hidden_(false) {
+    : backdrops_hidden_(false) {
   // The overview mode needs to be ended before the maximize mode is started. To
   // guarantee the proper order, it will be turned off from here.
   CancelOverview();
 
   MaximizeAllWindows();
   AddWindowCreationObservers();
   EnableBackdropBehindTopWindowOnEachDisplay(true);
   display::Screen::GetScreen()->AddObserver(this);
   WmShell::Get()->AddShellObserver(this);
   Shell::GetInstance()->AddPreTargetHandler(this);
 }
 
 void MaximizeModeWindowManager::MaximizeAllWindows() {
-  MruWindowTracker::WindowList windows = ash::Shell::GetInstance()->
-      mru_window_tracker()->BuildWindowListIgnoreModal();
+  MruWindowTracker::WindowList windows = ash::Shell::GetInstance()
+                                             ->mru_window_tracker()
+                                             ->BuildWindowListIgnoreModal();
   // Add all existing Mru windows.
   for (WmWindow* window : windows)
     MaximizeAndTrackWindow(WmWindowAura::GetAuraWindow(window));
 }
 
 void MaximizeModeWindowManager::RestoreAllWindows() {
   while (window_state_map_.size())
     ForgetWindow(window_state_map_.begin()->first);
 }
 
 void MaximizeModeWindowManager::SetDeferBoundsUpdates(
     bool defer_bounds_updates) {
   for (WindowToState::iterator it = window_state_map_.begin();
-       it != window_state_map_.end();
-       ++it) {
+       it != window_state_map_.end(); ++it) {
     it->second->SetDeferBoundsUpdates(defer_bounds_updates);
   }
 }
 
-void MaximizeModeWindowManager::MaximizeAndTrackWindow(
-    aura::Window* window) {
+void MaximizeModeWindowManager::MaximizeAndTrackWindow(aura::Window* window) {
   if (!ShouldHandleWindow(window))
     return;
 
   DCHECK(window_state_map_.find(window) == window_state_map_.end());
   window->AddObserver(this);
 
   // We create and remember a maximize mode state which will attach itself to
   // the provided state object.
   window_state_map_[window] = new MaximizeModeWindowState(window, this);
 }
@@ skipping 31 matching lines @@
 void MaximizeModeWindowManager::AddWindowCreationObservers() {
   DCHECK(observed_container_windows_.empty());
   // Observe window activations/creations in the default containers on all root
   // windows.
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
   for (aura::Window::Windows::const_iterator iter = root_windows.begin();
        iter != root_windows.end(); ++iter) {
     aura::Window* container =
         Shell::GetContainer(*iter, kShellWindowId_DefaultContainer);
     DCHECK(observed_container_windows_.find(container) ==
-              observed_container_windows_.end());
+           observed_container_windows_.end());
     container->AddObserver(this);
     observed_container_windows_.insert(container);
   }
 }
 
 void MaximizeModeWindowManager::RemoveWindowCreationObservers() {
   for (std::set<aura::Window*>::iterator iter =
            observed_container_windows_.begin();
        iter != observed_container_windows_.end(); ++iter) {
     (*iter)->RemoveObserver(this);
   }
   observed_container_windows_.clear();
 }
 
 void MaximizeModeWindowManager::DisplayConfigurationChanged() {
   EnableBackdropBehindTopWindowOnEachDisplay(false);
   RemoveWindowCreationObservers();
   AddWindowCreationObservers();
   EnableBackdropBehindTopWindowOnEachDisplay(true);
 }
 
 bool MaximizeModeWindowManager::IsContainerWindow(aura::Window* window) {
   return observed_container_windows_.find(window) !=
-             observed_container_windows_.end();
+         observed_container_windows_.end();
 }
 
 void MaximizeModeWindowManager::EnableBackdropBehindTopWindowOnEachDisplay(
     bool enable) {
   // This function should be a no-op if backdrops have been disabled.
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kAshDisableMaximizeModeWindowBackdrop)) {
     return;
   }
 
   if (backdrops_hidden_)
     return;
 
   // Inform the WorkspaceLayoutManager that we want to show a backdrop behind
   // the topmost window of its container.
   Shell::RootWindowControllerList controllers =
       Shell::GetAllRootWindowControllers();
   for (Shell::RootWindowControllerList::iterator iter = controllers.begin();
        iter != controllers.end(); ++iter) {
     RootWindowController* controller = *iter;
     aura::Window* container = Shell::GetContainer(
         controller->GetRootWindow(), kShellWindowId_DefaultContainer);
     controller->workspace_controller()->SetMaximizeBackdropDelegate(
         std::unique_ptr<WorkspaceLayoutManagerBackdropDelegate>(
             enable ? new WorkspaceBackdropDelegate(container) : NULL));
   }
 }
 
 }  // namespace ash