Move screenlock_bridge to components/proximity_auth

chrome/browser/signin/easy_unlock_screenlock_state_handler.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_screenlock_state_handler.h"
 
 #include "base/bind.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/chromeos/chromeos_utils.h"
 #include "chrome/browser/signin/easy_unlock_metrics.h"
 #include "chrome/grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace {
 
-ScreenlockBridge::UserPodCustomIcon GetIconForState(
+proximity_auth::ScreenlockBridge::UserPodCustomIcon GetIconForState(
     EasyUnlockScreenlockStateHandler::State state) {
   switch (state) {
     case EasyUnlockScreenlockStateHandler::STATE_NO_BLUETOOTH:
     case EasyUnlockScreenlockStateHandler::STATE_NO_PHONE:
     case EasyUnlockScreenlockStateHandler::STATE_PHONE_NOT_AUTHENTICATED:
     case EasyUnlockScreenlockStateHandler::STATE_PHONE_LOCKED:
     case EasyUnlockScreenlockStateHandler::STATE_PHONE_UNLOCKABLE:
     case EasyUnlockScreenlockStateHandler::STATE_PHONE_UNSUPPORTED:
     case EasyUnlockScreenlockStateHandler::STATE_RSSI_TOO_LOW:
-      return ScreenlockBridge::USER_POD_CUSTOM_ICON_LOCKED;
+      return proximity_auth::ScreenlockBridge::USER_POD_CUSTOM_ICON_LOCKED;
     case EasyUnlockScreenlockStateHandler::STATE_TX_POWER_TOO_HIGH:
     case EasyUnlockScreenlockStateHandler::
              STATE_PHONE_LOCKED_AND_TX_POWER_TOO_HIGH:
       // TODO(isherman): This icon is currently identical to the regular locked
       // icon.  Once the reduced proximity range flag is removed, consider
       // deleting the redundant icon.
-      return ScreenlockBridge::USER_POD_CUSTOM_ICON_LOCKED_WITH_PROXIMITY_HINT;
+      return proximity_auth::ScreenlockBridge::
+          USER_POD_CUSTOM_ICON_LOCKED_WITH_PROXIMITY_HINT;
     case EasyUnlockScreenlockStateHandler::STATE_BLUETOOTH_CONNECTING:
-      return ScreenlockBridge::USER_POD_CUSTOM_ICON_SPINNER;
+      return proximity_auth::ScreenlockBridge::USER_POD_CUSTOM_ICON_SPINNER;
     case EasyUnlockScreenlockStateHandler::STATE_AUTHENTICATED:
-      return ScreenlockBridge::USER_POD_CUSTOM_ICON_UNLOCKED;
+      return proximity_auth::ScreenlockBridge::USER_POD_CUSTOM_ICON_UNLOCKED;
     default:
-      return ScreenlockBridge::USER_POD_CUSTOM_ICON_NONE;
+      return proximity_auth::ScreenlockBridge::USER_POD_CUSTOM_ICON_NONE;
   }
 }
 
 bool HardlockOnClick(EasyUnlockScreenlockStateHandler::State state) {
   return state != EasyUnlockScreenlockStateHandler::STATE_INACTIVE;
 }
 
 size_t GetTooltipResourceId(EasyUnlockScreenlockStateHandler::State state) {
   switch (state) {
     case EasyUnlockScreenlockStateHandler::STATE_NO_BLUETOOTH:
@@ skipping 35 matching lines @@
 
 // Returns true iff the |state| corresponds to a locked remote device.
 bool IsLockedState(EasyUnlockScreenlockStateHandler::State state) {
   return (state == EasyUnlockScreenlockStateHandler::STATE_PHONE_LOCKED ||
           state == EasyUnlockScreenlockStateHandler::
                        STATE_PHONE_LOCKED_AND_TX_POWER_TOO_HIGH);
 }
 
 }  // namespace
 
-
 EasyUnlockScreenlockStateHandler::EasyUnlockScreenlockStateHandler(
     const std::string& user_email,
     HardlockState initial_hardlock_state,
-    ScreenlockBridge* screenlock_bridge)
+    proximity_auth::ScreenlockBridge* screenlock_bridge)
     : state_(STATE_INACTIVE),
       user_email_(user_email),
       screenlock_bridge_(screenlock_bridge),
       hardlock_state_(initial_hardlock_state),
       hardlock_ui_shown_(false),
       is_trial_run_(false),
       did_see_locked_phone_(false) {
   DCHECK(screenlock_bridge_);
   screenlock_bridge_->AddObserver(this);
 }
@@ skipping 22 matching lines @@
 
   state_ = new_state;
 
   // If lock screen is not active or it forces offline password, just cache the
   // current state. The screenlock state will get refreshed in |ScreenDidLock|.
   if (!screenlock_bridge_->IsLocked())
     return;
 
   // Do nothing when auth type is online.
   if (screenlock_bridge_->lock_handler()->GetAuthType(user_email_) ==
-      ScreenlockBridge::LockHandler::ONLINE_SIGN_IN) {
+      proximity_auth::ScreenlockBridge::LockHandler::ONLINE_SIGN_IN) {
     return;
   }
 
   if (IsLockedState(state_))
     did_see_locked_phone_ = true;
 
   // No hardlock UI for trial run.
   if (!is_trial_run_ && hardlock_state_ != NO_HARDLOCK) {
     ShowHardlockUI();
     return;
   }
 
   UpdateScreenlockAuthType();
 
-  ScreenlockBridge::UserPodCustomIcon icon = GetIconForState(state_);
+  proximity_auth::ScreenlockBridge::UserPodCustomIcon icon =
+      GetIconForState(state_);
 
-  if (icon == ScreenlockBridge::USER_POD_CUSTOM_ICON_NONE) {
+  if (icon == proximity_auth::ScreenlockBridge::USER_POD_CUSTOM_ICON_NONE) {
     screenlock_bridge_->lock_handler()->HideUserPodCustomIcon(user_email_);
     return;
   }
 
-  ScreenlockBridge::UserPodCustomIconOptions icon_options;
+  proximity_auth::ScreenlockBridge::UserPodCustomIconOptions icon_options;
   icon_options.SetIcon(icon);
 
   // Don't hardlock on trial run.
   if (is_trial_run_)
     icon_options.SetTrialRun();
   else if (HardlockOnClick(state_))
     icon_options.SetHardlockOnClick();
 
   UpdateTooltipOptions(&icon_options);
 
@@ skipping 39 matching lines @@
   RecordEasyUnlockTrialRunEvent(EASY_UNLOCK_TRIAL_RUN_EVENT_LAUNCHED);
 }
 
 void EasyUnlockScreenlockStateHandler::RecordClickOnLockIcon() {
   if (!is_trial_run_)
     return;
   RecordEasyUnlockTrialRunEvent(EASY_UNLOCK_TRIAL_RUN_EVENT_CLICKED_LOCK_ICON);
 }
 
 void EasyUnlockScreenlockStateHandler::OnScreenDidLock(
-    ScreenlockBridge::LockHandler::ScreenType screen_type) {
+    proximity_auth::ScreenlockBridge::LockHandler::ScreenType screen_type) {
   did_see_locked_phone_ = IsLockedState(state_);
   RefreshScreenlockState();
 }
 
 void EasyUnlockScreenlockStateHandler::OnScreenDidUnlock(
-    ScreenlockBridge::LockHandler::ScreenType screen_type) {
+    proximity_auth::ScreenlockBridge::LockHandler::ScreenType screen_type) {
   if (hardlock_state_ == LOGIN_FAILED)
     hardlock_state_ = NO_HARDLOCK;
   hardlock_ui_shown_ = false;
   is_trial_run_ = false;
 
   // Upon a successful unlock event, record whether the user's phone was locked
   // at any point while the lock screen was up.
   if (state_ == STATE_AUTHENTICATED)
     RecordEasyUnlockDidUserManuallyUnlockPhone(did_see_locked_phone_);
   did_see_locked_phone_ = false;
@@ skipping 10 matching lines @@
   ChangeState(last_state);
 }
 
 void EasyUnlockScreenlockStateHandler::ShowHardlockUI() {
   DCHECK(hardlock_state_ != NO_HARDLOCK);
 
   if (!screenlock_bridge_->IsLocked())
     return;
 
   // Do not override online signin.
-  const ScreenlockBridge::LockHandler::AuthType existing_auth_type =
-      screenlock_bridge_->lock_handler()->GetAuthType(user_email_);
-  if (existing_auth_type == ScreenlockBridge::LockHandler::ONLINE_SIGN_IN)
+  const proximity_auth::ScreenlockBridge::LockHandler::AuthType
+      existing_auth_type =
+          screenlock_bridge_->lock_handler()->GetAuthType(user_email_);
+  if (existing_auth_type ==
+      proximity_auth::ScreenlockBridge::LockHandler::ONLINE_SIGN_IN)
     return;
 
-  if (existing_auth_type != ScreenlockBridge::LockHandler::OFFLINE_PASSWORD) {
+  if (existing_auth_type !=
+      proximity_auth::ScreenlockBridge::LockHandler::OFFLINE_PASSWORD) {
     screenlock_bridge_->lock_handler()->SetAuthType(
         user_email_,
-        ScreenlockBridge::LockHandler::OFFLINE_PASSWORD,
+        proximity_auth::ScreenlockBridge::LockHandler::OFFLINE_PASSWORD,
         base::string16());
   }
 
   if (hardlock_state_ == NO_PAIRING) {
     screenlock_bridge_->lock_handler()->HideUserPodCustomIcon(user_email_);
     hardlock_ui_shown_ = false;
     return;
   }
 
   if (hardlock_ui_shown_)
     return;
 
-  ScreenlockBridge::UserPodCustomIconOptions icon_options;
+  proximity_auth::ScreenlockBridge::UserPodCustomIconOptions icon_options;
   if (hardlock_state_ == LOGIN_FAILED) {
-    icon_options.SetIcon(ScreenlockBridge::USER_POD_CUSTOM_ICON_LOCKED);
+    icon_options.SetIcon(
+        proximity_auth::ScreenlockBridge::USER_POD_CUSTOM_ICON_LOCKED);
   } else if (hardlock_state_ == PAIRING_CHANGED ||
              hardlock_state_ == PAIRING_ADDED) {
+    icon_options.SetIcon(proximity_auth::ScreenlockBridge::
+                             USER_POD_CUSTOM_ICON_LOCKED_TO_BE_ACTIVATED);
+  } else {
     icon_options.SetIcon(
-        ScreenlockBridge::USER_POD_CUSTOM_ICON_LOCKED_TO_BE_ACTIVATED);
-  } else {
-    icon_options.SetIcon(ScreenlockBridge::USER_POD_CUSTOM_ICON_HARDLOCKED);
+        proximity_auth::ScreenlockBridge::USER_POD_CUSTOM_ICON_HARDLOCKED);
   }
 
   base::string16 device_name = GetDeviceName();
   base::string16 tooltip;
   if (hardlock_state_ == USER_HARDLOCK) {
     tooltip = l10n_util::GetStringFUTF16(
         IDS_EASY_UNLOCK_SCREENLOCK_TOOLTIP_HARDLOCK_USER, device_name);
   } else if (hardlock_state_ == PAIRING_CHANGED) {
     tooltip = l10n_util::GetStringUTF16(
         IDS_EASY_UNLOCK_SCREENLOCK_TOOLTIP_HARDLOCK_PAIRING_CHANGED);
   } else if (hardlock_state_ == PAIRING_ADDED) {
     tooltip = l10n_util::GetStringFUTF16(
         IDS_EASY_UNLOCK_SCREENLOCK_TOOLTIP_HARDLOCK_PAIRING_ADDED, device_name,
         device_name);
   } else if (hardlock_state_ == LOGIN_FAILED) {
     tooltip = l10n_util::GetStringUTF16(
         IDS_EASY_UNLOCK_SCREENLOCK_TOOLTIP_LOGIN_FAILURE);
   } else {
     LOG(ERROR) << "Unknown hardlock state " << hardlock_state_;
   }
   icon_options.SetTooltip(tooltip, true /* autoshow */);
 
   screenlock_bridge_->lock_handler()->ShowUserPodCustomIcon(user_email_,
                                                             icon_options);
   hardlock_ui_shown_ = true;
 }
 
 void EasyUnlockScreenlockStateHandler::UpdateTooltipOptions(
-    ScreenlockBridge::UserPodCustomIconOptions* icon_options) {
+    proximity_auth::ScreenlockBridge::UserPodCustomIconOptions* icon_options) {
   size_t resource_id = 0;
   base::string16 device_name;
   if (is_trial_run_ && state_ == STATE_AUTHENTICATED) {
     resource_id = IDS_EASY_UNLOCK_SCREENLOCK_TOOLTIP_INITIAL_AUTHENTICATED;
   } else {
     resource_id = GetTooltipResourceId(state_);
     if (TooltipContainsDeviceType(state_))
       device_name = GetDeviceName();
   }
 
@@ skipping 22 matching lines @@
   // TODO(tbarzic): Figure out the name for non Chrome OS case.
   return base::ASCIIToUTF16("Chrome");
 #endif
 }
 
 void EasyUnlockScreenlockStateHandler::UpdateScreenlockAuthType() {
   if (!is_trial_run_ && hardlock_state_ != NO_HARDLOCK)
     return;
 
   // Do not override online signin.
-  const ScreenlockBridge::LockHandler::AuthType existing_auth_type =
-      screenlock_bridge_->lock_handler()->GetAuthType(user_email_);
-  DCHECK_NE(ScreenlockBridge::LockHandler::ONLINE_SIGN_IN, existing_auth_type);
+  const proximity_auth::ScreenlockBridge::LockHandler::AuthType
+      existing_auth_type =
+          screenlock_bridge_->lock_handler()->GetAuthType(user_email_);
+  DCHECK_NE(proximity_auth::ScreenlockBridge::LockHandler::ONLINE_SIGN_IN,
+            existing_auth_type);
 
   if (state_ == STATE_AUTHENTICATED) {
-    if (existing_auth_type != ScreenlockBridge::LockHandler::USER_CLICK) {
+    if (existing_auth_type !=
+        proximity_auth::ScreenlockBridge::LockHandler::USER_CLICK) {
       screenlock_bridge_->lock_handler()->SetAuthType(
           user_email_,
-          ScreenlockBridge::LockHandler::USER_CLICK,
+          proximity_auth::ScreenlockBridge::LockHandler::USER_CLICK,
           l10n_util::GetStringUTF16(
               IDS_EASY_UNLOCK_SCREENLOCK_USER_POD_AUTH_VALUE));
     }
   } else if (existing_auth_type !=
-             ScreenlockBridge::LockHandler::OFFLINE_PASSWORD) {
+             proximity_auth::ScreenlockBridge::LockHandler::OFFLINE_PASSWORD) {
     screenlock_bridge_->lock_handler()->SetAuthType(
         user_email_,
-        ScreenlockBridge::LockHandler::OFFLINE_PASSWORD,
+        proximity_auth::ScreenlockBridge::LockHandler::OFFLINE_PASSWORD,
         base::string16());
   }
 }