Cancel partial screenshot UI when lock happens.

ash/wm/power_button_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/wm/power_button_controller.h"
 
 #include "ash/ash_switches.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/root_window_event_filter.h"
@@ skipping 258 matching lines @@
   }
   return true;
 }
 
 bool PowerButtonController::TestApi::BackgroundLayerIsVisible() const {
   return controller_->background_layer_.get() &&
          controller_->background_layer_->visible();
 }
 
 PowerButtonController::PowerButtonController()
-    : logged_in_(false),
-      is_guest_(false),
-      locked_(false),
+    : login_status_(user::LOGGED_IN_NONE),
+      unlocked_login_status_(user::LOGGED_IN_NONE),
       power_button_down_(false),
       lock_button_down_(false),
       shutting_down_(false),
       has_legacy_power_button_(
           CommandLine::ForCurrentProcess()->HasSwitch(
               switches::kAuraLegacyPowerButton)) {
 }
 
 PowerButtonController::~PowerButtonController() {
 }
 
-void PowerButtonController::OnLoginStateChange(bool logged_in, bool is_guest) {
-  logged_in_ = logged_in;
-  is_guest_ = is_guest;
+void PowerButtonController::OnLoginStateChanged(user::LoginStatus status) {
+  login_status_ = status;
+  unlocked_login_status_ = user::LOGGED_IN_NONE;
 }
 
-void PowerButtonController::OnExit() {
+void PowerButtonController::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.
   if (!shutting_down_) {
     shutting_down_ = true;
     ash::Shell::GetInstance()->root_filter()->
         set_update_cursor_visibility(false);
     Shell::GetRootWindow()->ShowCursor(false);
     ShowBackgroundLayer();
     StartAnimation(ALL_CONTAINERS, ANIMATION_HIDE);
   }
 }
 
-void PowerButtonController::OnLockStateChange(bool locked) {
-  if (shutting_down_ || locked_ == locked)
+void PowerButtonController::OnLockStateChanged(bool locked) {
+  if (shutting_down_ || (login_status_ == user::LOGGED_IN_LOCKED) == locked)
     return;
 
-  locked_ = locked;
+  if (!locked && login_status_ == user::LOGGED_IN_LOCKED) {
+    login_status_ = unlocked_login_status_;
+    unlocked_login_status_ = user::LOGGED_IN_NONE;
+  } else {
+    unlocked_login_status_ = login_status_;
+    login_status_ = user::LOGGED_IN_LOCKED;
+  }
+
   if (locked) {
     StartAnimation(SCREEN_LOCKER_CONTAINERS, ANIMATION_FADE_IN);
     lock_timer_.Stop();
     lock_fail_timer_.Stop();
 
     if (!has_legacy_power_button_ && power_button_down_) {
       lock_to_shutdown_timer_.Stop();
       lock_to_shutdown_timer_.Start(
           FROM_HERE,
           base::TimeDelta::FromMilliseconds(kLockToShutdownTimeoutMs),
           this, &PowerButtonController::OnLockToShutdownTimeout);
     }
   } else {
     StartAnimation(ALL_BUT_SCREEN_LOCKER_AND_RELATED_CONTAINERS,
                    ANIMATION_RESTORE);
     HideBackgroundLayer();
   }
 }
 
 void PowerButtonController::OnStartingLock() {
-  if (shutting_down_ || locked_)
+  if (shutting_down_ || login_status_ == user::LOGGED_IN_LOCKED)
     return;
 
   // Ensure that the background layer is visible -- if the screen was locked via
   // the wrench menu, we won't have already shown the background as part of the
   // slow-close animation.
   ShowBackgroundLayer();
 
   StartAnimation(ALL_BUT_SCREEN_LOCKER_AND_RELATED_CONTAINERS,
                  ANIMATION_FAST_CLOSE);
 
   // Hide the screen locker containers so we can make them fade in later.
   StartAnimation(SCREEN_LOCKER_CONTAINERS, ANIMATION_HIDE);
 }
 
 void PowerButtonController::OnPowerButtonEvent(
     bool down, const base::TimeTicks& timestamp) {
   power_button_down_ = down;
 
   if (shutting_down_)
     return;
 
   if (has_legacy_power_button_) {
     // If power button releases won't get reported correctly because we're not
     // running on official hardware, just lock the screen or shut down
     // immediately.
     if (down) {
       ShowBackgroundLayer();
-      if (logged_in_as_non_guest() && !locked_) {
+      if (LoggedInAsNonGuest() && login_status_ != user::LOGGED_IN_LOCKED) {
         StartAnimation(ALL_BUT_SCREEN_LOCKER_AND_RELATED_CONTAINERS,
                        ANIMATION_SLOW_CLOSE);
         OnLockTimeout();
       } else {
         OnShutdownTimeout();
       }
     }
   } else {  // !has_legacy_power_button_
     if (down) {
       // If we already have a pending request to lock the screen, wait.
       if (lock_fail_timer_.IsRunning())
         return;
 
-      if (logged_in_as_non_guest() && !locked_)
+      if (LoggedInAsNonGuest() && login_status_ != user::LOGGED_IN_LOCKED)
         StartLockTimer();
       else
         StartShutdownTimer();
     } else {  // Button is up.
       if (lock_timer_.IsRunning() || shutdown_timer_.IsRunning())
         StartAnimation(
-            locked_ ? SCREEN_LOCKER_AND_RELATED_CONTAINERS : ALL_CONTAINERS,
+            (login_status_ == user::LOGGED_IN_LOCKED) ?
+            SCREEN_LOCKER_AND_RELATED_CONTAINERS : ALL_CONTAINERS,
             ANIMATION_UNDO_SLOW_CLOSE);
 
       // Drop the background layer after the undo animation finishes.
       if (lock_timer_.IsRunning() ||
-          (shutdown_timer_.IsRunning() && !logged_in_as_non_guest())) {
+          (shutdown_timer_.IsRunning() && !LoggedInAsNonGuest())) {
         hide_background_layer_timer_.Stop();
         hide_background_layer_timer_.Start(
             FROM_HERE,
             base::TimeDelta::FromMilliseconds(kUndoSlowCloseAnimMs),
             this, &PowerButtonController::HideBackgroundLayer);
       }
 
       lock_timer_.Stop();
       shutdown_timer_.Stop();
       lock_to_shutdown_timer_.Stop();
     }
   }
 }
 
 void PowerButtonController::OnLockButtonEvent(
     bool down, const base::TimeTicks& timestamp) {
   lock_button_down_ = down;
 
-  if (shutting_down_ || !logged_in_as_non_guest())
+  if (shutting_down_ || !LoggedInAsNonGuest())
     return;
 
   // Bail if we're already locked or are in the process of locking.  Also give
   // the power button precedence over the lock button (we don't expect both
   // buttons to be present, so this is just making sure that we don't do
   // something completely stupid if that assumption changes later).
-  if (locked_ || lock_fail_timer_.IsRunning() || power_button_down_)
+  if (login_status_ == user::LOGGED_IN_LOCKED ||
+      lock_fail_timer_.IsRunning() || power_button_down_)
     return;
 
   if (down) {
     StartLockTimer();
   } else {
     if (lock_timer_.IsRunning()) {
       StartAnimation(ALL_BUT_SCREEN_LOCKER_AND_RELATED_CONTAINERS,
                      ANIMATION_UNDO_SLOW_CLOSE);
       hide_background_layer_timer_.Stop();
       hide_background_layer_timer_.Start(
           FROM_HERE,
           base::TimeDelta::FromMilliseconds(kUndoSlowCloseAnimMs),
           this, &PowerButtonController::HideBackgroundLayer);
       lock_timer_.Stop();
     }
   }
 }
 
 void PowerButtonController::RequestShutdown() {
   if (!shutting_down_)
     StartShutdownAnimationAndRequestShutdown();
 }
 
 void PowerButtonController::OnRootWindowResized(const aura::RootWindow* root,
                                                 const gfx::Size& new_size) {
   if (background_layer_.get())
     background_layer_->SetBounds(gfx::Rect(root->bounds().size()));
 }
 
+bool PowerButtonController::LoggedInAsNonGuest() const {
+  if (login_status_ == user::LOGGED_IN_NONE)
+    return false;
+  if (login_status_ == user::LOGGED_IN_GUEST)
+    return false;
+  // TODO(mukai): think about kiosk mode.
+  return true;
+}
+
 void PowerButtonController::OnLockTimeout() {
   delegate_->RequestLockScreen();
   lock_fail_timer_.Start(
       FROM_HERE,
       base::TimeDelta::FromMilliseconds(kLockFailTimeoutMs),
       this, &PowerButtonController::OnLockFailTimeout);
 }
 
 void PowerButtonController::OnLockFailTimeout() {
-  DCHECK(!locked_);
+  DCHECK_NE(login_status_, user::LOGGED_IN_LOCKED);
   LOG(ERROR) << "Screen lock request timed out";
   StartAnimation(ALL_BUT_SCREEN_LOCKER_AND_RELATED_CONTAINERS,
                  ANIMATION_RESTORE);
   HideBackgroundLayer();
 }
 
 void PowerButtonController::OnLockToShutdownTimeout() {
-  DCHECK(locked_);
+  DCHECK_EQ(login_status_, user::LOGGED_IN_LOCKED);
   StartShutdownTimer();
 }
 
 void PowerButtonController::OnShutdownTimeout() {
   if (!shutting_down_)
     StartShutdownAnimationAndRequestShutdown();
 }
 
 void PowerButtonController::OnRealShutdownTimeout() {
   DCHECK(shutting_down_);
@@ skipping 21 matching lines @@
 }
 
 void PowerButtonController::StartShutdownAnimationAndRequestShutdown() {
   DCHECK(!shutting_down_);
   shutting_down_ = true;
 
   ash::Shell::GetInstance()->root_filter()->set_update_cursor_visibility(false);
   Shell::GetRootWindow()->ShowCursor(false);
 
   ShowBackgroundLayer();
-  if (!logged_in_ || locked_) {
+  if (login_status_ != user::LOGGED_IN_NONE) {
     // Hide the other containers before starting the animation.
     // ANIMATION_FAST_CLOSE will make the screen locker windows partially
     // transparent, and we don't want the other windows to show through.
     StartAnimation(ALL_BUT_SCREEN_LOCKER_AND_RELATED_CONTAINERS,
                    ANIMATION_HIDE);
     StartAnimation(SCREEN_LOCKER_AND_RELATED_CONTAINERS, ANIMATION_FAST_CLOSE);
   } else {
     StartAnimation(ALL_CONTAINERS, ANIMATION_FAST_CLOSE);
   }
 
@@ skipping 18 matching lines @@
     root_layer->StackAtBottom(background_layer_.get());
   }
   background_layer_->SetVisible(true);
 }
 
 void PowerButtonController::HideBackgroundLayer() {
   background_layer_.reset();
 }
 
 }  // namespace ash