[Easy Unlock] Update handling of the trial easy unlock/signin run

chrome/browser/signin/easy_unlock_screenlock_state_handler_unittest.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 <string>
 #include <vector>
 
+#include "base/prefs/scoped_user_pref_update.h"
+#include "base/prefs/testing_pref_service.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/signin/easy_unlock_screenlock_state_handler.h"
 #include "chrome/browser/signin/easy_unlock_service.h"
 #include "chrome/browser/signin/screenlock_bridge.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/grit/generated_resources.h"
-#include "chrome/test/base/testing_pref_service_syncable.h"
-#include "components/pref_registry/pref_registry_syncable.h"
+#include "chrome/test/base/testing_browser_process.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace {
 
 // Icons used by EasyUnlockScreenlockStateHandler. The icon id values are the
 // same as the ones set by ScreenlockBridge.
 const char kLockedIconId[] = "locked";
 const char kUnlockedIconId[] = "unlocked";
 const char kSpinnerIconId[] = "spinner";
@@ skipping 165 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(TestLockHandler);
 };
 
 class EasyUnlockScreenlockStateHandlerTest : public testing::Test {
  public:
   EasyUnlockScreenlockStateHandlerTest() : user_email_("test_user@gmail.com") {}
   virtual ~EasyUnlockScreenlockStateHandlerTest() {}
 
   virtual void SetUp() override {
-    pref_service_.reset(new TestingPrefServiceSyncable());
+    pref_service_.reset(new TestingPrefServiceSimple());
+
+    TestingBrowserProcess::GetGlobal()->SetApplicationLocale("en-US");
 
     // The preference used to determine if easy unlock was previously used by
     // the user on the device ought to be registered by the EasyUnlockService.
-    EasyUnlockService::RegisterProfilePrefs(pref_service_->registry());
+    EasyUnlockService::RegisterPrefs(pref_service_->registry());
 
     // Create and inject fake lock handler to the screenlock bridge.
     lock_handler_.reset(new TestLockHandler(user_email_));
     ScreenlockBridge* screenlock_bridge = ScreenlockBridge::Get();
     screenlock_bridge->SetLockHandler(lock_handler_.get());
 
     // Create the screenlock state handler object that will be tested.
     state_handler_.reset(new EasyUnlockScreenlockStateHandler(
         user_email_,
         EasyUnlockScreenlockStateHandler::NO_HARDLOCK,
         pref_service_.get(),
         screenlock_bridge));
   }
 
   virtual void TearDown() override {
     ScreenlockBridge::Get()->SetLockHandler(NULL);
     lock_handler_.reset();
     state_handler_.reset();
   }
 
+  void SetFirstRunCompleteValue(bool value) {
+    DictionaryPrefUpdate update(pref_service_.get(),
+                                prefs::kEasyUnlockFirstRunComplete);
+    update->SetBooleanWithoutPathExpansion(user_email_, value);
+  }
+
  protected:
   // The state handler that is being tested.
   scoped_ptr<EasyUnlockScreenlockStateHandler> state_handler_;
 
   // The user associated with |state_handler_|.
   const std::string user_email_;
 
   // Faked lock handler given to ScreenlockBridge during the test. Abstracts
   // the screen lock UI.
   scoped_ptr<TestLockHandler> lock_handler_;
 
   // The user's preferences.
-  scoped_ptr<TestingPrefServiceSyncable> pref_service_;
+  scoped_ptr<TestingPrefServiceSimple> pref_service_;
 };
 
 TEST_F(EasyUnlockScreenlockStateHandlerTest, AuthenticatedInitialRun) {
   state_handler_->ChangeState(
       EasyUnlockScreenlockStateHandler::STATE_AUTHENTICATED);
 
   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
   EXPECT_EQ(ScreenlockBridge::LockHandler::USER_CLICK,
             lock_handler_->GetAuthType(user_email_));
 
   ASSERT_TRUE(lock_handler_->HasCustomIcon());
   EXPECT_EQ(kUnlockedIconId, lock_handler_->GetCustomIconId());
   EXPECT_TRUE(lock_handler_->CustomIconHasTooltip());
   EXPECT_TRUE(lock_handler_->IsCustomIconTooltipAutoshown());
   EXPECT_FALSE(lock_handler_->CustomIconHardlocksOnClick());
 
   state_handler_->ChangeState(
       EasyUnlockScreenlockStateHandler::STATE_AUTHENTICATED);
   // Duplicated state change should be ignored.
   EXPECT_EQ(0u, lock_handler_->GetAndResetShowIconCount());
 }
 
 TEST_F(EasyUnlockScreenlockStateHandlerTest, AuthenticatedNotInitialRun) {
-  // Update preference for showing tutorial.
-  pref_service_->SetBoolean(prefs::kEasyUnlockShowTutorial, false);
+  SetFirstRunCompleteValue(true);
 
   state_handler_->ChangeState(
       EasyUnlockScreenlockStateHandler::STATE_AUTHENTICATED);
 
   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
   EXPECT_EQ(ScreenlockBridge::LockHandler::USER_CLICK,
             lock_handler_->GetAuthType(user_email_));
 
   ASSERT_TRUE(lock_handler_->HasCustomIcon());
   EXPECT_EQ(kUnlockedIconId, lock_handler_->GetCustomIconId());
   EXPECT_TRUE(lock_handler_->CustomIconHasTooltip());
   EXPECT_FALSE(lock_handler_->IsCustomIconTooltipAutoshown());
   EXPECT_TRUE(lock_handler_->CustomIconHardlocksOnClick());
 }
 
 TEST_F(EasyUnlockScreenlockStateHandlerTest, BluetoothConnecting) {
-  pref_service_->SetBoolean(prefs::kEasyUnlockShowTutorial, false);
+  SetFirstRunCompleteValue(true);
+
   state_handler_->ChangeState(
       EasyUnlockScreenlockStateHandler::STATE_BLUETOOTH_CONNECTING);
 
   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
   EXPECT_EQ(ScreenlockBridge::LockHandler::OFFLINE_PASSWORD,
             lock_handler_->GetAuthType(user_email_));
 
   ASSERT_TRUE(lock_handler_->HasCustomIcon());
   EXPECT_EQ(kSpinnerIconId, lock_handler_->GetCustomIconId());
   EXPECT_FALSE(lock_handler_->CustomIconHasTooltip());
   EXPECT_TRUE(lock_handler_->CustomIconHardlocksOnClick());
 
   state_handler_->ChangeState(
       EasyUnlockScreenlockStateHandler::STATE_BLUETOOTH_CONNECTING);
   // Duplicated state change should be ignored.
   EXPECT_EQ(0u, lock_handler_->GetAndResetShowIconCount());
 }
 
 TEST_F(EasyUnlockScreenlockStateHandlerTest, HardlockedState) {
-  pref_service_->SetBoolean(prefs::kEasyUnlockShowTutorial, false);
+  SetFirstRunCompleteValue(true);
+
   state_handler_->ChangeState(
       EasyUnlockScreenlockStateHandler::STATE_AUTHENTICATED);
 
   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
   EXPECT_EQ(ScreenlockBridge::LockHandler::USER_CLICK,
             lock_handler_->GetAuthType(user_email_));
 
   state_handler_->SetHardlockState(
       EasyUnlockScreenlockStateHandler::USER_HARDLOCK);
 
   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
   EXPECT_EQ(ScreenlockBridge::LockHandler::OFFLINE_PASSWORD,
             lock_handler_->GetAuthType(user_email_));
 
   ASSERT_TRUE(lock_handler_->HasCustomIcon());
   EXPECT_EQ(kHardlockedIconId, lock_handler_->GetCustomIconId());
   EXPECT_TRUE(lock_handler_->CustomIconHasTooltip());
   EXPECT_FALSE(lock_handler_->CustomIconHardlocksOnClick());
 
   state_handler_->SetHardlockState(
       EasyUnlockScreenlockStateHandler::USER_HARDLOCK);
 
   EXPECT_EQ(0u, lock_handler_->GetAndResetShowIconCount());
   ASSERT_TRUE(lock_handler_->HasCustomIcon());
 }
 
 TEST_F(EasyUnlockScreenlockStateHandlerTest, HardlockedStateNoPairing) {
-  pref_service_->SetBoolean(prefs::kEasyUnlockShowTutorial, false);
+  SetFirstRunCompleteValue(true);
+
   state_handler_->ChangeState(
       EasyUnlockScreenlockStateHandler::STATE_AUTHENTICATED);
 
   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
   EXPECT_EQ(ScreenlockBridge::LockHandler::USER_CLICK,
             lock_handler_->GetAuthType(user_email_));
 
   state_handler_->SetHardlockState(
       EasyUnlockScreenlockStateHandler::NO_PAIRING);
 
   EXPECT_FALSE(lock_handler_->HasCustomIcon());
   EXPECT_EQ(ScreenlockBridge::LockHandler::OFFLINE_PASSWORD,
             lock_handler_->GetAuthType(user_email_));
 }
 
 TEST_F(EasyUnlockScreenlockStateHandlerTest, StatesWithLockedIcon) {
-  pref_service_->SetBoolean(prefs::kEasyUnlockShowTutorial, false);
+  SetFirstRunCompleteValue(true);
 
   std::vector<EasyUnlockScreenlockStateHandler::State> states;
   states.push_back(EasyUnlockScreenlockStateHandler::STATE_NO_BLUETOOTH);
   states.push_back(EasyUnlockScreenlockStateHandler::STATE_NO_PHONE);
   states.push_back(EasyUnlockScreenlockStateHandler::STATE_PHONE_UNSUPPORTED);
   states.push_back(EasyUnlockScreenlockStateHandler::STATE_PHONE_UNLOCKABLE);
   states.push_back(
       EasyUnlockScreenlockStateHandler::STATE_PHONE_NOT_AUTHENTICATED);
   states.push_back(EasyUnlockScreenlockStateHandler::STATE_PHONE_LOCKED);
 
@@ skipping 16 matching lines @@
         << "State: " << states[i];
     EXPECT_TRUE(lock_handler_->CustomIconHardlocksOnClick())
         << "State: " << states[i];
 
     state_handler_->ChangeState(states[i]);
     EXPECT_EQ(0u, lock_handler_->GetAndResetShowIconCount())
         << "State: " << states[i];
   }
 }
 
