clang-format all of //ash

ash/shell.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/shell.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 
@@ skipping 105 matching lines @@
 #include "ui/wm/core/accelerator_filter.h"
 #include "ui/wm/core/compound_event_filter.h"
 #include "ui/wm/core/focus_controller.h"
 #include "ui/wm/core/shadow_controller.h"
 #include "ui/wm/core/visibility_controller.h"
 #include "ui/wm/core/window_modality_controller.h"
 
 #if defined(OS_CHROMEOS)
 #if defined(USE_X11)
 #include "ui/gfx/x/x11_types.h"  // nogncheck
-#endif  // defined(USE_X11)
+#endif                           // defined(USE_X11)
 #include "ash/accelerators/magnifier_key_scroller.h"
 #include "ash/accelerators/spoken_feedback_toggler.h"
 #include "ash/common/ash_constants.h"
 #include "ash/common/system/chromeos/power/power_status.h"
 #include "ash/display/display_change_observer_chromeos.h"
 #include "ash/display/display_color_manager_chromeos.h"
 #include "ash/display/display_error_observer_chromeos.h"
 #include "ash/display/projecting_observer_chromeos.h"
 #include "ash/display/resolution_notification_controller.h"
 #include "ash/display/screen_orientation_controller_chromeos.h"
@@ skipping 134 matching lines @@
       .id();
 }
 
 // static
 aura::Window::Windows Shell::GetAllRootWindows() {
   CHECK(HasInstance());
   return Shell::GetInstance()->window_tree_host_manager()->GetAllRootWindows();
 }
 
 // static
-aura::Window* Shell::GetContainer(aura::Window* root_window,
-                                  int container_id) {
+aura::Window* Shell::GetContainer(aura::Window* root_window, int container_id) {
   return root_window->GetChildById(container_id);
 }
 
 // static
 const aura::Window* Shell::GetContainer(const aura::Window* root_window,
                                         int container_id) {
   return root_window->GetChildById(container_id);
 }
 
 // static
@@ skipping 19 matching lines @@
                             ui::MenuSourceType source_type) {
   // No context menus if there is no session with an active user.
   if (!session_state_delegate_->NumberOfLoggedInUsers())
     return;
   // No context menus when screen is locked.
   if (session_state_delegate_->IsScreenLocked())
     return;
 
   aura::Window* root = WmWindowAura::GetAuraWindow(
       wm::GetRootWindowMatching(gfx::Rect(location_in_screen, gfx::Size())));
-  GetRootWindowController(root)
-      ->ShowContextMenu(location_in_screen, source_type);
+  GetRootWindowController(root)->ShowContextMenu(location_in_screen,
+                                                 source_type);
 }
 
 void Shell::ShowAppList(aura::Window* window) {
   // If the context window is not given, show it on the target root window.
   delegate_->GetAppListPresenter()->Show(GetDisplayIdForWindow(window));
 }
 
 void Shell::DismissAppList() {
   delegate_->GetAppListPresenter()->Dismiss();
 }
