[Smart Lock] Extract the screenlock state to the proximity_auth component.

chrome/browser/signin/easy_unlock_service.cc

 // Copyright 2014 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 "chrome/browser/signin/easy_unlock_service.h"
 
 #include "apps/app_lifetime_monitor.h"
 #include "apps/app_lifetime_monitor_factory.h"
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 31 matching lines @@
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/power_manager_client.h"
 #include "components/user_manager/user_manager.h"
 #endif
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #endif
 
+using proximity_auth::ScreenlockState;
+
 namespace {
 
 enum BluetoothType {
   BT_NO_ADAPTER,
   BT_NORMAL,
   BT_LOW_ENERGY_CAPABLE,
   BT_MAX_TYPE
 };
 
 PrefService* GetLocalState() {
@@ skipping 365 matching lines @@
   if (!GetScreenlockStateHandler())
     return;
 
   EasyUnlockScreenlockStateHandler::HardlockState state;
   bool has_persisted_state = GetPersistedHardlockState(&state);
   if (!has_persisted_state)
     return;
 
   if (state == EasyUnlockScreenlockStateHandler::NO_HARDLOCK) {
     // Show connecting icon early when there is a persisted non hardlock state.
-    UpdateScreenlockState(
-        EasyUnlockScreenlockStateHandler::STATE_BLUETOOTH_CONNECTING);
+    UpdateScreenlockState(ScreenlockState::BLUETOOTH_CONNECTING);
   } else {
     screenlock_state_handler_->MaybeShowHardlockUI();
   }
 }
 
 EasyUnlockScreenlockStateHandler*
     EasyUnlockService::GetScreenlockStateHandler() {
   if (!IsAllowed())
     return NULL;
   if (!screenlock_state_handler_) {
     screenlock_state_handler_.reset(new EasyUnlockScreenlockStateHandler(
         GetUserEmail(), GetHardlockState(), GetScreenlockBridgeInstance()));
   }
   return screenlock_state_handler_.get();
 }
 
-bool EasyUnlockService::UpdateScreenlockState(
-    EasyUnlockScreenlockStateHandler::State state) {
+bool EasyUnlockService::UpdateScreenlockState(ScreenlockState state) {
   EasyUnlockScreenlockStateHandler* handler = GetScreenlockStateHandler();
   if (!handler)
     return false;
 
   handler->ChangeState(state);
 
-  if (state == EasyUnlockScreenlockStateHandler::STATE_AUTHENTICATED) {
+  if (state == ScreenlockState::AUTHENTICATED) {
 #if defined(OS_CHROMEOS)
     if (power_monitor_)
       power_monitor_->RecordStartUpTime();
 #endif
   } else if (auth_attempt_.get()) {
     // Clean up existing auth attempt if we can no longer authenticate the
     // remote device.
     auth_attempt_.reset();
 
     if (!handler->InStateValidOnRemoteAuthFailure())
       HandleAuthFailure(GetUserEmail());
   }
 
   FOR_EACH_OBSERVER(
       EasyUnlockServiceObserver, observers_, OnScreenlockStateChanged(state));
   return true;
 }
 
-EasyUnlockScreenlockStateHandler::State
-EasyUnlockService::GetScreenlockState() {
+ScreenlockState EasyUnlockService::GetScreenlockState() {
   EasyUnlockScreenlockStateHandler* handler = GetScreenlockStateHandler();
   if (!handler)
-    return EasyUnlockScreenlockStateHandler::STATE_INACTIVE;
+    return ScreenlockState::INACTIVE;
 
   return handler->state();
 }
 
 void EasyUnlockService::AttemptAuth(const std::string& user_id) {
   AttemptAuth(user_id, AttemptAuthCallback());
 }
 
 void EasyUnlockService::AttemptAuth(const std::string& user_id,
                                     const AttemptAuthCallback& callback) {
@@ skipping 272 matching lines @@
         return PASSWORD_ENTRY_PAIRING_CHANGED;
       case EasyUnlockScreenlockStateHandler::LOGIN_FAILED:
         return PASSWORD_ENTRY_LOGIN_FAILED;
       case EasyUnlockScreenlockStateHandler::PAIRING_ADDED:
         return PASSWORD_ENTRY_PAIRING_ADDED;
     }
   } else if (!screenlock_state_handler()) {
     return PASSWORD_ENTRY_NO_SCREENLOCK_STATE_HANDLER;
   } else {
     switch (screenlock_state_handler()->state()) {
-      case EasyUnlockScreenlockStateHandler::STATE_INACTIVE:
+      case ScreenlockState::INACTIVE:
         return PASSWORD_ENTRY_SERVICE_NOT_ACTIVE;
-      case EasyUnlockScreenlockStateHandler::STATE_NO_BLUETOOTH:
+      case ScreenlockState::NO_BLUETOOTH:
         return PASSWORD_ENTRY_NO_BLUETOOTH;
-      case EasyUnlockScreenlockStateHandler::STATE_BLUETOOTH_CONNECTING:
+      case ScreenlockState::BLUETOOTH_CONNECTING:
         return PASSWORD_ENTRY_BLUETOOTH_CONNECTING;
-      case EasyUnlockScreenlockStateHandler::STATE_NO_PHONE:
+      case ScreenlockState::NO_PHONE:
         return PASSWORD_ENTRY_NO_PHONE;
-      case EasyUnlockScreenlockStateHandler::STATE_PHONE_NOT_AUTHENTICATED:
+      case ScreenlockState::PHONE_NOT_AUTHENTICATED:
         return PASSWORD_ENTRY_PHONE_NOT_AUTHENTICATED;
-      case EasyUnlockScreenlockStateHandler::STATE_PHONE_LOCKED:
+      case ScreenlockState::PHONE_LOCKED:
         return PASSWORD_ENTRY_PHONE_LOCKED;
-      case EasyUnlockScreenlockStateHandler::STATE_PHONE_UNLOCKABLE:
+      case ScreenlockState::PHONE_NOT_LOCKABLE:
         return PASSWORD_ENTRY_PHONE_NOT_LOCKABLE;
-      case EasyUnlockScreenlockStateHandler::STATE_PHONE_UNSUPPORTED:
+      case ScreenlockState::PHONE_UNSUPPORTED:
         return PASSWORD_ENTRY_PHONE_UNSUPPORTED;
-      case EasyUnlockScreenlockStateHandler::STATE_RSSI_TOO_LOW:
+      case ScreenlockState::RSSI_TOO_LOW:
         return PASSWORD_ENTRY_RSSI_TOO_LOW;
-      case EasyUnlockScreenlockStateHandler::STATE_TX_POWER_TOO_HIGH:
+      case ScreenlockState::TX_POWER_TOO_HIGH:
         return PASSWORD_ENTRY_TX_POWER_TOO_HIGH;
-      case EasyUnlockScreenlockStateHandler::
-               STATE_PHONE_LOCKED_AND_TX_POWER_TOO_HIGH:
+      case ScreenlockState::PHONE_LOCKED_AND_TX_POWER_TOO_HIGH:
         return PASSWORD_ENTRY_PHONE_LOCKED_AND_TX_POWER_TOO_HIGH;
-      case EasyUnlockScreenlockStateHandler::STATE_AUTHENTICATED:
+      case ScreenlockState::AUTHENTICATED:
         return PASSWORD_ENTRY_WITH_AUTHENTICATED_PHONE;
     }
   }
 
   NOTREACHED();
   return EASY_UNLOCK_AUTH_EVENT_COUNT;
 }
 
 #if defined(OS_CHROMEOS)
 void EasyUnlockService::OnCryptohomeKeysFetchedForChecking(
@@ skipping 19 matching lines @@
         user_id,
         devices_in_cryptohome.empty()
             ? EasyUnlockScreenlockStateHandler::PAIRING_ADDED
             : EasyUnlockScreenlockStateHandler::PAIRING_CHANGED);
   }
 }
 #endif
 
 void EasyUnlockService::PrepareForSuspend() {
   app_manager_->DisableAppIfLoaded();
-  if (screenlock_state_handler_ && screenlock_state_handler_->IsActive()) {
-    UpdateScreenlockState(
-        EasyUnlockScreenlockStateHandler::STATE_BLUETOOTH_CONNECTING);
-  }
+  if (screenlock_state_handler_ && screenlock_state_handler_->IsActive())
+    UpdateScreenlockState(ScreenlockState::BLUETOOTH_CONNECTING);
 }
 
 void EasyUnlockService::EnsureTpmKeyPresentIfNeeded() {
   if (tpm_key_checked_ || GetType() != TYPE_REGULAR || GetUserEmail().empty() ||
       GetHardlockState() == EasyUnlockScreenlockStateHandler::NO_PAIRING) {
     return;
   }
 
 #if defined(OS_CHROMEOS)
   // If this is called before the session is started, the chances are Chrome
   // is restarting in order to apply user flags. Don't check TPM keys in this
   // case.
   if (!user_manager::UserManager::Get() ||
       !user_manager::UserManager::Get()->IsSessionStarted())
     return;
 
   // TODO(tbarzic): Set check_private_key only if previous sign-in attempt
   // failed.
   EasyUnlockTpmKeyManagerFactory::GetInstance()->Get(profile_)
       ->PrepareTpmKey(true /* check_private_key */,
                       base::Closure());
 #endif  // defined(OS_CHROMEOS)
 
   tpm_key_checked_ = true;
 }