+// Verifies tooltips are autoshown on initial run.
+TEST_F(EasyUnlockScreenlockStateHandlerTest, StatesWithLockedIcon_InitialRun) {
+  std::vector<EasyUnlockScreenlockStateHandler::State> states;
+  states.push_back(EasyUnlockScreenlockStateHandler::STATE_NO_BLUETOOTH);
+  states.push_back(EasyUnlockScreenlockStateHandler::STATE_NO_PHONE);
+  states.push_back(EasyUnlockScreenlockStateHandler::STATE_PHONE_UNSUPPORTED);
+  states.push_back(EasyUnlockScreenlockStateHandler::STATE_PHONE_UNLOCKABLE);
+  states.push_back(
+      EasyUnlockScreenlockStateHandler::STATE_PHONE_NOT_AUTHENTICATED);
+  states.push_back(EasyUnlockScreenlockStateHandler::STATE_PHONE_LOCKED);
+
+  for (size_t i = 0; i < states.size(); ++i) {
+    state_handler_->ChangeState(states[i]);
+    ASSERT_TRUE(lock_handler_->HasCustomIcon())
+        << "State: " << states[i];
+    EXPECT_TRUE(lock_handler_->CustomIconHasTooltip())
+        << "State: " << states[i];
+    EXPECT_TRUE(lock_handler_->IsCustomIconTooltipAutoshown())
+        << "State: " << states[i];
+  }
+
+  ScreenlockBridge::Get()->SetLockHandler(NULL);
+  lock_handler_.reset(new TestLockHandler(user_email_));
+  EXPECT_EQ(0u, lock_handler_->GetAndResetShowIconCount());
+  ScreenlockBridge::Get()->SetLockHandler(lock_handler_.get());
+
+  // After the screen unlocks the tooltips should not be shown anymore.
+  for (size_t i = 0; i < states.size(); ++i) {
+    state_handler_->ChangeState(states[i]);
+    ASSERT_TRUE(lock_handler_->HasCustomIcon())
+        << "State: " << states[i];
+    EXPECT_TRUE(lock_handler_->CustomIconHasTooltip())
+        << "State: " << states[i];
+    EXPECT_FALSE(lock_handler_->IsCustomIconTooltipAutoshown())
+        << "State: " << states[i];
+  }
+}
+
 TEST_F(EasyUnlockScreenlockStateHandlerTest,
        LockScreenClearedOnStateHandlerDestruction) {
   state_handler_->ChangeState(
       EasyUnlockScreenlockStateHandler::STATE_AUTHENTICATED);
 
   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
   EXPECT_EQ(ScreenlockBridge::LockHandler::USER_CLICK,
             lock_handler_->GetAuthType(user_email_));
 
   ASSERT_TRUE(lock_handler_->HasCustomIcon());
@@ skipping 79 matching lines @@
   ScreenlockBridge::Get()->SetLockHandler(lock_handler_.get());
 
   for (size_t i = 0; i < states.size(); ++i) {
     state_handler_->ChangeState(states[i]);
     ASSERT_TRUE(lock_handler_->HasCustomIcon()) << "State: " << states[i];
     EXPECT_TRUE(lock_handler_->CustomIconHardlocksOnClick())
         << "State: " << states[i];
   }
 }
 
