clang-format all of //ash

ash/wm/lock_state_controller.cc

 // Copyright 2013 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/lock_state_controller.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 
@@ skipping 57 matching lines @@
 static const int kTimeoutMultiplier = 2;
 #else
 static const int kTimeoutMultiplier = 1;
 #endif
 
 const int LockStateController::kLockFailTimeoutMs = 8000 * kTimeoutMultiplier;
 const int LockStateController::kLockToShutdownTimeoutMs = 150;
 const int LockStateController::kShutdownRequestDelayMs = 50;
 
 LockStateController::TestApi::TestApi(LockStateController* controller)
-    : controller_(controller) {
-}
+    : controller_(controller) {}
 
-LockStateController::TestApi::~TestApi() {
-}
+LockStateController::TestApi::~TestApi() {}
 
 LockStateController::LockStateController()
     : animator_(new SessionStateAnimatorImpl()),
       login_status_(LoginStatus::NOT_LOGGED_IN),
       system_is_locked_(false),
       shutting_down_(false),
       shutdown_after_lock_(false),
       animating_lock_(false),
       can_cancel_lock_animation_(false),
       weak_ptr_factory_(this) {
@@ skipping 14 matching lines @@
 }
 
 void LockStateController::RemoveObserver(LockStateObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 bool LockStateController::HasObserver(const LockStateObserver* observer) const {
   return observers_.HasObserver(observer);
 }
 
-void LockStateController::StartLockAnimation(
-    bool shutdown_after_lock) {
+void LockStateController::StartLockAnimation(bool shutdown_after_lock) {
   if (animating_lock_)
     return;
   shutdown_after_lock_ = shutdown_after_lock;
   can_cancel_lock_animation_ = true;
 
   StartCancellablePreLockAnimation();
 }
 
 void LockStateController::StartShutdownAnimation() {
   StartCancellableShutdownAnimation();
@@ skipping 21 matching lines @@
 
 void LockStateController::CancelLockAnimation() {
   if (!CanCancelLockAnimation())
     return;
   shutdown_after_lock_ = false;
   animating_lock_ = false;
   CancelPreLockAnimation();
 }
 
 bool LockStateController::CanCancelShutdownAnimation() {
-  return pre_shutdown_timer_.IsRunning() ||
-         shutdown_after_lock_ ||
+  return pre_shutdown_timer_.IsRunning() || shutdown_after_lock_ ||
          lock_to_shutdown_timer_.IsRunning();
 }
 
 void LockStateController::CancelShutdownAnimation() {
   if (!CanCancelShutdownAnimation())
     return;
   if (lock_to_shutdown_timer_.IsRunning()) {
     lock_to_shutdown_timer_.Stop();
     return;
   }
@@ skipping 28 matching lines @@
   shell->cursor_manager()->LockCursor();
 
   animator_->StartAnimation(
       SessionStateAnimator::ROOT_CONTAINER,
       SessionStateAnimator::ANIMATION_GRAYSCALE_BRIGHTNESS,
       SessionStateAnimator::ANIMATION_SPEED_SHUTDOWN);
   StartRealShutdownTimer(true);
 }
 
 void LockStateController::OnLockScreenHide(
-  base::Callback<void(void)>& callback) {
+    base::Callback<void(void)>& callback) {
   StartUnlockAnimationBeforeUIDestroyed(callback);
 }
 
 void LockStateController::SetLockScreenDisplayedCallback(
     const base::Closure& callback) {
   lock_screen_displayed_callback_ = callback;
 }
 
 void LockStateController::OnHostCloseRequested(
     const aura::WindowTreeHost* host) {
@@ skipping 55 matching lines @@
   lock_duration_timer_.reset();
   DCHECK(!system_is_locked_);
 
   LOG(FATAL) << "Screen lock took too long; crashing intentionally";
 }
 
 void LockStateController::StartLockToShutdownTimer() {
   shutdown_after_lock_ = false;
   lock_to_shutdown_timer_.Stop();
   lock_to_shutdown_timer_.Start(
-      FROM_HERE,
-      base::TimeDelta::FromMilliseconds(kLockToShutdownTimeoutMs),
+      FROM_HERE, base::TimeDelta::FromMilliseconds(kLockToShutdownTimeoutMs),
       this, &LockStateController::OnLockToShutdownTimeout);
 }
 
 void LockStateController::OnLockToShutdownTimeout() {
   DCHECK(system_is_locked_);
   StartCancellableShutdownAnimation();
 }
 
 void LockStateController::StartPreShutdownAnimationTimer() {
   pre_shutdown_timer_.Stop();
   pre_shutdown_timer_.Start(
       FROM_HERE,
       animator_->GetDuration(SessionStateAnimator::ANIMATION_SPEED_SHUTDOWN),
-      this,
-      &LockStateController::OnPreShutdownAnimationTimeout);
+      this, &LockStateController::OnPreShutdownAnimationTimeout);
 }
 
 void LockStateController::OnPreShutdownAnimationTimeout() {
   VLOG(1) << "OnPreShutdownAnimationTimeout";
   shutting_down_ = true;
 
   Shell* shell = Shell::GetInstance();
   shell->cursor_manager()->HideCursor();
 
   StartRealShutdownTimer(false);
@@ skipping 51 matching lines @@
 }
 
 void LockStateController::StartImmediatePreLockAnimation(
     bool request_lock_on_completion) {
   VLOG(1) << "StartImmediatePreLockAnimation " << request_lock_on_completion;
   animating_lock_ = true;
   StoreUnlockedProperties();
 
   base::Closure next_animation_starter =
       base::Bind(&LockStateController::PreLockAnimationFinished,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 request_lock_on_completion);
+                 weak_ptr_factory_.GetWeakPtr(), request_lock_on_completion);
   SessionStateAnimator::AnimationSequence* animation_sequence =
       animator_->BeginAnimationSequence(next_animation_starter);
 
   animation_sequence->StartAnimation(
       SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
       SessionStateAnimator::ANIMATION_LIFT,
       SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS);
   animation_sequence->StartAnimation(
-      SessionStateAnimator::LAUNCHER,
-      SessionStateAnimator::ANIMATION_FADE_OUT,
+      SessionStateAnimator::LAUNCHER, SessionStateAnimator::ANIMATION_FADE_OUT,
       SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS);
   // Hide the screen locker containers so we can raise them later.
   animator_->StartAnimation(SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
                             SessionStateAnimator::ANIMATION_HIDE_IMMEDIATELY,
                             SessionStateAnimator::ANIMATION_SPEED_IMMEDIATE);
   AnimateBackgroundAppearanceIfNecessary(
       SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS, animation_sequence);
 
   animation_sequence->EndSequence();
 
   DispatchCancelMode();
-  FOR_EACH_OBSERVER(LockStateObserver, observers_,
+  FOR_EACH_OBSERVER(
+      LockStateObserver, observers_,
       OnLockStateEvent(LockStateObserver::EVENT_LOCK_ANIMATION_STARTED));
 }
 
 void LockStateController::StartCancellablePreLockAnimation() {
   animating_lock_ = true;
   StoreUnlockedProperties();
   VLOG(1) << "StartCancellablePreLockAnimation";
   base::Closure next_animation_starter =
       base::Bind(&LockStateController::PreLockAnimationFinished,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 true /* request_lock */);
+                 weak_ptr_factory_.GetWeakPtr(), true /* request_lock */);
   SessionStateAnimator::AnimationSequence* animation_sequence =
       animator_->BeginAnimationSequence(next_animation_starter);
 
   animation_sequence->StartAnimation(
       SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
       SessionStateAnimator::ANIMATION_LIFT,
       SessionStateAnimator::ANIMATION_SPEED_UNDOABLE);
   animation_sequence->StartAnimation(
-      SessionStateAnimator::LAUNCHER,
-      SessionStateAnimator::ANIMATION_FADE_OUT,
+      SessionStateAnimator::LAUNCHER, SessionStateAnimator::ANIMATION_FADE_OUT,
       SessionStateAnimator::ANIMATION_SPEED_UNDOABLE);
   // Hide the screen locker containers so we can raise them later.
   animator_->StartAnimation(SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
                             SessionStateAnimator::ANIMATION_HIDE_IMMEDIATELY,
                             SessionStateAnimator::ANIMATION_SPEED_IMMEDIATE);
   AnimateBackgroundAppearanceIfNecessary(
       SessionStateAnimator::ANIMATION_SPEED_UNDOABLE, animation_sequence);
 
   DispatchCancelMode();
-  FOR_EACH_OBSERVER(LockStateObserver, observers_,
+  FOR_EACH_OBSERVER(
+      LockStateObserver, observers_,
       OnLockStateEvent(LockStateObserver::EVENT_PRELOCK_ANIMATION_STARTED));
   animation_sequence->EndSequence();
 }
 
 void LockStateController::CancelPreLockAnimation() {
   VLOG(1) << "CancelPreLockAnimation";
   base::Closure next_animation_starter =
       base::Bind(&LockStateController::LockAnimationCancelled,
                  weak_ptr_factory_.GetWeakPtr());
   SessionStateAnimator::AnimationSequence* animation_sequence =
       animator_->BeginAnimationSequence(next_animation_starter);
 
   animation_sequence->StartAnimation(
       SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
       SessionStateAnimator::ANIMATION_UNDO_LIFT,
       SessionStateAnimator::ANIMATION_SPEED_UNDO_MOVE_WINDOWS);
   animation_sequence->StartAnimation(
-      SessionStateAnimator::LAUNCHER,
-      SessionStateAnimator::ANIMATION_FADE_IN,
+      SessionStateAnimator::LAUNCHER, SessionStateAnimator::ANIMATION_FADE_IN,
       SessionStateAnimator::ANIMATION_SPEED_UNDO_MOVE_WINDOWS);
   AnimateBackgroundHidingIfNecessary(
       SessionStateAnimator::ANIMATION_SPEED_UNDO_MOVE_WINDOWS,
       animation_sequence);
 
   animation_sequence->EndSequence();
 }
 
 void LockStateController::StartPostLockAnimation() {
   VLOG(1) << "StartPostLockAnimation";
   base::Closure next_animation_starter =
       base::Bind(&LockStateController::PostLockAnimationFinished,
                  weak_ptr_factory_.GetWeakPtr());
   SessionStateAnimator::AnimationSequence* animation_sequence =
       animator_->BeginAnimationSequence(next_animation_starter);
 
   animation_sequence->StartAnimation(
       SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
       SessionStateAnimator::ANIMATION_RAISE_TO_SCREEN,
       SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS);
   animation_sequence->EndSequence();
 }
 
 void LockStateController::StartUnlockAnimationBeforeUIDestroyed(
     base::Closure& callback) {
   VLOG(1) << "StartUnlockAnimationBeforeUIDestroyed";
   animator_->StartAnimationWithCallback(
       SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
       SessionStateAnimator::ANIMATION_LIFT,
-      SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS,
-      callback);
+      SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS, callback);
 }
 
 void LockStateController::StartUnlockAnimationAfterUIDestroyed() {
   VLOG(1) << "StartUnlockAnimationAfterUIDestroyed";
   base::Closure next_animation_starter =
       base::Bind(&LockStateController::UnlockAnimationAfterUIDestroyedFinished,
                  weak_ptr_factory_.GetWeakPtr());
   SessionStateAnimator::AnimationSequence* animation_sequence =
       animator_->BeginAnimationSequence(next_animation_starter);
 
   animation_sequence->StartAnimation(
       SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
       SessionStateAnimator::ANIMATION_DROP,
       SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS);
   animation_sequence->StartAnimation(
-      SessionStateAnimator::LAUNCHER,
-      SessionStateAnimator::ANIMATION_FADE_IN,
+      SessionStateAnimator::LAUNCHER, SessionStateAnimator::ANIMATION_FADE_IN,
       SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS);
   AnimateBackgroundHidingIfNecessary(
       SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS, animation_sequence);
   animation_sequence->EndSequence();
 }
 
 void LockStateController::LockAnimationCancelled() {
   can_cancel_lock_animation_ = false;
   RestoreUnlockedProperties();
 }
@@ skipping 22 matching lines @@
 #if defined(OS_CHROMEOS)
   // Increase lock timeout for slower hardware, see http://crbug.com/350628
   const std::string board = base::SysInfo::GetLsbReleaseBoard();
   if (board == "x86-mario" ||
       base::StartsWith(board, "x86-alex", base::CompareCase::SENSITIVE) ||
       base::StartsWith(board, "x86-zgb", base::CompareCase::SENSITIVE) ||
       base::StartsWith(board, "daisy", base::CompareCase::SENSITIVE)) {
     timeout *= 2;
   }
 #endif
-  lock_fail_timer_.Start(
-      FROM_HERE, timeout, this, &LockStateController::OnLockFailTimeout);
+  lock_fail_timer_.Start(FROM_HERE, timeout, this,
+                         &LockStateController::OnLockFailTimeout);
 
   lock_duration_timer_.reset(new base::ElapsedTimer());
 }
 
 void LockStateController::PostLockAnimationFinished() {
   animating_lock_ = false;
   VLOG(1) << "PostLockAnimationFinished";
-  FOR_EACH_OBSERVER(LockStateObserver, observers_,
+  FOR_EACH_OBSERVER(
+      LockStateObserver, observers_,
       OnLockStateEvent(LockStateObserver::EVENT_LOCK_ANIMATION_FINISHED));
   if (!lock_screen_displayed_callback_.is_null()) {
     lock_screen_displayed_callback_.Run();
     lock_screen_displayed_callback_.Reset();
   }
   CHECK(!views::MenuController::GetActiveInstance());
   if (shutdown_after_lock_) {
     shutdown_after_lock_ = false;
     StartLockToShutdownTimer();
   }
@@ skipping 29 matching lines @@
                               SessionStateAnimator::ANIMATION_SPEED_IMMEDIATE);
   }
   unlocked_properties_.reset();
 }
 
 void LockStateController::AnimateBackgroundAppearanceIfNecessary(
     SessionStateAnimator::AnimationSpeed speed,
     SessionStateAnimator::AnimationSequence* animation_sequence) {
   if (unlocked_properties_.get() &&
       unlocked_properties_->background_is_hidden) {
-    animation_sequence->StartAnimation(
-        SessionStateAnimator::DESKTOP_BACKGROUND,
-        SessionStateAnimator::ANIMATION_FADE_IN,
-        speed);
+    animation_sequence->StartAnimation(SessionStateAnimator::DESKTOP_BACKGROUND,
+                                       SessionStateAnimator::ANIMATION_FADE_IN,
+                                       speed);
   }
 }
 
 void LockStateController::AnimateBackgroundHidingIfNecessary(
     SessionStateAnimator::AnimationSpeed speed,
     SessionStateAnimator::AnimationSequence* animation_sequence) {
   if (unlocked_properties_.get() &&
       unlocked_properties_->background_is_hidden) {
-    animation_sequence->StartAnimation(
-        SessionStateAnimator::DESKTOP_BACKGROUND,
-        SessionStateAnimator::ANIMATION_FADE_OUT,
-        speed);
+    animation_sequence->StartAnimation(SessionStateAnimator::DESKTOP_BACKGROUND,
+                                       SessionStateAnimator::ANIMATION_FADE_OUT,
+                                       speed);
   }
 }
 
 }  // namespace ash