ash: Use session_manager::SessionState

ash/common/test/test_session_state_delegate.cc

 // Copyright (c) 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/common/test/test_session_state_delegate.h"
 
 #include <algorithm>
 #include <string>
 
 #include "ash/common/login_status.h"
@@ skipping 75 matching lines @@
 };
 
 TestSessionStateDelegate::TestSessionStateDelegate()
     : can_lock_screen_(true),
       should_lock_screen_before_suspending_(false),
       screen_locked_(false),
       user_adding_screen_running_(false),
       logged_in_users_(1),
       active_user_index_(0),
       user_manager_(new TestUserManager()),
-      session_state_(SESSION_STATE_LOGIN_PRIMARY) {
+      session_state_(session_manager::SessionState::LOGIN_PRIMARY) {
   // This is intended to be capitalized.
   user_list_.push_back(base::MakeUnique<MockUserInfo>("First@tray"));
   // This is intended to be capitalized.
   user_list_.push_back(base::MakeUnique<MockUserInfo>("Second@tray"));
   user_list_.push_back(base::MakeUnique<MockUserInfo>("third@tray"));
   user_list_.push_back(base::MakeUnique<MockUserInfo>("someone@tray"));
 }
 
 TestSessionStateDelegate::~TestSessionStateDelegate() {}
 
@@ skipping 11 matching lines @@
   return 3;
 }
 
 int TestSessionStateDelegate::NumberOfLoggedInUsers() const {
   // TODO(skuhne): Add better test framework to test multiple profiles.
   return IsActiveUserSessionStarted() ? logged_in_users_ : 0;
 }
 
 bool TestSessionStateDelegate::IsActiveUserSessionStarted() const {
   return user_manager_->IsSessionStarted() &&
-         session_state_ == SESSION_STATE_ACTIVE;
+         session_state_ == session_manager::SessionState::ACTIVE;
 }
 
 bool TestSessionStateDelegate::CanLockScreen() const {
   return IsActiveUserSessionStarted() && can_lock_screen_;
 }
 
 bool TestSessionStateDelegate::IsScreenLocked() const {
   return screen_locked_;
 }
 
 bool TestSessionStateDelegate::ShouldLockScreenBeforeSuspending() const {
   return should_lock_screen_before_suspending_;
 }
 
 void TestSessionStateDelegate::LockScreen() {
   if (CanLockScreen())
     screen_locked_ = true;
 }
 
 void TestSessionStateDelegate::UnlockScreen() {
   screen_locked_ = false;
 }
 
 bool TestSessionStateDelegate::IsUserSessionBlocked() const {
   return !IsActiveUserSessionStarted() || IsScreenLocked() ||
-         user_adding_screen_running_ || session_state_ != SESSION_STATE_ACTIVE;
+         user_adding_screen_running_ ||
+         session_state_ != session_manager::SessionState::ACTIVE;
 }
 
-SessionStateDelegate::SessionState TestSessionStateDelegate::GetSessionState()
+session_manager::SessionState TestSessionStateDelegate::GetSessionState()
     const {
   return session_state_;
 }
 
 void TestSessionStateDelegate::SetHasActiveUser(bool has_active_user) {
   if (!has_active_user) {
-    session_state_ = SESSION_STATE_LOGIN_PRIMARY;
+    session_state_ = session_manager::SessionState::LOGIN_PRIMARY;
   } else {
-    session_state_ = SESSION_STATE_ACTIVE;
+    session_state_ = session_manager::SessionState::ACTIVE;
     WmShell::Get()->ShowShelf();
   }
 }
 
 void TestSessionStateDelegate::SetActiveUserSessionStarted(
     bool active_user_session_started) {
   if (active_user_session_started) {
     user_manager_->SessionStarted();
-    session_state_ = SESSION_STATE_ACTIVE;
+    session_state_ = session_manager::SessionState::ACTIVE;
     WmShell::Get()->CreateShelf();
     WmShell::Get()->UpdateAfterLoginStatusChange(LoginStatus::USER);
   } else {
-    session_state_ = SESSION_STATE_LOGIN_PRIMARY;
+    session_state_ = session_manager::SessionState::LOGIN_PRIMARY;
     user_manager_.reset(new TestUserManager());
   }
 }
 
 // static
 void TestSessionStateDelegate::SetCanLockScreen(bool can_lock_screen) {
   CHECK(WmShell::HasInstance());
   static_cast<ash::test::TestSessionStateDelegate*>(
       WmShell::Get()->GetSessionStateDelegate())
       ->can_lock_screen_ = can_lock_screen;
 }
 
 void TestSessionStateDelegate::SetShouldLockScreenBeforeSuspending(
     bool should_lock) {
   should_lock_screen_before_suspending_ = should_lock;
 }
 
 void TestSessionStateDelegate::SetUserAddingScreenRunning(
     bool user_adding_screen_running) {
   user_adding_screen_running_ = user_adding_screen_running;
   if (user_adding_screen_running_)
-    session_state_ = SESSION_STATE_LOGIN_SECONDARY;
+    session_state_ = session_manager::SessionState::LOGIN_SECONDARY;
   else
-    session_state_ = SESSION_STATE_ACTIVE;
+    session_state_ = session_manager::SessionState::ACTIVE;
 }
 
 void TestSessionStateDelegate::SetUserImage(const gfx::ImageSkia& user_image) {
   user_list_[active_user_index_]->SetUserImage(user_image);
 }
 
 const user_manager::UserInfo* TestSessionStateDelegate::GetUserInfo(
     UserIndex index) const {
   int max = static_cast<int>(user_list_.size());
   return user_list_[index < max ? index : max - 1].get();
@@ skipping 32 matching lines @@
 }
 
 void TestSessionStateDelegate::AddSessionStateObserver(
     SessionStateObserver* observer) {}
 
 void TestSessionStateDelegate::RemoveSessionStateObserver(
     SessionStateObserver* observer) {}
 
 }  // namespace test
 }  // namespace ash