@@ skipping 95 matching lines @@
   FOR_EACH_OBSERVER(ShellObserver, *wm_shell_common_->shell_observers(),
                     OnShelfCreatedForRootWindow(root_window));
 }
 
 void Shell::CreateKeyboard() {
   if (in_mus_)
     return;
   // TODO(bshe): Primary root window controller may not be the controller to
   // attach virtual keyboard. See http://crbug.com/303429
   InitKeyboard();
-  GetPrimaryRootWindowController()->
-      ActivateKeyboard(keyboard::KeyboardController::GetInstance());
+  GetPrimaryRootWindowController()->ActivateKeyboard(
+      keyboard::KeyboardController::GetInstance());
 }
 
 void Shell::DeactivateKeyboard() {
   keyboard_ui_->Hide();
   if (in_mus_)
     return;
   if (keyboard::KeyboardController::GetInstance()) {
     RootWindowControllerList controllers = GetAllRootWindowControllers();
     for (RootWindowControllerList::iterator iter = controllers.begin();
-        iter != controllers.end(); ++iter) {
+         iter != controllers.end(); ++iter) {
       (*iter)->DeactivateKeyboard(keyboard::KeyboardController::GetInstance());
     }
   }
   keyboard::KeyboardController::ResetInstance(nullptr);
 }
 
 void Shell::ShowShelf() {
   RootWindowControllerList controllers = GetAllRootWindowControllers();
   for (RootWindowControllerList::iterator iter = controllers.begin();
        iter != controllers.end(); ++iter)
@@ skipping 12 matching lines @@
 void Shell::AddPointerWatcher(views::PointerWatcher* watcher) {
   pointer_watcher_delegate_->AddPointerWatcher(watcher);
 }
 
 void Shell::RemovePointerWatcher(views::PointerWatcher* watcher) {
   pointer_watcher_delegate_->RemovePointerWatcher(watcher);
 }
 
 #if defined(OS_CHROMEOS)
 bool Shell::ShouldSaveDisplaySettings() {
-  return !(screen_orientation_controller_
-               ->ignore_display_configuration_updates() ||
-           resolution_notification_controller_->DoesNotificationTimeout());
+  return !(
+      screen_orientation_controller_->ignore_display_configuration_updates() ||
+      resolution_notification_controller_->DoesNotificationTimeout());
 }
 #endif
 
 void Shell::UpdateShelfVisibility() {
   RootWindowControllerList controllers = GetAllRootWindowControllers();
   for (RootWindowControllerList::iterator iter = controllers.begin();
        iter != controllers.end(); ++iter)
     if ((*iter)->shelf_widget())
       (*iter)->UpdateShelfVisibility();
 }
@@ skipping 23 matching lines @@
   for (RootWindowControllerList::iterator iter = controllers.begin();
        iter != controllers.end(); ++iter)
     (*iter)->GetSystemModalLayoutManager(window)->CreateModalBackground();
 }
 
 void Shell::OnModalWindowRemoved(aura::Window* removed) {
   RootWindowControllerList controllers = GetAllRootWindowControllers();
   bool activated = false;
   for (RootWindowControllerList::iterator iter = controllers.begin();
        iter != controllers.end() && !activated; ++iter) {
-    activated = (*iter)->GetSystemModalLayoutManager(removed)->
-        ActivateNextModalWindow();
+    activated = (*iter)
+                    ->GetSystemModalLayoutManager(removed)
+                    ->ActivateNextModalWindow();
   }
   if (!activated) {
     RemovePreTargetHandler(modality_filter_.get());
     modality_filter_.reset();
     for (RootWindowControllerList::iterator iter = controllers.begin();
          iter != controllers.end(); ++iter)
       (*iter)->GetSystemModalLayoutManager(removed)->DestroyModalBackground();
   }
 }
 