+TEST_F(EasyUnlockScreenlockStateHandlerTest,
+       NoPairingHardlockClearsIcon) {
+  SetFirstRunCompleteValue(true);
+
+  state_handler_->ChangeState(
+      EasyUnlockScreenlockStateHandler::STATE_PHONE_LOCKED);
+
+  EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
+  ASSERT_TRUE(lock_handler_->HasCustomIcon());
+  EXPECT_EQ(kLockedIconId, lock_handler_->GetCustomIconId());
+
+  state_handler_->SetHardlockState(
+      EasyUnlockScreenlockStateHandler::NO_PAIRING);
+
+  EXPECT_EQ(0u, lock_handler_->GetAndResetShowIconCount());
+  ASSERT_FALSE(lock_handler_->HasCustomIcon());
+}
+
+TEST_F(EasyUnlockScreenlockStateHandlerTest,
+       NoPairingHardlockIgnoredOnInitialRun) {
+  state_handler_->ChangeState(
+      EasyUnlockScreenlockStateHandler::STATE_PHONE_LOCKED);
+
+  EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
+  ASSERT_TRUE(lock_handler_->HasCustomIcon());
+  EXPECT_EQ(kLockedIconId, lock_handler_->GetCustomIconId());
+
+  state_handler_->SetHardlockState(
+      EasyUnlockScreenlockStateHandler::NO_PAIRING);
+
+  EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
+  ASSERT_TRUE(lock_handler_->HasCustomIcon());
+  EXPECT_EQ(kLockedIconId, lock_handler_->GetCustomIconId());
+}
+
+TEST_F(EasyUnlockScreenlockStateHandlerTest, PairingChangedHardlock) {
+  SetFirstRunCompleteValue(true);
+  state_handler_->ChangeState(
+      EasyUnlockScreenlockStateHandler::STATE_PHONE_LOCKED);
+
+  EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
+  ASSERT_TRUE(lock_handler_->HasCustomIcon());
+  EXPECT_EQ(kLockedIconId, lock_handler_->GetCustomIconId());
+
+  state_handler_->SetHardlockState(
+      EasyUnlockScreenlockStateHandler::PAIRING_CHANGED);
+
+  EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
+  ASSERT_TRUE(lock_handler_->HasCustomIcon());
+  EXPECT_EQ(kHardlockedIconId, lock_handler_->GetCustomIconId());
+
+  state_handler_->ChangeState(
+      EasyUnlockScreenlockStateHandler::STATE_AUTHENTICATED);
+
+  EXPECT_EQ(0u, lock_handler_->GetAndResetShowIconCount());
+  ASSERT_TRUE(lock_handler_->HasCustomIcon());
+  EXPECT_EQ(kHardlockedIconId, lock_handler_->GetCustomIconId());
+}
+
+TEST_F(EasyUnlockScreenlockStateHandlerTest,
+       PairingChangedHardlockEffectiveOnInitialRun) {
+  state_handler_->ChangeState(
+      EasyUnlockScreenlockStateHandler::STATE_PHONE_LOCKED);
+
+  EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
+  ASSERT_TRUE(lock_handler_->HasCustomIcon());
+  EXPECT_EQ(kLockedIconId, lock_handler_->GetCustomIconId());
+
+  state_handler_->SetHardlockState(
+      EasyUnlockScreenlockStateHandler::PAIRING_CHANGED);
+
+  EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
+  ASSERT_TRUE(lock_handler_->HasCustomIcon());
+  EXPECT_EQ(kHardlockedIconId, lock_handler_->GetCustomIconId());
+}
+
 TEST_F(EasyUnlockScreenlockStateHandlerTest, InactiveStateHidesIcon) {
   state_handler_->ChangeState(
       EasyUnlockScreenlockStateHandler::STATE_AUTHENTICATED);
 
   ASSERT_TRUE(lock_handler_->HasCustomIcon());
 
   state_handler_->ChangeState(
       EasyUnlockScreenlockStateHandler::STATE_INACTIVE);
 
   ASSERT_FALSE(lock_handler_->HasCustomIcon());
@@ skipping 32 matching lines @@
   EXPECT_EQ(base::ASCIIToUTF16("xxx"), lock_handler_->GetAuthValue());
 
   state_handler_->ChangeState(
       EasyUnlockScreenlockStateHandler::STATE_BLUETOOTH_CONNECTING);
   EXPECT_EQ(base::ASCIIToUTF16("xxx"), lock_handler_->GetAuthValue());
   ASSERT_TRUE(lock_handler_->HasCustomIcon());
   EXPECT_EQ(kSpinnerIconId, lock_handler_->GetCustomIconId());
 }
 
 TEST_F(EasyUnlockScreenlockStateHandlerTest, StateChangesIgnoredIfHardlocked) {
-  pref_service_->SetBoolean(prefs::kEasyUnlockShowTutorial, false);
+  SetFirstRunCompleteValue(true);
   state_handler_->ChangeState(
       EasyUnlockScreenlockStateHandler::STATE_AUTHENTICATED);
 
   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
   EXPECT_EQ(ScreenlockBridge::LockHandler::USER_CLICK,
             lock_handler_->GetAuthType(user_email_));
 
   state_handler_->SetHardlockState(
       EasyUnlockScreenlockStateHandler::USER_HARDLOCK);
 
@@ skipping 11 matching lines @@
   state_handler_->ChangeState(
       EasyUnlockScreenlockStateHandler::STATE_AUTHENTICATED);
   ASSERT_TRUE(lock_handler_->HasCustomIcon());
   EXPECT_EQ(0u, lock_handler_->GetAndResetShowIconCount());
   EXPECT_EQ(ScreenlockBridge::LockHandler::OFFLINE_PASSWORD,
             lock_handler_->GetAuthType(user_email_));
 }
 
 TEST_F(EasyUnlockScreenlockStateHandlerTest,
        LockScreenChangeableOnLockAfterHardlockReset) {
-  pref_service_->SetBoolean(prefs::kEasyUnlockShowTutorial, false);
+  SetFirstRunCompleteValue(true);
   state_handler_->ChangeState(
       EasyUnlockScreenlockStateHandler::STATE_AUTHENTICATED);
 
   state_handler_->SetHardlockState(
       EasyUnlockScreenlockStateHandler::USER_HARDLOCK);
   EXPECT_EQ(2u, lock_handler_->GetAndResetShowIconCount());
 
   state_handler_->SetHardlockState(
       EasyUnlockScreenlockStateHandler::NO_HARDLOCK);
 
@@ skipping 22 matching lines @@
   state_handler_->ChangeState(
       EasyUnlockScreenlockStateHandler::STATE_AUTHENTICATED);
   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
   EXPECT_TRUE(lock_handler_->HasCustomIcon());
   EXPECT_EQ(ScreenlockBridge::LockHandler::USER_CLICK,
             lock_handler_->GetAuthType(user_email_));
   EXPECT_TRUE(lock_handler_->CustomIconHardlocksOnClick());
 }
 
 TEST_F(EasyUnlockScreenlockStateHandlerTest, HardlockStatePersistsOverUnlocks) {
-  pref_service_->SetBoolean(prefs::kEasyUnlockShowTutorial, false);
+  SetFirstRunCompleteValue(true);
   state_handler_->ChangeState(
       EasyUnlockScreenlockStateHandler::STATE_AUTHENTICATED);
   state_handler_->SetHardlockState(
       EasyUnlockScreenlockStateHandler::USER_HARDLOCK);
   EXPECT_EQ(2u, lock_handler_->GetAndResetShowIconCount());
 
   ScreenlockBridge::Get()->SetLockHandler(NULL);
   lock_handler_.reset(new TestLockHandler(user_email_));
   EXPECT_EQ(0u, lock_handler_->GetAndResetShowIconCount());
   ScreenlockBridge::Get()->SetLockHandler(lock_handler_.get());
 
   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
   EXPECT_EQ(ScreenlockBridge::LockHandler::OFFLINE_PASSWORD,
             lock_handler_->GetAuthType(user_email_));
   ASSERT_TRUE(lock_handler_->HasCustomIcon());
   EXPECT_EQ(kHardlockedIconId, lock_handler_->GetCustomIconId());
 
   state_handler_->ChangeState(
       EasyUnlockScreenlockStateHandler::STATE_AUTHENTICATED);
   EXPECT_EQ(0u, lock_handler_->GetAndResetShowIconCount());
   EXPECT_TRUE(lock_handler_->HasCustomIcon());
   EXPECT_EQ(ScreenlockBridge::LockHandler::OFFLINE_PASSWORD,
             lock_handler_->GetAuthType(user_email_));
 }
 
 }  // namespace