clang-format all of //ash

ash/root_window_controller.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 <queue>
 #include <vector>
 
 #include "ash/aura/aura_layout_manager_adapter.h"
@@ skipping 90 matching lines @@
 // wm/window_animation.cc's brightness/grayscale fade animation that the login
 // background image animation isn't hidden by the splash screen animation.
 const int kBootSplashScreenHideDurationMs = 500;
 #endif
 
 float ToRelativeValue(int value, int src, int dst) {
   return static_cast<float>(value) / static_cast<float>(src) * dst;
 }
 
 void MoveOriginRelativeToSize(const gfx::Size& src_size,
-                                const gfx::Size& dst_size,
-                                gfx::Rect* bounds_in_out) {
+                              const gfx::Size& dst_size,
+                              gfx::Rect* bounds_in_out) {
   gfx::Point origin = bounds_in_out->origin();
   bounds_in_out->set_origin(gfx::Point(
       ToRelativeValue(origin.x(), src_size.width(), dst_size.width()),
       ToRelativeValue(origin.y(), src_size.height(), dst_size.height())));
 }
 
 // Reparents |window| to |new_parent|.
 void ReparentWindow(aura::Window* window, aura::Window* new_parent) {
   const gfx::Size src_size = window->parent()->bounds().size();
   const gfx::Size dst_size = new_parent->bounds().size();
@@ skipping 261 matching lines @@
     animating_wallpaper_controller_->StopAnimating();
   wallpaper_controller_.reset();
   animating_wallpaper_controller_.reset();
   aura::Window* root_window = GetRootWindow();
   Shell* shell = Shell::GetInstance();
   // Change the target root window before closing child windows. If any child
   // being removed triggers a relayout of the shelf it will try to build a
   // window list adding windows from the target root window's containers which
   // may have already gone away.
   if (Shell::GetTargetRootWindow() == root_window) {
-    shell->set_target_root_window(
-        Shell::GetPrimaryRootWindow() == root_window
-            ? NULL
-            : Shell::GetPrimaryRootWindow());
+    shell->set_target_root_window(Shell::GetPrimaryRootWindow() == root_window
+                                      ? NULL
+                                      : Shell::GetPrimaryRootWindow());
   }
 
   CloseChildWindows();
   GetRootWindowSettings(root_window)->controller = NULL;
   workspace_controller_.reset();
   // Forget with the display ID so that display lookup
   // ends up with invalid display.
   GetRootWindowSettings(root_window)->display_id =
       display::Display::kInvalidDisplayID;
   ash_host_->PrepareForShutdown();
@@ skipping 52 matching lines @@
   if (window) {
     aura::Window* window_container = WmWindowAura::GetAuraWindow(
         wm::GetContainerForWindow(WmWindowAura::Get(window)));
     if (window_container &&
         window_container->id() >= kShellWindowId_LockScreenContainer) {
       modal_container = GetContainer(kShellWindowId_LockSystemModalContainer);
     } else {
       modal_container = GetContainer(kShellWindowId_SystemModalContainer);
     }
   } else {
-    int modal_window_id = Shell::GetInstance()->session_state_delegate()
-        ->IsUserSessionBlocked() ? kShellWindowId_LockSystemModalContainer :
-                                   kShellWindowId_SystemModalContainer;
+    int modal_window_id =
+        Shell::GetInstance()->session_state_delegate()->IsUserSessionBlocked()
+            ? kShellWindowId_LockSystemModalContainer
+            : kShellWindowId_SystemModalContainer;
     modal_container = GetContainer(modal_window_id);
   }
   return modal_container ? static_cast<SystemModalContainerLayoutManager*>(
-      modal_container->layout_manager()) : NULL;
+                               modal_container->layout_manager())
+                         : NULL;
 }
 
 aura::Window* RootWindowController::GetContainer(int container_id) {
   return GetRootWindow()->GetChildById(container_id);
 }
 
 const aura::Window* RootWindowController::GetContainer(int container_id) const {
   return ash_host_->AsWindowTreeHost()->window()->GetChildById(container_id);
 }
 
