Eliminate ash::internal namespace

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 "ash/accessibility_delegate.h"
 #include "ash/ash_switches.h"
@@ skipping 23 matching lines @@
 
 namespace ash {
 
 namespace {
 
 const int kMaxShutdownSoundDurationMs = 1500;
 
 aura::Window* GetBackground() {
   aura::Window* root_window = Shell::GetPrimaryRootWindow();
   return Shell::GetContainer(root_window,
-      internal::kShellWindowId_DesktopBackgroundContainer);
+                             kShellWindowId_DesktopBackgroundContainer);
 }
 
 bool IsBackgroundHidden() {
   return !GetBackground()->IsVisible();
 }
 
 void ShowBackground() {
   ui::ScopedLayerAnimationSettings settings(
       GetBackground()->layer()->GetAnimator());
   settings.SetTransitionDuration(base::TimeDelta());
@@ skipping 99 matching lines @@
 const int LockStateController::kShutdownRequestDelayMs = 50;
 
 LockStateController::TestApi::TestApi(LockStateController* controller)
     : controller_(controller) {
 }
 
 LockStateController::TestApi::~TestApi() {
 }
 
 LockStateController::LockStateController()
-    : animator_(new internal::SessionStateAnimator()),
+    : animator_(new SessionStateAnimator()),
       login_status_(user::LOGGED_IN_NONE),
       system_is_locked_(false),
       shutting_down_(false),
       shutdown_after_lock_(false),
       animating_lock_(false),
       can_cancel_lock_animation_(false),
       weak_ptr_factory_(this) {
   Shell::GetPrimaryRootWindow()->GetHost()->AddObserver(this);
 }
 
@@ skipping 69 matching lines @@
   if (lock_to_shutdown_timer_.IsRunning()) {
     lock_to_shutdown_timer_.Stop();
     return;
   }
   if (shutdown_after_lock_) {
     shutdown_after_lock_ = false;
     return;
   }
 
   animator_->StartGlobalAnimation(
-      internal::SessionStateAnimator::ANIMATION_UNDO_GRAYSCALE_BRIGHTNESS,
-      internal::SessionStateAnimator::ANIMATION_SPEED_REVERT_SHUTDOWN);
+      SessionStateAnimator::ANIMATION_UNDO_GRAYSCALE_BRIGHTNESS,
+      SessionStateAnimator::ANIMATION_SPEED_REVERT_SHUTDOWN);
   pre_shutdown_timer_.Stop();
 }
 
 void LockStateController::OnStartingLock() {
   if (shutting_down_ || system_is_locked_)
     return;
   if (animating_lock_)
     return;
   StartImmediatePreLockAnimation(false /* request_lock_on_completion */);
 }
 
 void LockStateController::RequestShutdown() {
   if (shutting_down_)
     return;
 
   shutting_down_ = true;
 
   Shell* shell = ash::Shell::GetInstance();
   shell->cursor_manager()->HideCursor();
   shell->cursor_manager()->LockCursor();
 
   animator_->StartGlobalAnimation(
-      internal::SessionStateAnimator::ANIMATION_GRAYSCALE_BRIGHTNESS,
-      internal::SessionStateAnimator::ANIMATION_SPEED_SHUTDOWN);
+      SessionStateAnimator::ANIMATION_GRAYSCALE_BRIGHTNESS,
+      SessionStateAnimator::ANIMATION_SPEED_SHUTDOWN);
   StartRealShutdownTimer(true);
 }
 
 void LockStateController::OnLockScreenHide(
   base::Callback<void(void)>& callback) {
   StartUnlockAnimationBeforeUIDestroyed(callback);
 }
 
 void LockStateController::SetLockScreenDisplayedCallback(
     const base::Closure& callback) {
@@ skipping 14 matching lines @@
 
 void LockStateController::OnAppTerminating() {
   // If we hear that Chrome is exiting but didn't request it ourselves, all we
   // can really hope for is that we'll have time to clear the screen.
   // This is also the case when the user signs off.
   if (!shutting_down_) {
     shutting_down_ = true;
     Shell* shell = ash::Shell::GetInstance();
     shell->cursor_manager()->HideCursor();
     shell->cursor_manager()->LockCursor();
-    animator_->StartAnimation(
-        internal::SessionStateAnimator::kAllContainersMask,
-        internal::SessionStateAnimator::ANIMATION_HIDE_IMMEDIATELY,
-        internal::SessionStateAnimator::ANIMATION_SPEED_IMMEDIATE);
+    animator_->StartAnimation(SessionStateAnimator::kAllContainersMask,
+                              SessionStateAnimator::ANIMATION_HIDE_IMMEDIATELY,
+                              SessionStateAnimator::ANIMATION_SPEED_IMMEDIATE);
   }
 }
 
 void LockStateController::OnLockStateChanged(bool locked) {
   VLOG(1) << "OnLockStateChanged " << locked;
   if (shutting_down_ || (system_is_locked_ == locked))
     return;
 
   system_is_locked_ = locked;
 
@@ skipping 22 matching lines @@
 
 void LockStateController::OnLockToShutdownTimeout() {
   DCHECK(system_is_locked_);
   StartCancellableShutdownAnimation();
 }
 
 void LockStateController::StartPreShutdownAnimationTimer() {
   pre_shutdown_timer_.Stop();
   pre_shutdown_timer_.Start(
       FROM_HERE,
-      animator_->
-          GetDuration(internal::SessionStateAnimator::ANIMATION_SPEED_SHUTDOWN),
+      animator_->GetDuration(SessionStateAnimator::ANIMATION_SPEED_SHUTDOWN),
       this,
       &LockStateController::OnPreShutdownAnimationTimeout);
 }
 
 void LockStateController::OnPreShutdownAnimationTimeout() {
   VLOG(1) << "OnPreShutdownAnimationTimeout";
   shutting_down_ = true;
 
   Shell* shell = ash::Shell::GetInstance();
   shell->cursor_manager()->HideCursor();
 
   StartRealShutdownTimer(false);
 }
 
 void LockStateController::StartRealShutdownTimer(bool with_animation_time) {
   base::TimeDelta duration =
       base::TimeDelta::FromMilliseconds(kShutdownRequestDelayMs);
   if (with_animation_time) {
-    duration += animator_->GetDuration(
-        internal::SessionStateAnimator::ANIMATION_SPEED_SHUTDOWN);
+    duration +=
+        animator_->GetDuration(SessionStateAnimator::ANIMATION_SPEED_SHUTDOWN);
   }
 
 #if defined(OS_CHROMEOS)
   const AccessibilityDelegate* const delegate =
       Shell::GetInstance()->accessibility_delegate();
   base::TimeDelta sound_duration = delegate->PlayShutdownSound();
   sound_duration =
       std::min(sound_duration,
                base::TimeDelta::FromMilliseconds(kMaxShutdownSoundDurationMs));
   duration = std::max(duration, sound_duration);
@@ skipping 19 matching lines @@
       UMA_ACCEL_SHUT_DOWN_POWER_BUTTON);
   delegate_->RequestShutdown();
 }
 
 void LockStateController::StartCancellableShutdownAnimation() {
   Shell* shell = ash::Shell::GetInstance();
   // Hide cursor, but let it reappear if the mouse moves.
   shell->cursor_manager()->HideCursor();
 
   animator_->StartGlobalAnimation(
-      internal::SessionStateAnimator::ANIMATION_GRAYSCALE_BRIGHTNESS,
-      internal::SessionStateAnimator::ANIMATION_SPEED_SHUTDOWN);
+      SessionStateAnimator::ANIMATION_GRAYSCALE_BRIGHTNESS,
+      SessionStateAnimator::ANIMATION_SPEED_SHUTDOWN);
   StartPreShutdownAnimationTimer();
 }
 
 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);
   AnimationFinishedObserver* observer =
       new AnimationFinishedObserver(next_animation_starter);
 
   observer->Pause();
 
   animator_->StartAnimationWithObserver(
-      internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
-      internal::SessionStateAnimator::ANIMATION_LIFT,
-      internal::SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS,
+      SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
+      SessionStateAnimator::ANIMATION_LIFT,
+      SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS,
       observer);
   animator_->StartAnimationWithObserver(
-      internal::SessionStateAnimator::LAUNCHER,
-      internal::SessionStateAnimator::ANIMATION_FADE_OUT,
-      internal::SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS,
+      SessionStateAnimator::LAUNCHER,
+      SessionStateAnimator::ANIMATION_FADE_OUT,
+      SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS,
       observer);
   // Hide the screen locker containers so we can raise them later.
