chrome/browser/signin/easy_unlock_screenlock_state_handler_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/signin/easy_unlock_screenlock_state_handler.h"
   6
   7 #include <string>
   8 #include <vector>
   9
  10 #include "base/strings/string16.h"
  11 #include "base/strings/string_number_conversions.h"
  12 #include "base/strings/string_util.h"
  13 #include "base/strings/utf_string_conversions.h"
  14 #include "base/test/histogram_tester.h"
  15 #include "chrome/browser/signin/easy_unlock_metrics.h"
  16 #include "chrome/browser/signin/easy_unlock_service.h"
  17 #include "chrome/grit/generated_resources.h"
  18 #include "components/proximity_auth/screenlock_bridge.h"
  19 #include "components/proximity_auth/screenlock_state.h"
  20 #include "testing/gtest/include/gtest/gtest.h"
  21 #include "ui/base/l10n/l10n_util.h"
  22
  23 using proximity_auth::ScreenlockState;
  24
  25 namespace {
  26
  27 // Icons used by EasyUnlockScreenlockStateHandler. The icon id values are the
  28 // same as the ones set by proximity_auth::ScreenlockBridge.
  29 const char kLockedIconId[] = "locked";
  30 const char kLockedToBeActivatedIconId[] = "locked-to-be-activated";
  31 const char kUnlockedIconId[] = "unlocked";
  32 const char kSpinnerIconId[] = "spinner";
  33 const char kHardlockedIconId[] = "hardlocked";
  34
  35 // Checks if |input| string has any unreplaced placeholders.
  36 bool StringHasPlaceholders(const base::string16& input) {
  37   std::vector<size_t> offsets;
  38   std::vector<base::string16> subst;
  39   subst.push_back(base::string16());
  40
  41   base::string16 replaced =
  42       base::ReplaceStringPlaceholders(input, subst, &offsets);
  43   return !offsets.empty();
  44 }
  45
  46 // Fake lock handler to be used in these tests.
  47 class TestLockHandler : public proximity_auth::ScreenlockBridge::LockHandler {
  48  public:
  49   explicit TestLockHandler(const std::string& user_email)
  50       : user_email_(user_email),
  51         show_icon_count_(0u),
  52         auth_type_(OFFLINE_PASSWORD) {
  53   }
  54   ~TestLockHandler() override {}
  55
  56   // proximity_auth::ScreenlockBridge::LockHandler implementation:
  57   void ShowBannerMessage(const base::string16& message) override {
  58     ASSERT_FALSE(true) << "Should not be reached.";
  59   }
  60
  61   void ShowUserPodCustomIcon(
  62       const std::string& user_email,
  63       const proximity_auth::ScreenlockBridge::UserPodCustomIconOptions& icon)
  64       override {
  65     ASSERT_EQ(user_email_, user_email);
  66     ++show_icon_count_;
  67     last_custom_icon_ = icon.ToDictionaryValue().Pass();
  68     ValidateCustomIcon();
  69   }
  70
  71   void HideUserPodCustomIcon(const std::string& user_email) override {
  72     ASSERT_EQ(user_email_, user_email);
  73     last_custom_icon_.reset();
  74   }
  75
  76   void EnableInput() override {
  77     ASSERT_FALSE(true) << "Should not be reached.";
  78   }
  79
  80   void SetAuthType(const std::string& user_email,
  81                    AuthType auth_type,
  82                    const base::string16& auth_value) override {
  83     ASSERT_EQ(user_email_, user_email);
  84     // Generally, this is allowed, but EasyUnlockScreenlockStateHandler should
  85     // avoid resetting the same auth type.
  86     EXPECT_NE(auth_type_, auth_type);
  87
  88     auth_type_ = auth_type;
  89     auth_value_ = auth_value;
  90   }
  91
  92   AuthType GetAuthType(const std::string& user_email) const override {
  93     EXPECT_EQ(user_email_, user_email);
  94     return auth_type_;
  95   }
  96
  97   ScreenType GetScreenType() const override {
  98     return LOCK_SCREEN;
  99   }
 100
 101   void Unlock(const std::string& user_email) override {
 102     ASSERT_FALSE(true) << "Should not be reached.";
 103   }
 104
 105   void AttemptEasySignin(const std::string& user_email,
 106                          const std::string& secret,
 107                          const std::string& key_label) override {
 108     ASSERT_FALSE(true) << "Should not be reached.";
 109   }
 110
 111   // Utility methods used by tests:
 112
 113   // Gets last set auth value.
 114   base::string16 GetAuthValue() const {
 115     return auth_value_;
 116   }
 117
 118   // Sets the auth value.
 119   void SetAuthValue(const base::string16& value) {
 120     auth_value_ = value;
 121   }
 122
 123   // Returns the number of times an icon was shown since the last call to this
 124   // method.
 125   size_t GetAndResetShowIconCount() {
 126     size_t result = show_icon_count_;
 127     show_icon_count_ = 0u;
 128     return result;
 129   }
 130
 131   // Whether the custom icon is set.
 132   bool HasCustomIcon() const {
 133     return last_custom_icon_;
 134   }
 135
 136   // If custom icon is set, returns the icon's id.
 137   // If there is no icon, or if it doesn't have an id set, returns an empty
 138   // string.
 139   std::string GetCustomIconId() const {
 140     std::string result;
 141     if (last_custom_icon_)
 142       last_custom_icon_->GetString("id", &result);
 143     return result;
 144   }
 145
 146   // Whether the custom icon is set and it has a tooltip.
 147   bool CustomIconHasTooltip() const {
 148     return last_custom_icon_ && last_custom_icon_->HasKey("tooltip");
 149   }
 150
 151   // Gets the custom icon's tooltip text, if one is set.
 152   base::string16 GetCustomIconTooltip() const {
 153     base::string16 result;
 154     if (last_custom_icon_)
 155       last_custom_icon_->GetString("tooltip.text", &result);
 156     return result;
 157   }
 158
 159   // Whether the custom icon's tooltip should be autoshown. If the icon is not
 160   // set, or it doesn't have a tooltip, returns false.
 161   bool IsCustomIconTooltipAutoshown() const {
 162     bool result = false;
 163     if (last_custom_icon_)
 164       last_custom_icon_->GetBoolean("tooltip.autoshow", &result);
 165     return result;
 166   }
 167
 168   // Whether the custom icon is set and if has hardlock capability enabed.
 169   bool CustomIconHardlocksOnClick() const {
 170     bool result = false;
 171     if (last_custom_icon_)
 172       last_custom_icon_->GetBoolean("hardlockOnClick", &result);
 173     return result;
 174   }
 175
 176  private:
 177   // Does some sanity checks on the last icon set by |ShowUserPodCustomIcon|.
 178   // It will cause a test failure if the icon is not valid.
 179   void ValidateCustomIcon() {
 180     ASSERT_TRUE(last_custom_icon_.get());
 181
 182     EXPECT_TRUE(last_custom_icon_->HasKey("id"));
 183
 184     if (last_custom_icon_->HasKey("tooltip")) {
 185       base::string16 tooltip;
 186       EXPECT_TRUE(last_custom_icon_->GetString("tooltip.text", &tooltip));
 187       EXPECT_FALSE(tooltip.empty());
 188       EXPECT_FALSE(StringHasPlaceholders(tooltip));
 189     }
 190   }
 191
 192   // The fake user email used in test. All methods called on |this| should be
 193   // associated with this user.
 194   const std::string user_email_;
 195
 196   // The last icon set using |SetUserPodCustomIcon|. Call to
 197   // |HideUserPodcustomIcon| resets it.
 198   scoped_ptr<base::DictionaryValue> last_custom_icon_;
 199   size_t show_icon_count_;
 200
 201   // Auth type and value set using |SetAuthType|.
 202   AuthType auth_type_;
 203   base::string16 auth_value_;
 204
 205   DISALLOW_COPY_AND_ASSIGN(TestLockHandler);
 206 };
 207
 208 class EasyUnlockScreenlockStateHandlerTest : public testing::Test {
 209  public:
 210   EasyUnlockScreenlockStateHandlerTest() : user_email_("test_user@gmail.com") {}
 211   ~EasyUnlockScreenlockStateHandlerTest() override {}
 212
 213   void SetUp() override {
 214     // Create and inject fake lock handler to the screenlock bridge.
 215     lock_handler_.reset(new TestLockHandler(user_email_));
 216     proximity_auth::ScreenlockBridge* screenlock_bridge =
 217         proximity_auth::ScreenlockBridge::Get();
 218     screenlock_bridge->SetLockHandler(lock_handler_.get());
 219
 220     // Create the screenlock state handler object that will be tested.
 221     state_handler_.reset(new EasyUnlockScreenlockStateHandler(
 222         user_email_,
 223         EasyUnlockScreenlockStateHandler::NO_HARDLOCK,
 224         screenlock_bridge));
 225   }
 226
 227   void TearDown() override {
 228     proximity_auth::ScreenlockBridge::Get()->SetLockHandler(NULL);
 229     lock_handler_.reset();
 230     state_handler_.reset();
 231   }
 232
 233  protected:
 234   // The state handler that is being tested.
 235   scoped_ptr<EasyUnlockScreenlockStateHandler> state_handler_;
 236
 237   // The user associated with |state_handler_|.
 238   const std::string user_email_;
 239
 240   // Faked lock handler given to proximity_auth::ScreenlockBridge during the
 241   // test. Abstracts the screen lock UI.
 242   scoped_ptr<TestLockHandler> lock_handler_;
 243 };
 244
 245 TEST_F(EasyUnlockScreenlockStateHandlerTest, AuthenticatedTrialRun) {
 246   state_handler_->SetTrialRun();
 247   state_handler_->ChangeState(ScreenlockState::AUTHENTICATED);
 248
 249   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
 250   EXPECT_EQ(proximity_auth::ScreenlockBridge::LockHandler::USER_CLICK,
 251             lock_handler_->GetAuthType(user_email_));
 252
 253   ASSERT_TRUE(lock_handler_->HasCustomIcon());
 254   EXPECT_EQ(kUnlockedIconId, lock_handler_->GetCustomIconId());
 255   EXPECT_TRUE(lock_handler_->CustomIconHasTooltip());
 256   EXPECT_TRUE(lock_handler_->IsCustomIconTooltipAutoshown());
 257   EXPECT_FALSE(lock_handler_->CustomIconHardlocksOnClick());
 258
 259   state_handler_->ChangeState(ScreenlockState::AUTHENTICATED);
 260   // Duplicated state change should be ignored.
 261   EXPECT_EQ(0u, lock_handler_->GetAndResetShowIconCount());
 262 }
 263
 264 TEST_F(EasyUnlockScreenlockStateHandlerTest, AuthenticatedNotInitialRun) {
 265   state_handler_->ChangeState(ScreenlockState::AUTHENTICATED);
 266
 267   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
 268   EXPECT_EQ(proximity_auth::ScreenlockBridge::LockHandler::USER_CLICK,
 269             lock_handler_->GetAuthType(user_email_));
 270
 271   ASSERT_TRUE(lock_handler_->HasCustomIcon());
 272   EXPECT_EQ(kUnlockedIconId, lock_handler_->GetCustomIconId());
 273   EXPECT_TRUE(lock_handler_->CustomIconHasTooltip());
 274   EXPECT_FALSE(lock_handler_->IsCustomIconTooltipAutoshown());
 275   EXPECT_TRUE(lock_handler_->CustomIconHardlocksOnClick());
 276 }
 277
 278 TEST_F(EasyUnlockScreenlockStateHandlerTest, IsActive) {
 279   EXPECT_FALSE(state_handler_->IsActive());
 280   state_handler_->ChangeState(ScreenlockState::AUTHENTICATED);
 281   EXPECT_TRUE(state_handler_->IsActive());
 282   state_handler_->ChangeState(ScreenlockState::INACTIVE);
 283   EXPECT_FALSE(state_handler_->IsActive());
 284 }
 285
 286 TEST_F(EasyUnlockScreenlockStateHandlerTest, BluetoothConnecting) {
 287   state_handler_->ChangeState(ScreenlockState::BLUETOOTH_CONNECTING);
 288   EXPECT_TRUE(state_handler_->IsActive());
 289
 290   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
 291   EXPECT_EQ(proximity_auth::ScreenlockBridge::LockHandler::OFFLINE_PASSWORD,
 292             lock_handler_->GetAuthType(user_email_));
 293
 294   ASSERT_TRUE(lock_handler_->HasCustomIcon());
 295   EXPECT_EQ(kSpinnerIconId, lock_handler_->GetCustomIconId());
 296   EXPECT_FALSE(lock_handler_->CustomIconHasTooltip());
 297   EXPECT_TRUE(lock_handler_->CustomIconHardlocksOnClick());
 298
 299   state_handler_->ChangeState(ScreenlockState::BLUETOOTH_CONNECTING);
 300   // Duplicated state change should be ignored.
 301   EXPECT_EQ(0u, lock_handler_->GetAndResetShowIconCount());
 302 }
 303
 304 TEST_F(EasyUnlockScreenlockStateHandlerTest, HardlockedState) {
 305   state_handler_->ChangeState(ScreenlockState::AUTHENTICATED);
 306
 307   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
 308   EXPECT_EQ(proximity_auth::ScreenlockBridge::LockHandler::USER_CLICK,
 309             lock_handler_->GetAuthType(user_email_));
 310
 311   state_handler_->SetHardlockState(
 312       EasyUnlockScreenlockStateHandler::USER_HARDLOCK);
 313
 314   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
 315   EXPECT_EQ(proximity_auth::ScreenlockBridge::LockHandler::OFFLINE_PASSWORD,
 316             lock_handler_->GetAuthType(user_email_));
 317
 318   ASSERT_TRUE(lock_handler_->HasCustomIcon());
 319   EXPECT_EQ(kHardlockedIconId, lock_handler_->GetCustomIconId());
 320   EXPECT_TRUE(lock_handler_->CustomIconHasTooltip());
 321   EXPECT_TRUE(lock_handler_->IsCustomIconTooltipAutoshown());
 322   EXPECT_FALSE(lock_handler_->CustomIconHardlocksOnClick());
 323
 324   state_handler_->SetHardlockState(
 325       EasyUnlockScreenlockStateHandler::USER_HARDLOCK);
 326
 327   EXPECT_EQ(0u, lock_handler_->GetAndResetShowIconCount());
 328   ASSERT_TRUE(lock_handler_->HasCustomIcon());
 329 }
 330
 331 TEST_F(EasyUnlockScreenlockStateHandlerTest, HardlockedStateNoPairing) {
 332   state_handler_->ChangeState(ScreenlockState::AUTHENTICATED);
 333
 334   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
 335   EXPECT_EQ(proximity_auth::ScreenlockBridge::LockHandler::USER_CLICK,
 336             lock_handler_->GetAuthType(user_email_));
 337
 338   state_handler_->SetHardlockState(
 339       EasyUnlockScreenlockStateHandler::NO_PAIRING);
 340
 341   EXPECT_FALSE(lock_handler_->HasCustomIcon());
 342   EXPECT_EQ(proximity_auth::ScreenlockBridge::LockHandler::OFFLINE_PASSWORD,
 343             lock_handler_->GetAuthType(user_email_));
 344 }
 345
 346 TEST_F(EasyUnlockScreenlockStateHandlerTest, StatesWithLockedIcon) {
 347   std::vector<ScreenlockState> states;
 348   states.push_back(ScreenlockState::NO_BLUETOOTH);
 349   states.push_back(ScreenlockState::NO_PHONE);
 350   states.push_back(ScreenlockState::PHONE_UNSUPPORTED);
 351   states.push_back(ScreenlockState::PHONE_NOT_LOCKABLE);
 352   states.push_back(ScreenlockState::PHONE_NOT_AUTHENTICATED);
 353   states.push_back(ScreenlockState::PHONE_LOCKED);
 354
 355   for (size_t i = 0; i < states.size(); ++i) {
 356     SCOPED_TRACE(base::IntToString(i));
 357     state_handler_->ChangeState(states[i]);
 358     EXPECT_TRUE(state_handler_->IsActive());
 359
 360     EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
 361     EXPECT_EQ(proximity_auth::ScreenlockBridge::LockHandler::OFFLINE_PASSWORD,
 362               lock_handler_->GetAuthType(user_email_));
 363
 364     ASSERT_TRUE(lock_handler_->HasCustomIcon());
 365     EXPECT_EQ(kLockedIconId, lock_handler_->GetCustomIconId());
 366     EXPECT_TRUE(lock_handler_->CustomIconHasTooltip());
 367     EXPECT_TRUE(lock_handler_->IsCustomIconTooltipAutoshown());
 368     EXPECT_TRUE(lock_handler_->CustomIconHardlocksOnClick());
 369
 370     state_handler_->ChangeState(states[i]);
 371     EXPECT_EQ(0u, lock_handler_->GetAndResetShowIconCount());
 372   }
 373 }
 374
 375 TEST_F(EasyUnlockScreenlockStateHandlerTest, SettingTrialRunUpdatesUI) {
 376   state_handler_->ChangeState(ScreenlockState::AUTHENTICATED);
 377
 378   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
 379   EXPECT_EQ(proximity_auth::ScreenlockBridge::LockHandler::USER_CLICK,
 380             lock_handler_->GetAuthType(user_email_));
 381
 382   ASSERT_TRUE(lock_handler_->HasCustomIcon());
 383   ASSERT_FALSE(lock_handler_->IsCustomIconTooltipAutoshown());
 384
 385   state_handler_->SetTrialRun();
 386
 387   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
 388   EXPECT_EQ(proximity_auth::ScreenlockBridge::LockHandler::USER_CLICK,
 389             lock_handler_->GetAuthType(user_email_));
 390
 391   ASSERT_TRUE(lock_handler_->HasCustomIcon());
 392   ASSERT_TRUE(lock_handler_->IsCustomIconTooltipAutoshown());
 393 }
 394
 395 TEST_F(EasyUnlockScreenlockStateHandlerTest,
 396        LockScreenClearedOnStateHandlerDestruction) {
 397   state_handler_->ChangeState(ScreenlockState::AUTHENTICATED);
 398
 399   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
 400   EXPECT_EQ(proximity_auth::ScreenlockBridge::LockHandler::USER_CLICK,
 401             lock_handler_->GetAuthType(user_email_));
 402
 403   ASSERT_TRUE(lock_handler_->HasCustomIcon());
 404
 405   state_handler_.reset();
 406
 407   EXPECT_EQ(0u, lock_handler_->GetAndResetShowIconCount());
 408   EXPECT_EQ(proximity_auth::ScreenlockBridge::LockHandler::OFFLINE_PASSWORD,
 409             lock_handler_->GetAuthType(user_email_));
 410
 411   ASSERT_FALSE(lock_handler_->HasCustomIcon());
 412 }
 413
 414 TEST_F(EasyUnlockScreenlockStateHandlerTest, StatePreservedWhenScreenUnlocks) {
 415   state_handler_->ChangeState(ScreenlockState::AUTHENTICATED);
 416
 417   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
 418   EXPECT_EQ(proximity_auth::ScreenlockBridge::LockHandler::USER_CLICK,
 419             lock_handler_->GetAuthType(user_email_));
 420   ASSERT_TRUE(lock_handler_->HasCustomIcon());
 421
 422   proximity_auth::ScreenlockBridge::Get()->SetLockHandler(NULL);
 423   lock_handler_.reset(new TestLockHandler(user_email_));
 424   EXPECT_EQ(0u, lock_handler_->GetAndResetShowIconCount());
 425   proximity_auth::ScreenlockBridge::Get()->SetLockHandler(lock_handler_.get());
 426
 427   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
 428   EXPECT_EQ(proximity_auth::ScreenlockBridge::LockHandler::USER_CLICK,
 429             lock_handler_->GetAuthType(user_email_));
 430   ASSERT_TRUE(lock_handler_->HasCustomIcon());
 431 }
 432
 433 TEST_F(EasyUnlockScreenlockStateHandlerTest, StateChangeWhileScreenUnlocked) {
 434   state_handler_->ChangeState(ScreenlockState::AUTHENTICATED);
 435
 436   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
 437   EXPECT_EQ(proximity_auth::ScreenlockBridge::LockHandler::USER_CLICK,
 438             lock_handler_->GetAuthType(user_email_));
 439   ASSERT_TRUE(lock_handler_->HasCustomIcon());
 440
 441   proximity_auth::ScreenlockBridge::Get()->SetLockHandler(NULL);
 442   lock_handler_.reset(new TestLockHandler(user_email_));
 443   EXPECT_EQ(0u, lock_handler_->GetAndResetShowIconCount());
 444
 445   state_handler_->ChangeState(ScreenlockState::BLUETOOTH_CONNECTING);
 446
 447   proximity_auth::ScreenlockBridge::Get()->SetLockHandler(lock_handler_.get());
 448
 449   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
 450   EXPECT_EQ(proximity_auth::ScreenlockBridge::LockHandler::OFFLINE_PASSWORD,
 451             lock_handler_->GetAuthType(user_email_));
 452   ASSERT_TRUE(lock_handler_->HasCustomIcon());
 453   EXPECT_EQ(kSpinnerIconId, lock_handler_->GetCustomIconId());
 454 }
 455
 456 TEST_F(EasyUnlockScreenlockStateHandlerTest,
 457        HardlockEnabledAfterInitialUnlock) {
 458   state_handler_->SetTrialRun();
 459
 460   std::vector<ScreenlockState> states;
 461   states.push_back(ScreenlockState::BLUETOOTH_CONNECTING);
 462   states.push_back(ScreenlockState::PHONE_NOT_AUTHENTICATED);
 463   states.push_back(ScreenlockState::NO_BLUETOOTH);
 464   states.push_back(ScreenlockState::NO_PHONE);
 465   states.push_back(ScreenlockState::PHONE_UNSUPPORTED);
 466   states.push_back(ScreenlockState::PHONE_NOT_LOCKABLE);
 467   // This one should go last as changing state to AUTHENTICATED enables hard
 468   // locking.
 469   states.push_back(ScreenlockState::AUTHENTICATED);
 470
 471   for (size_t i = 0; i < states.size(); ++i) {
 472     SCOPED_TRACE(base::IntToString(i));
 473     state_handler_->ChangeState(states[i]);
 474     ASSERT_TRUE(lock_handler_->HasCustomIcon());
 475     EXPECT_FALSE(lock_handler_->CustomIconHardlocksOnClick());
 476   }
 477
 478   proximity_auth::ScreenlockBridge::Get()->SetLockHandler(NULL);
 479   lock_handler_.reset(new TestLockHandler(user_email_));
 480   proximity_auth::ScreenlockBridge::Get()->SetLockHandler(lock_handler_.get());
 481
 482   for (size_t i = 0; i < states.size(); ++i) {
 483     SCOPED_TRACE(base::IntToString(i));
 484     state_handler_->ChangeState(states[i]);
 485     ASSERT_TRUE(lock_handler_->HasCustomIcon());
 486     EXPECT_TRUE(lock_handler_->CustomIconHardlocksOnClick());
 487   }
 488 }
 489
 490 TEST_F(EasyUnlockScreenlockStateHandlerTest,
 491        NoPairingHardlockClearsIcon) {
 492   state_handler_->ChangeState(ScreenlockState::PHONE_LOCKED);
 493
 494   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
 495   ASSERT_TRUE(lock_handler_->HasCustomIcon());
 496   EXPECT_EQ(kLockedIconId, lock_handler_->GetCustomIconId());
 497
 498   state_handler_->SetHardlockState(
 499       EasyUnlockScreenlockStateHandler::NO_PAIRING);
 500
 501   EXPECT_EQ(0u, lock_handler_->GetAndResetShowIconCount());
 502   ASSERT_FALSE(lock_handler_->HasCustomIcon());
 503 }
 504
 505 TEST_F(EasyUnlockScreenlockStateHandlerTest, PairingChangedHardlock) {
 506   state_handler_->ChangeState(ScreenlockState::PHONE_LOCKED);
 507
 508   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
 509   ASSERT_TRUE(lock_handler_->HasCustomIcon());
 510   EXPECT_EQ(kLockedIconId, lock_handler_->GetCustomIconId());
 511
 512   state_handler_->SetHardlockState(
 513       EasyUnlockScreenlockStateHandler::PAIRING_CHANGED);
 514
 515   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
 516   ASSERT_TRUE(lock_handler_->HasCustomIcon());
 517   EXPECT_EQ(kLockedToBeActivatedIconId, lock_handler_->GetCustomIconId());
 518
 519   state_handler_->ChangeState(ScreenlockState::AUTHENTICATED);
 520
 521   EXPECT_EQ(0u, lock_handler_->GetAndResetShowIconCount());
 522   ASSERT_TRUE(lock_handler_->HasCustomIcon());
 523   EXPECT_EQ(kLockedToBeActivatedIconId, lock_handler_->GetCustomIconId());
 524 }
 525
 526 TEST_F(EasyUnlockScreenlockStateHandlerTest,
 527        PairingChangedHardlockIneffectiveOnInitialRun) {
 528   state_handler_->SetTrialRun();
 529
 530   state_handler_->ChangeState(ScreenlockState::PHONE_LOCKED);
 531
 532   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
 533   ASSERT_TRUE(lock_handler_->HasCustomIcon());
 534   EXPECT_EQ(kLockedIconId, lock_handler_->GetCustomIconId());
 535
 536   state_handler_->SetHardlockState(
 537       EasyUnlockScreenlockStateHandler::PAIRING_CHANGED);
 538
 539   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
 540   ASSERT_TRUE(lock_handler_->HasCustomIcon());
 541   EXPECT_EQ(kLockedIconId, lock_handler_->GetCustomIconId());
 542 }
 543
 544 TEST_F(EasyUnlockScreenlockStateHandlerTest, InactiveStateHidesIcon) {
 545   state_handler_->ChangeState(ScreenlockState::AUTHENTICATED);
 546
 547   ASSERT_TRUE(lock_handler_->HasCustomIcon());
 548
 549   state_handler_->ChangeState(ScreenlockState::INACTIVE);
 550
 551   ASSERT_FALSE(lock_handler_->HasCustomIcon());
 552 }
 553
 554 TEST_F(EasyUnlockScreenlockStateHandlerTest,
 555        AuthenticatedStateClearsPreviousAuthValue) {
 556   state_handler_->ChangeState(ScreenlockState::INACTIVE);
 557
 558   lock_handler_->SetAuthValue(base::ASCIIToUTF16("xxx"));
 559
 560   state_handler_->ChangeState(ScreenlockState::AUTHENTICATED);
 561
 562   EXPECT_EQ(l10n_util::GetStringUTF16(
 563                 IDS_EASY_UNLOCK_SCREENLOCK_USER_POD_AUTH_VALUE),
 564             lock_handler_->GetAuthValue());
 565
 566   state_handler_->ChangeState(ScreenlockState::NO_PHONE);
 567
 568   EXPECT_EQ(base::string16(), lock_handler_->GetAuthValue());
 569 }
 570
 571 TEST_F(EasyUnlockScreenlockStateHandlerTest,
 572        ChangingStateDoesNotAffectAuthValueIfAuthTypeDoesNotChange) {
 573   lock_handler_->SetAuthValue(base::ASCIIToUTF16("xxx"));
 574
 575   state_handler_->ChangeState(ScreenlockState::NO_PHONE);
 576   EXPECT_EQ(base::ASCIIToUTF16("xxx"), lock_handler_->GetAuthValue());
 577
 578   state_handler_->ChangeState(ScreenlockState::PHONE_NOT_AUTHENTICATED);
 579   EXPECT_EQ(base::ASCIIToUTF16("xxx"), lock_handler_->GetAuthValue());
 580
 581   state_handler_->ChangeState(ScreenlockState::BLUETOOTH_CONNECTING);
 582   EXPECT_EQ(base::ASCIIToUTF16("xxx"), lock_handler_->GetAuthValue());
 583   ASSERT_TRUE(lock_handler_->HasCustomIcon());
 584   EXPECT_EQ(kSpinnerIconId, lock_handler_->GetCustomIconId());
 585 }
 586
 587 TEST_F(EasyUnlockScreenlockStateHandlerTest, StateChangesIgnoredIfHardlocked) {
 588   state_handler_->ChangeState(ScreenlockState::AUTHENTICATED);
 589
 590   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
 591   EXPECT_EQ(proximity_auth::ScreenlockBridge::LockHandler::USER_CLICK,
 592             lock_handler_->GetAuthType(user_email_));
 593
 594   state_handler_->SetHardlockState(
 595       EasyUnlockScreenlockStateHandler::USER_HARDLOCK);
 596
 597   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
 598   EXPECT_EQ(proximity_auth::ScreenlockBridge::LockHandler::OFFLINE_PASSWORD,
 599             lock_handler_->GetAuthType(user_email_));
 600   ASSERT_TRUE(lock_handler_->HasCustomIcon());
 601   EXPECT_EQ(kHardlockedIconId, lock_handler_->GetCustomIconId());
 602
 603   state_handler_->ChangeState(ScreenlockState::NO_PHONE);
 604   ASSERT_TRUE(lock_handler_->HasCustomIcon());
 605   EXPECT_EQ(0u, lock_handler_->GetAndResetShowIconCount());
 606
 607   state_handler_->ChangeState(ScreenlockState::AUTHENTICATED);
 608   ASSERT_TRUE(lock_handler_->HasCustomIcon());
 609   EXPECT_EQ(0u, lock_handler_->GetAndResetShowIconCount());
 610   EXPECT_EQ(proximity_auth::ScreenlockBridge::LockHandler::OFFLINE_PASSWORD,
 611             lock_handler_->GetAuthType(user_email_));
 612 }
 613
 614 TEST_F(EasyUnlockScreenlockStateHandlerTest,
 615        LockScreenChangeableOnLockAfterHardlockReset) {
 616   state_handler_->ChangeState(ScreenlockState::AUTHENTICATED);
 617
 618   state_handler_->SetHardlockState(
 619       EasyUnlockScreenlockStateHandler::USER_HARDLOCK);
 620   EXPECT_EQ(2u, lock_handler_->GetAndResetShowIconCount());
 621
 622   state_handler_->SetHardlockState(
 623       EasyUnlockScreenlockStateHandler::NO_HARDLOCK);
 624
 625   proximity_auth::ScreenlockBridge::Get()->SetLockHandler(NULL);
 626   lock_handler_.reset(new TestLockHandler(user_email_));
 627   EXPECT_EQ(0u, lock_handler_->GetAndResetShowIconCount());
 628   proximity_auth::ScreenlockBridge::Get()->SetLockHandler(lock_handler_.get());
 629
 630   state_handler_->ChangeState(ScreenlockState::NO_PHONE);
 631
 632   EXPECT_EQ(2u, lock_handler_->GetAndResetShowIconCount());
 633   EXPECT_TRUE(lock_handler_->HasCustomIcon());
 634
 635   proximity_auth::ScreenlockBridge::Get()->SetLockHandler(NULL);
 636   lock_handler_.reset(new TestLockHandler(user_email_));
 637   EXPECT_EQ(0u, lock_handler_->GetAndResetShowIconCount());
 638   proximity_auth::ScreenlockBridge::Get()->SetLockHandler(lock_handler_.get());
 639
 640   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
 641   EXPECT_TRUE(lock_handler_->HasCustomIcon());
 642   EXPECT_EQ(proximity_auth::ScreenlockBridge::LockHandler::OFFLINE_PASSWORD,
 643             lock_handler_->GetAuthType(user_email_));
 644   EXPECT_EQ(kLockedIconId, lock_handler_->GetCustomIconId());
 645
 646   state_handler_->ChangeState(ScreenlockState::AUTHENTICATED);
 647   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
 648   EXPECT_TRUE(lock_handler_->HasCustomIcon());
 649   EXPECT_EQ(proximity_auth::ScreenlockBridge::LockHandler::USER_CLICK,
 650             lock_handler_->GetAuthType(user_email_));
 651   EXPECT_TRUE(lock_handler_->CustomIconHardlocksOnClick());
 652 }
 653
 654 TEST_F(EasyUnlockScreenlockStateHandlerTest, HardlockStatePersistsOverUnlocks) {
 655   state_handler_->ChangeState(ScreenlockState::AUTHENTICATED);
 656   state_handler_->SetHardlockState(
 657       EasyUnlockScreenlockStateHandler::USER_HARDLOCK);
 658   EXPECT_EQ(2u, lock_handler_->GetAndResetShowIconCount());
 659
 660   proximity_auth::ScreenlockBridge::Get()->SetLockHandler(NULL);
 661   lock_handler_.reset(new TestLockHandler(user_email_));
 662   EXPECT_EQ(0u, lock_handler_->GetAndResetShowIconCount());
 663   proximity_auth::ScreenlockBridge::Get()->SetLockHandler(lock_handler_.get());
 664
 665   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
 666   EXPECT_EQ(proximity_auth::ScreenlockBridge::LockHandler::OFFLINE_PASSWORD,
 667             lock_handler_->GetAuthType(user_email_));
 668   ASSERT_TRUE(lock_handler_->HasCustomIcon());
 669   EXPECT_EQ(kHardlockedIconId, lock_handler_->GetCustomIconId());
 670
 671   state_handler_->ChangeState(ScreenlockState::AUTHENTICATED);
 672   EXPECT_EQ(0u, lock_handler_->GetAndResetShowIconCount());
 673   EXPECT_TRUE(lock_handler_->HasCustomIcon());
 674   EXPECT_EQ(proximity_auth::ScreenlockBridge::LockHandler::OFFLINE_PASSWORD,
 675             lock_handler_->GetAuthType(user_email_));
 676 }
 677
 678 TEST_F(EasyUnlockScreenlockStateHandlerTest, NoOverrideOnlineSignin) {
 679   lock_handler_->SetAuthType(
 680       user_email_,
 681       proximity_auth::ScreenlockBridge::LockHandler::ONLINE_SIGN_IN,
 682       base::string16());
 683
 684   std::vector<ScreenlockState> states;
 685   states.push_back(ScreenlockState::NO_BLUETOOTH);
 686   states.push_back(ScreenlockState::NO_PHONE);
 687   states.push_back(ScreenlockState::PHONE_UNSUPPORTED);
 688   states.push_back(ScreenlockState::PHONE_NOT_LOCKABLE);
 689   states.push_back(ScreenlockState::PHONE_NOT_AUTHENTICATED);
 690   states.push_back(ScreenlockState::PHONE_LOCKED);
 691   states.push_back(ScreenlockState::PHONE_NOT_LOCKABLE);
 692   states.push_back(ScreenlockState::PHONE_UNSUPPORTED);
 693   states.push_back(ScreenlockState::RSSI_TOO_LOW);
 694   states.push_back(ScreenlockState::TX_POWER_TOO_HIGH);
 695   states.push_back(ScreenlockState::AUTHENTICATED);
 696
 697   for (size_t i = 0; i < states.size(); ++i) {
 698     state_handler_->ChangeState(states[i]);
 699     EXPECT_EQ(proximity_auth::ScreenlockBridge::LockHandler::ONLINE_SIGN_IN,
 700               lock_handler_->GetAuthType(user_email_));
 701     EXPECT_FALSE(lock_handler_->HasCustomIcon());
 702   }
 703
 704   std::vector<EasyUnlockScreenlockStateHandler::HardlockState> hardlock_states;
 705   hardlock_states.push_back(EasyUnlockScreenlockStateHandler::NO_HARDLOCK);
 706   hardlock_states.push_back(EasyUnlockScreenlockStateHandler::USER_HARDLOCK);
 707   hardlock_states.push_back(EasyUnlockScreenlockStateHandler::PAIRING_CHANGED);
 708   hardlock_states.push_back(EasyUnlockScreenlockStateHandler::PAIRING_ADDED);
 709   hardlock_states.push_back(EasyUnlockScreenlockStateHandler::NO_PAIRING);
 710   hardlock_states.push_back(EasyUnlockScreenlockStateHandler::LOGIN_FAILED);
 711
 712   for (size_t i = 0; i < hardlock_states.size(); ++i) {
 713     state_handler_->SetHardlockState(hardlock_states[i]);
 714     EXPECT_EQ(proximity_auth::ScreenlockBridge::LockHandler::ONLINE_SIGN_IN,
 715               lock_handler_->GetAuthType(user_email_));
 716     EXPECT_FALSE(lock_handler_->HasCustomIcon());
 717   }
 718 }
 719
 720 TEST_F(EasyUnlockScreenlockStateHandlerTest, TrialRunMetrics) {
 721   base::HistogramTester histogram_tester;
 722
 723   // Simulate the user clicking on the lock icon twice outside of a trial run.
 724   // No trial run metrics should be recorded.
 725   state_handler_->RecordClickOnLockIcon();
 726   state_handler_->RecordClickOnLockIcon();
 727   histogram_tester.ExpectTotalCount("EasyUnlock.TrialRun.Events", 0);
 728
 729   // Simulate the user clicking on the lock icon three times during a trial run.
 730   state_handler_->SetTrialRun();
 731   state_handler_->RecordClickOnLockIcon();
 732   state_handler_->RecordClickOnLockIcon();
 733   state_handler_->RecordClickOnLockIcon();
 734   histogram_tester.ExpectTotalCount("EasyUnlock.TrialRun.Events", 4);
 735   histogram_tester.ExpectBucketCount("EasyUnlock.TrialRun.Events",
 736                                      EASY_UNLOCK_TRIAL_RUN_EVENT_LAUNCHED, 1);
 737   histogram_tester.ExpectBucketCount(
 738       "EasyUnlock.TrialRun.Events",
 739       EASY_UNLOCK_TRIAL_RUN_EVENT_CLICKED_LOCK_ICON, 3);
 740 }
 741
 742 }  // namespace