@@ skipping 50 matching lines @@
 #endif
 }
 
 void RootWindowController::OnWallpaperAnimationFinished(views::Widget* widget) {
   // Make sure the wallpaper is visible.
   system_background_->SetColor(SK_ColorBLACK);
 #if defined(OS_CHROMEOS)
   boot_splash_screen_.reset();
 #endif
 
-  Shell::GetInstance()->user_wallpaper_delegate()->
-      OnWallpaperAnimationFinished();
+  Shell::GetInstance()
+      ->user_wallpaper_delegate()
+      ->OnWallpaperAnimationFinished();
   // Only removes old component when wallpaper animation finished. If we
   // remove the old one before the new wallpaper is done fading in there will
   // be a white flash during the animation.
   if (animating_wallpaper_controller()) {
     DesktopBackgroundWidgetController* controller =
         animating_wallpaper_controller()->GetController(true);
     // |desktop_widget_| should be the same animating widget we try to move
     // to |kDesktopController|. Otherwise, we may close |desktop_widget_|
     // before move it to |kDesktopController|.
     DCHECK_EQ(controller->widget(), widget);
@@ skipping 138 matching lines @@
   DCHECK(keyboard_controller);
   keyboard_controller->AddObserver(shelf_widget()->shelf_layout_manager());
   keyboard_controller->AddObserver(panel_layout_manager_);
   keyboard_controller->AddObserver(docked_layout_manager_);
   keyboard_controller->AddObserver(workspace_controller_->layout_manager());
   keyboard_controller->AddObserver(
       always_on_top_controller_->GetLayoutManager());
   Shell::GetInstance()->delegate()->VirtualKeyboardActivated(true);
   aura::Window* parent = GetContainer(kShellWindowId_ImeWindowParentContainer);
   DCHECK(parent);
-  aura::Window* keyboard_container =
-      keyboard_controller->GetContainerWindow();
+  aura::Window* keyboard_container = keyboard_controller->GetContainerWindow();
   keyboard_container->set_id(kShellWindowId_VirtualKeyboardContainer);
   parent->AddChild(keyboard_container);
 }
 
 void RootWindowController::DeactivateKeyboard(
     keyboard::KeyboardController* keyboard_controller) {
   if (!keyboard_controller ||
       !keyboard_controller->keyboard_container_initialized()) {
     return;
   }
-  aura::Window* keyboard_container =
-      keyboard_controller->GetContainerWindow();
+  aura::Window* keyboard_container = keyboard_controller->GetContainerWindow();
   if (keyboard_container->GetRootWindow() == GetRootWindow()) {
     aura::Window* parent =
         GetContainer(kShellWindowId_ImeWindowParentContainer);
     DCHECK(parent);
     parent->RemoveChild(keyboard_container);
     // Virtual keyboard may be deactivated while still showing, notify all
     // observers that keyboard bounds changed to 0 before remove them.
     keyboard_controller->NotifyKeyboardBoundsChanging(gfx::Rect());
     keyboard_controller->RemoveObserver(shelf_widget()->shelf_layout_manager());
     keyboard_controller->RemoveObserver(panel_layout_manager_);
@@ skipping 45 matching lines @@
   Shell* shell = Shell::GetInstance();
   shell->InitRootWindow(root_window);
 
   root_window_controller_common_->CreateContainers();
 
   CreateSystemBackground(first_run_after_boot);
 
   InitLayoutManagers();
   InitTouchHuds();
 
-  if (Shell::GetPrimaryRootWindowController()->
-      GetSystemModalLayoutManager(NULL)->has_modal_background()) {
+  if (Shell::GetPrimaryRootWindowController()
+          ->GetSystemModalLayoutManager(NULL)
+          ->has_modal_background()) {
     GetSystemModalLayoutManager(NULL)->CreateModalBackground();
   }
 
   WmShell::Get()->AddShellObserver(this);
 
   root_window_controller_common_->root_window_layout()->OnWindowResized();
   if (root_window_type == PRIMARY) {
     shell->InitKeyboard();
   } else {
     ash_host_->AsWindowTreeHost()->Show();
@@ skipping 54 matching lines @@
   WmWindow* shelf_container =
       WmWindowAura::Get(GetContainer(kShellWindowId_ShelfContainer));
   WmWindow* status_container =
       WmWindowAura::Get(GetContainer(kShellWindowId_StatusContainer));
   shelf_widget_.reset(new ShelfWidget(shelf_container, status_container,
                                       wm_shelf_aura_.get(),
                                       workspace_controller()));
   workspace_layout_manager_delegate->set_shelf(
       shelf_widget_->shelf_layout_manager());
 
-  if (!Shell::GetInstance()->session_state_delegate()->
-      IsActiveUserSessionStarted()) {
+  if (!Shell::GetInstance()
+           ->session_state_delegate()
+           ->IsActiveUserSessionStarted()) {
     // This window exists only to be a event target on login screen.
     // It does not have to handle events, nor be visible.
     mouse_event_target_.reset(new aura::Window(new EmptyWindowDelegate));
     mouse_event_target_->Init(ui::LAYER_NOT_DRAWN);
 
     aura::Window* lock_background_container =
         GetContainer(kShellWindowId_LockScreenBackgroundContainer);
     lock_background_container->AddChild(mouse_event_target_.get());
     mouse_event_target_->Show();
   }
@@ skipping 11 matching lines @@
   // Create Panel layout manager
   aura::Window* panel_container = GetContainer(kShellWindowId_PanelContainer);
   WmWindow* wm_panel_container = WmWindowAura::Get(panel_container);
   panel_layout_manager_ = new PanelLayoutManager(wm_panel_container);
   wm_panel_container->SetLayoutManager(base::WrapUnique(panel_layout_manager_));
   panel_container_handler_.reset(new PanelWindowEventHandler);
   panel_container->AddPreTargetHandler(panel_container_handler_.get());
 
   // Install an AttachedPanelWindowTargeter on the panel container to make it
   // easier to correctly target shelf buttons with touch.
-  gfx::Insets mouse_extend(-kResizeOutsideBoundsSize,
-                           -kResizeOutsideBoundsSize,
+  gfx::Insets mouse_extend(-kResizeOutsideBoundsSize, -kResizeOutsideBoundsSize,
                            -kResizeOutsideBoundsSize,
                            -kResizeOutsideBoundsSize);
-  gfx::Insets touch_extend = mouse_extend.Scale(
-      kResizeOutsideBoundsScaleForTouch);
+  gfx::Insets touch_extend =
+      mouse_extend.Scale(kResizeOutsideBoundsScaleForTouch);
   panel_container->SetEventTargeter(
       std::unique_ptr<ui::EventTargeter>(new AttachedPanelWindowTargeter(
           panel_container, mouse_extend, touch_extend, panel_layout_manager_)));
 }
 
 void RootWindowController::InitTouchHuds() {
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kAshTouchHud))
     set_touch_hud_debug(new TouchHudDebug(GetRootWindow()));
   if (Shell::GetInstance()->is_touch_hud_projection_enabled())
@@ skipping 45 matching lines @@
   shelf_widget_->shelf_layout_manager()->UpdateVisibilityState();
 }
 
 void RootWindowController::OnTouchHudProjectionToggled(bool enabled) {
   if (enabled)
     EnableTouchHudProjection();
   else
     DisableTouchHudProjection();
 }
 
-RootWindowController* GetRootWindowController(
-    const aura::Window* root_window) {
+RootWindowController* GetRootWindowController(const aura::Window* root_window) {
   if (!root_window)
     return nullptr;
 
   if (Shell::GetInstance()->in_mus()) {
     // On mus, like desktop aura, each top-level widget has its own root window,
     // so |root_window| is not necessarily the display's root. For now, just
     // the use the primary display root.
     // TODO(jamescook): Multi-display support. This depends on how mus windows
     // will be owned by displays.
     aura::Window* primary_root_window = Shell::GetInstance()
                                             ->window_tree_host_manager()
                                             ->GetPrimaryRootWindow();
     return GetRootWindowSettings(primary_root_window)->controller;
   }
 
   return GetRootWindowSettings(root_window)->controller;
 }
 
 }  // namespace ash