-  animator_->StartAnimation(
-      internal::SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
-      internal::SessionStateAnimator::ANIMATION_HIDE_IMMEDIATELY,
-      internal::SessionStateAnimator::ANIMATION_SPEED_IMMEDIATE);
+  animator_->StartAnimation(SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
+                            SessionStateAnimator::ANIMATION_HIDE_IMMEDIATELY,
+                            SessionStateAnimator::ANIMATION_SPEED_IMMEDIATE);
   AnimateBackgroundAppearanceIfNecessary(
-      internal::SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS,
-      observer);
+      SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS, observer);
 
   observer->Unpause();
 
   DispatchCancelMode();
   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 */);
   AnimationFinishedObserver* observer =
       new AnimationFinishedObserver(next_animation_starter);
 
   observer->Pause();
 
   animator_->StartAnimationWithObserver(
-      internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
-      internal::SessionStateAnimator::ANIMATION_LIFT,
-      internal::SessionStateAnimator::ANIMATION_SPEED_UNDOABLE,
+      SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
+      SessionStateAnimator::ANIMATION_LIFT,
+      SessionStateAnimator::ANIMATION_SPEED_UNDOABLE,
       observer);
   animator_->StartAnimationWithObserver(
-      internal::SessionStateAnimator::LAUNCHER,
-      internal::SessionStateAnimator::ANIMATION_FADE_OUT,
-      internal::SessionStateAnimator::ANIMATION_SPEED_UNDOABLE,
+      SessionStateAnimator::LAUNCHER,
+      SessionStateAnimator::ANIMATION_FADE_OUT,
+      SessionStateAnimator::ANIMATION_SPEED_UNDOABLE,
       observer);
   // Hide the screen locker containers so we can raise them later.