@@ skipping 51 matching lines @@
 }
 
 void Shell::SetCursorCompositingEnabled(bool enabled) {
   window_tree_host_manager_->cursor_window_controller()
       ->SetCursorCompositingEnabled(enabled);
   native_cursor_manager_->SetNativeCursorEnabled(!enabled);
 }
 #endif  // defined(OS_CHROMEOS)
 
 void Shell::DoInitialWorkspaceAnimation() {
-  return GetPrimaryRootWindowController()->workspace_controller()->
-      DoInitialAnimation();
+  return GetPrimaryRootWindowController()
+      ->workspace_controller()
+      ->DoInitialAnimation();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Shell, private:
 
 Shell::Shell(ShellDelegate* delegate, base::SequencedWorkerPool* blocking_pool)
     : target_root_window_(nullptr),
       scoped_target_root_window_(nullptr),
       delegate_(delegate),
       shelf_model_(new ShelfModel),
@@ skipping 91 matching lines @@
   // to deinitialize the shelf first, as it is initialized after the delegate.
   ShutdownShelf();
   wm_shell_->system_tray_delegate()->Shutdown();
   wm_shell_->SetSystemTrayDelegate(nullptr);
 
   locale_notification_controller_.reset();
 
   // Drag-and-drop must be canceled prior to close all windows.
   drag_drop_controller_.reset();
 
-  // Controllers who have WindowObserver added must be deleted
-  // before |window_tree_host_manager_| is deleted.
+// Controllers who have WindowObserver added must be deleted
+// before |window_tree_host_manager_| is deleted.
 
 #if defined(OS_CHROMEOS)
   // VideoActivityNotifier must be deleted before |video_detector_| is
   // deleted because it's observing video activity through
   // VideoDetectorObserver interface.
   video_activity_notifier_.reset();
 #endif  // defined(OS_CHROMEOS)
   video_detector_.reset();
   high_contrast_controller_.reset();
 
@@ skipping 180 matching lines @@
 
   // Install the custom factory first so that views::FocusManagers for Tray,
   // Shelf, and WallPaper could be created by the factory.
   views::FocusManagerFactory::Install(new AshFocusManagerFactory);
 
   aura::Env::GetInstance()->set_context_factory(init_params.context_factory);
 
   // The WindowModalityController needs to be at the front of the input event
   // pretarget handler list to ensure that it processes input events when modal
   // windows are active.
-  window_modality_controller_.reset(
-      new ::wm::WindowModalityController(this));
+  window_modality_controller_.reset(new ::wm::WindowModalityController(this));
 
   env_filter_.reset(new ::wm::CompoundEventFilter);
   AddPreTargetHandler(env_filter_.get());
 
   wm::AshFocusRules* focus_rules = new wm::AshFocusRules();
 
   ::wm::FocusController* focus_controller =
       new ::wm::FocusController(focus_rules);
   focus_client_.reset(focus_controller);
   activation_client_ = focus_controller;
@@ skipping 55 matching lines @@
   keyboard_metrics_filter_.reset(new KeyboardUMAEventFilter);
   AddPreTargetHandler(keyboard_metrics_filter_.get());
 
 #if defined(OS_CHROMEOS)
   sticky_keys_controller_.reset(new StickyKeysController);
 #endif
   screen_pinning_controller_.reset(new ScreenPinningController(
       wm_shell_common_.get(), window_tree_host_manager_.get()));
 
   lock_state_controller_.reset(new LockStateController);
-  power_button_controller_.reset(new PowerButtonController(
-      lock_state_controller_.get()));
+  power_button_controller_.reset(
+      new PowerButtonController(lock_state_controller_.get()));
 #if defined(OS_CHROMEOS)
   // Pass the initial display state to PowerButtonController.
   power_button_controller_->OnDisplayModeChanged(
       display_configurator_->cached_displays());
 #endif
   wm_shell_common_->AddShellObserver(lock_state_controller_.get());
 
   drag_drop_controller_.reset(new DragDropController);
   // |screenshot_controller_| needs to be created (and prepended as a
   // pre-target handler) at this point, because |mouse_cursor_filter_| needs to
   // process mouse events prior to screenshot session.
   // See http://crbug.com/459214
   screenshot_controller_.reset(new ScreenshotController());
   mouse_cursor_filter_.reset(new MouseCursorEventFilter());
   PrependPreTargetHandler(mouse_cursor_filter_.get());
 
   // Create Controllers that may need root window.
   // TODO(oshima): Move as many controllers before creating
   // RootWindowController as possible.
   visibility_controller_.reset(new AshVisibilityController);
 
-  magnification_controller_.reset(
-      MagnificationController::CreateInstance());
+  magnification_controller_.reset(MagnificationController::CreateInstance());
   wm_shell_common_->CreateMruWindowTracker();
 
-  partial_magnification_controller_.reset(
-      new PartialMagnificationController());
+  partial_magnification_controller_.reset(new PartialMagnificationController());
 
   autoclick_controller_.reset(AutoclickController::CreateInstance());
 
   high_contrast_controller_.reset(new HighContrastController);
   video_detector_.reset(new VideoDetector);
   window_cycle_controller_.reset(new WindowCycleController());
 
   tooltip_controller_.reset(new views::corewm::TooltipController(
       std::unique_ptr<views::corewm::Tooltip>(new views::corewm::TooltipAura)));
   AddPreTargetHandler(tooltip_controller_.get());
 
   event_client_.reset(new EventClientImpl);
 
   // This controller needs to be set before SetupManagedWindowMode.
   desktop_background_controller_.reset(
       new DesktopBackgroundController(blocking_pool_));
   user_wallpaper_delegate_.reset(delegate_->CreateUserWallpaperDelegate());
 
   session_state_delegate_.reset(delegate_->CreateSessionStateDelegate());
   accessibility_delegate_.reset(delegate_->CreateAccessibilityDelegate());
   new_window_delegate_.reset(delegate_->CreateNewWindowDelegate());
   media_delegate_.reset(delegate_->CreateMediaDelegate());
   pointer_watcher_delegate_ = delegate_->CreatePointerWatcherDelegate();
 
   resize_shadow_controller_.reset(new ResizeShadowController());
-  shadow_controller_.reset(
-      new ::wm::ShadowController(activation_client_));
+  shadow_controller_.reset(new ::wm::ShadowController(activation_client_));
 
   SystemTrayDelegate* system_tray_delegate =
       delegate()->CreateSystemTrayDelegate();
   DCHECK(system_tray_delegate);
   wm_shell_->SetSystemTrayDelegate(base::WrapUnique(system_tray_delegate));
 
   locale_notification_controller_.reset(new LocaleNotificationController);
 
   // Initialize toast manager
   toast_manager_.reset(new ToastManager);
@@ skipping 86 matching lines @@
 }
 
 void Shell::InitRootWindow(aura::Window* root_window) {
   DCHECK(activation_client_);
   DCHECK(visibility_controller_.get());
   DCHECK(drag_drop_controller_.get());
 
   aura::client::SetFocusClient(root_window, focus_client_.get());
   aura::client::SetActivationClient(root_window, activation_client_);
   ::wm::FocusController* focus_controller =
-      static_cast< ::wm::FocusController*>(activation_client_);
+      static_cast<::wm::FocusController*>(activation_client_);
   root_window->AddPreTargetHandler(focus_controller);
   aura::client::SetVisibilityClient(root_window, visibility_controller_.get());
   aura::client::SetDragDropClient(root_window, drag_drop_controller_.get());
   aura::client::SetScreenPositionClient(root_window,
                                         screen_position_controller_.get());
   aura::client::SetCursorClient(root_window, cursor_manager_.get());
   aura::client::SetTooltipClient(root_window, tooltip_controller_.get());
   aura::client::SetEventClient(root_window, event_client_.get());
 
   aura::client::SetWindowMoveClient(root_window,
-      toplevel_window_event_handler_.get());
+                                    toplevel_window_event_handler_.get());
   root_window->AddPreTargetHandler(toplevel_window_event_handler_.get());
   root_window->AddPostTargetHandler(toplevel_window_event_handler_.get());
 }
 
 bool Shell::CanWindowReceiveEvents(aura::Window* window) {
   RootWindowControllerList controllers = GetAllRootWindowControllers();
   for (RootWindowController* controller : controllers) {
     if (controller->CanWindowReceiveEvents(window))
       return true;
   }
@@ skipping 25 matching lines @@
 
 void Shell::OnWindowActivated(
     aura::client::ActivationChangeObserver::ActivationReason reason,
     aura::Window* gained_active,
     aura::Window* lost_active) {
   if (gained_active)
     target_root_window_ = gained_active->GetRootWindow();
 }
 
 }  // namespace ash