-  animator_->StartAnimation(
-      internal::SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
-      internal::SessionStateAnimator::ANIMATION_HIDE_IMMEDIATELY,
-      internal::SessionStateAnimator::ANIMATION_SPEED_IMMEDIATE);
+  animator_->StartAnimation(SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
+                            SessionStateAnimator::ANIMATION_HIDE_IMMEDIATELY,
+                            SessionStateAnimator::ANIMATION_SPEED_IMMEDIATE);
   AnimateBackgroundAppearanceIfNecessary(
-      internal::SessionStateAnimator::ANIMATION_SPEED_UNDOABLE,
-      observer);
+      SessionStateAnimator::ANIMATION_SPEED_UNDOABLE, observer);
 
   DispatchCancelMode();
   FOR_EACH_OBSERVER(LockStateObserver, observers_,
       OnLockStateEvent(LockStateObserver::EVENT_PRELOCK_ANIMATION_STARTED));
   observer->Unpause();
 }
 
 void LockStateController::CancelPreLockAnimation() {
   VLOG(1) << "CancelPreLockAnimation";
   base::Closure next_animation_starter =
       base::Bind(&LockStateController::LockAnimationCancelled,
                  weak_ptr_factory_.GetWeakPtr());
   AnimationFinishedObserver* observer =
       new AnimationFinishedObserver(next_animation_starter);
 
   observer->Pause();
 
   animator_->StartAnimationWithObserver(
-      internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
-      internal::SessionStateAnimator::ANIMATION_UNDO_LIFT,
-      internal::SessionStateAnimator::ANIMATION_SPEED_UNDO_MOVE_WINDOWS,
+      SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
+      SessionStateAnimator::ANIMATION_UNDO_LIFT,
+      SessionStateAnimator::ANIMATION_SPEED_UNDO_MOVE_WINDOWS,
       observer);
   animator_->StartAnimationWithObserver(
-      internal::SessionStateAnimator::LAUNCHER,
-      internal::SessionStateAnimator::ANIMATION_FADE_IN,
-      internal::SessionStateAnimator::ANIMATION_SPEED_UNDO_MOVE_WINDOWS,
+      SessionStateAnimator::LAUNCHER,
+      SessionStateAnimator::ANIMATION_FADE_IN,
+      SessionStateAnimator::ANIMATION_SPEED_UNDO_MOVE_WINDOWS,
       observer);
   AnimateBackgroundHidingIfNecessary(
-      internal::SessionStateAnimator::ANIMATION_SPEED_UNDO_MOVE_WINDOWS,
-      observer);
+      SessionStateAnimator::ANIMATION_SPEED_UNDO_MOVE_WINDOWS, observer);
 
   observer->Unpause();
 }
 
 void LockStateController::StartPostLockAnimation() {
   VLOG(1) << "StartPostLockAnimation";
   base::Closure next_animation_starter =
       base::Bind(&LockStateController::PostLockAnimationFinished,
                  weak_ptr_factory_.GetWeakPtr());
 
   AnimationFinishedObserver* observer =
       new AnimationFinishedObserver(next_animation_starter);
 
   observer->Pause();
   animator_->StartAnimationWithObserver(
-      internal::SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
-      internal::SessionStateAnimator::ANIMATION_RAISE_TO_SCREEN,
-      internal::SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS,
+      SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
+      SessionStateAnimator::ANIMATION_RAISE_TO_SCREEN,
+      SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS,
       observer);
   observer->Unpause();
 }
 
 void LockStateController::StartUnlockAnimationBeforeUIDestroyed(
     base::Closure& callback) {
   VLOG(1) << "StartUnlockAnimationBeforeUIDestroyed";
   animator_->StartAnimationWithCallback(
-      internal::SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
-      internal::SessionStateAnimator::ANIMATION_LIFT,
-      internal::SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS,
+      SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
+      SessionStateAnimator::ANIMATION_LIFT,
+      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());
 
   AnimationFinishedObserver* observer =
       new AnimationFinishedObserver(next_animation_starter);
 
   observer->Pause();
 
   animator_->StartAnimationWithObserver(
-      internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
-      internal::SessionStateAnimator::ANIMATION_DROP,
-      internal::SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS,
+      SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
+      SessionStateAnimator::ANIMATION_DROP,
+      SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS,
       observer);
   animator_->StartAnimationWithObserver(
-      internal::SessionStateAnimator::LAUNCHER,
-      internal::SessionStateAnimator::ANIMATION_FADE_IN,
-      internal::SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS,
+      SessionStateAnimator::LAUNCHER,
+      SessionStateAnimator::ANIMATION_FADE_IN,
+      SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS,
       observer);
   AnimateBackgroundHidingIfNecessary(
-      internal::SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS,
-      observer);
+      SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS, observer);
   observer->Unpause();
 }
 
 void LockStateController::LockAnimationCancelled() {
   can_cancel_lock_animation_ = false;
   RestoreUnlockedProperties();
 }
 
 void LockStateController::PreLockAnimationFinished(bool request_lock) {
   can_cancel_lock_animation_ = false;
@@ skipping 46 matching lines @@
   RestoreUnlockedProperties();
 }
 
 void LockStateController::StoreUnlockedProperties() {
   if (!unlocked_properties_) {
     unlocked_properties_.reset(new UnlockedStateProperties());
     unlocked_properties_->background_is_hidden = IsBackgroundHidden();
   }
   if (unlocked_properties_->background_is_hidden) {
     // Hide background so that it can be animated later.
-    animator_->StartAnimation(
-        internal::SessionStateAnimator::DESKTOP_BACKGROUND,
-        internal::SessionStateAnimator::ANIMATION_HIDE_IMMEDIATELY,
-        internal::SessionStateAnimator::ANIMATION_SPEED_IMMEDIATE);
+    animator_->StartAnimation(SessionStateAnimator::DESKTOP_BACKGROUND,
+                              SessionStateAnimator::ANIMATION_HIDE_IMMEDIATELY,
+                              SessionStateAnimator::ANIMATION_SPEED_IMMEDIATE);
     ShowBackground();
   }
 }
 
 void LockStateController::RestoreUnlockedProperties() {
   if (!unlocked_properties_)
     return;
   if (unlocked_properties_->background_is_hidden) {
     HideBackground();
     // Restore background visibility.
-    animator_->StartAnimation(
-        internal::SessionStateAnimator::DESKTOP_BACKGROUND,
-        internal::SessionStateAnimator::ANIMATION_FADE_IN,
-        internal::SessionStateAnimator::ANIMATION_SPEED_IMMEDIATE);
+    animator_->StartAnimation(SessionStateAnimator::DESKTOP_BACKGROUND,
+                              SessionStateAnimator::ANIMATION_FADE_IN,
+                              SessionStateAnimator::ANIMATION_SPEED_IMMEDIATE);
   }
   unlocked_properties_.reset();
 }
 
 void LockStateController::AnimateBackgroundAppearanceIfNecessary(
-    internal::SessionStateAnimator::AnimationSpeed speed,
+    SessionStateAnimator::AnimationSpeed speed,
     ui::LayerAnimationObserver* observer) {
   if (unlocked_properties_.get() &&
       unlocked_properties_->background_is_hidden) {
     animator_->StartAnimationWithObserver(
-        internal::SessionStateAnimator::DESKTOP_BACKGROUND,
-        internal::SessionStateAnimator::ANIMATION_FADE_IN,
+        SessionStateAnimator::DESKTOP_BACKGROUND,
+        SessionStateAnimator::ANIMATION_FADE_IN,
         speed,
         observer);
   }
 }
 
 void LockStateController::AnimateBackgroundHidingIfNecessary(
-    internal::SessionStateAnimator::AnimationSpeed speed,
+    SessionStateAnimator::AnimationSpeed speed,
     ui::LayerAnimationObserver* observer) {
   if (unlocked_properties_.get() &&
       unlocked_properties_->background_is_hidden) {
     animator_->StartAnimationWithObserver(
-        internal::SessionStateAnimator::DESKTOP_BACKGROUND,
-        internal::SessionStateAnimator::ANIMATION_FADE_OUT,
+        SessionStateAnimator::DESKTOP_BACKGROUND,
+        SessionStateAnimator::ANIMATION_FADE_OUT,
         speed,
         observer);
   }
 }
 
 }  // namespace ash