Rename ScreelockBridge to SigninScreenBridge

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/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/browser/signin/signin_screen_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 "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace {
 
 // Resource URLs for icons used by EasyUnlockScreenlockStateHandler.
 const char kLockedIconURL[] = "chrome://theme/IDR_EASY_UNLOCK_LOCKED";
 const char kUnlockedIconURL[] = "chrome://theme/IDR_EASY_UNLOCK_UNLOCKED";
 const char kSpinnerIconURL[] = "chrome://theme/IDR_EASY_UNLOCK_SPINNER";
 
 // The expected size of user pod custom icons set by
 // EasyUnlockScreenlockStateHandler.
 const int kExpectedIconSize = 27;
 
 // Checks if |input| string has any unreplaced placeholders.
 bool StringHasPlaceholders(const base::string16& input) {
   std::vector<size_t> offsets;
   std::vector<base::string16> subst;
   subst.push_back(base::string16());
 
   base::string16 replaced = ReplaceStringPlaceholders(input, subst, &offsets);
   return !offsets.empty();
 }
 
 // Fake lock handler to be used in these tests.
-class TestLockHandler : public ScreenlockBridge::LockHandler {
+class TestLockHandler : public SigninScreenBridge::LockHandler {
  public:
   explicit TestLockHandler(const std::string& user_email)
       : user_email_(user_email),
         show_icon_count_(0u),
         auth_type_(OFFLINE_PASSWORD) {
   }
   virtual ~TestLockHandler() {}
 
-  // ScreenlockBridge::LockHandler implementation:
+  // SigninScreenBridge::LockHandler implementation:
   virtual void ShowBannerMessage(const base::string16& message) OVERRIDE {
     ASSERT_FALSE(true) << "Should not be reached.";
   }
 
   virtual void ShowUserPodCustomIcon(
       const std::string& user_email,
-      const ScreenlockBridge::UserPodCustomIconOptions& icon) OVERRIDE {
+      const SigninScreenBridge::UserPodCustomIconOptions& icon) OVERRIDE {
     ASSERT_EQ(user_email_, user_email);
     ++show_icon_count_;
     last_custom_icon_ = icon.ToDictionaryValue().Pass();
     ValidateCustomIcon();
   }
 
   virtual void HideUserPodCustomIcon(const std::string& user_email) OVERRIDE {
     ASSERT_EQ(user_email_, user_email);
     last_custom_icon_.reset();
   }
@@ skipping 165 matching lines @@
 
   virtual void SetUp() OVERRIDE {
     pref_service_.reset(new TestingPrefServiceSyncable());
 
     // 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());
 
     // 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());
+    SigninScreenBridge* signin_screen_bridge = SigninScreenBridge::Get();
+    signin_screen_bridge->SetLockHandler(lock_handler_.get());
 
     // Create the screenlock state handler object that will be tested.
     state_handler_.reset(
         new EasyUnlockScreenlockStateHandler(user_email_,
                                              pref_service_.get(),
-                                             screenlock_bridge));
+                                             signin_screen_bridge));
   }
 
   virtual void TearDown() OVERRIDE {
-    ScreenlockBridge::Get()->SetLockHandler(NULL);
+    SigninScreenBridge::Get()->SetLockHandler(NULL);
     lock_handler_.reset();
     state_handler_.reset();
   }
 
  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
+  // Faked lock handler given to SigninScreenBridge during the test. Abstracts
   // the screen lock UI.
   scoped_ptr<TestLockHandler> lock_handler_;
 
   // The user's preferences.
   scoped_ptr<TestingPrefServiceSyncable> pref_service_;
 };
 
 TEST_F(EasyUnlockScreenlockStateHandlerTest, AuthenticatedInitialRun) {
   state_handler_->ChangeState(
       EasyUnlockScreenlockStateHandler::STATE_AUTHENTICATED);
 
   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
-  EXPECT_EQ(ScreenlockBridge::LockHandler::USER_CLICK,
+  EXPECT_EQ(SigninScreenBridge::LockHandler::USER_CLICK,
             lock_handler_->GetAuthType(user_email_));
 
   ASSERT_TRUE(lock_handler_->HasCustomIcon());
   EXPECT_EQ(kUnlockedIconURL, lock_handler_->GetCustomIconURL());
   EXPECT_TRUE(lock_handler_->CustomIconHasTooltip());
   EXPECT_TRUE(lock_handler_->IsCustomIconTooltipAutoshown());
   EXPECT_FALSE(lock_handler_->CustomIconHardlocksOnClick());
   EXPECT_FALSE(lock_handler_->IsCustomIconAnimated());
   EXPECT_EQ(100, lock_handler_->GetCustomIconOpacity());
 
   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);
 
   state_handler_->ChangeState(
       EasyUnlockScreenlockStateHandler::STATE_AUTHENTICATED);
 
   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
-  EXPECT_EQ(ScreenlockBridge::LockHandler::USER_CLICK,
+  EXPECT_EQ(SigninScreenBridge::LockHandler::USER_CLICK,
             lock_handler_->GetAuthType(user_email_));
 
   ASSERT_TRUE(lock_handler_->HasCustomIcon());
   EXPECT_EQ(kUnlockedIconURL, lock_handler_->GetCustomIconURL());
   EXPECT_TRUE(lock_handler_->CustomIconHasTooltip());
   EXPECT_FALSE(lock_handler_->IsCustomIconTooltipAutoshown());
   EXPECT_TRUE(lock_handler_->CustomIconHardlocksOnClick());
   EXPECT_FALSE(lock_handler_->IsCustomIconAnimated());
   EXPECT_EQ(100, lock_handler_->GetCustomIconOpacity());
 }
 
 TEST_F(EasyUnlockScreenlockStateHandlerTest, BluetoothConnecting) {
   pref_service_->SetBoolean(prefs::kEasyUnlockShowTutorial, false);
   state_handler_->ChangeState(
       EasyUnlockScreenlockStateHandler::STATE_BLUETOOTH_CONNECTING);
 
   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
-  EXPECT_EQ(ScreenlockBridge::LockHandler::OFFLINE_PASSWORD,
+  EXPECT_EQ(SigninScreenBridge::LockHandler::OFFLINE_PASSWORD,
             lock_handler_->GetAuthType(user_email_));
 
   ASSERT_TRUE(lock_handler_->HasCustomIcon());
   EXPECT_EQ(kSpinnerIconURL, lock_handler_->GetCustomIconURL());
   EXPECT_FALSE(lock_handler_->CustomIconHasTooltip());
   EXPECT_TRUE(lock_handler_->CustomIconHardlocksOnClick());
   EXPECT_TRUE(lock_handler_->IsCustomIconAnimated());
   EXPECT_EQ(100, lock_handler_->GetCustomIconOpacity());
 
   state_handler_->ChangeState(
@@ skipping 12 matching lines @@
   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]);
 
     EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount())
         << "State: " << states[i];
-    EXPECT_EQ(ScreenlockBridge::LockHandler::OFFLINE_PASSWORD,
+    EXPECT_EQ(SigninScreenBridge::LockHandler::OFFLINE_PASSWORD,
               lock_handler_->GetAuthType(user_email_))
         << "State: " << states[i];
 
     ASSERT_TRUE(lock_handler_->HasCustomIcon())
         << "State: " << states[i];
     EXPECT_EQ(kLockedIconURL, lock_handler_->GetCustomIconURL())
         << "State: " << states[i];
     EXPECT_TRUE(lock_handler_->CustomIconHasTooltip())
         << "State: " << states[i];
     EXPECT_FALSE(lock_handler_->IsCustomIconTooltipAutoshown())
@@ skipping 10 matching lines @@
         << "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,
+  EXPECT_EQ(SigninScreenBridge::LockHandler::USER_CLICK,
             lock_handler_->GetAuthType(user_email_));
 
   ASSERT_TRUE(lock_handler_->HasCustomIcon());
 
   state_handler_.reset();
 
   EXPECT_EQ(0u, lock_handler_->GetAndResetShowIconCount());
-  EXPECT_EQ(ScreenlockBridge::LockHandler::OFFLINE_PASSWORD,
+  EXPECT_EQ(SigninScreenBridge::LockHandler::OFFLINE_PASSWORD,
             lock_handler_->GetAuthType(user_email_));
 
   ASSERT_FALSE(lock_handler_->HasCustomIcon());
 }
 
 TEST_F(EasyUnlockScreenlockStateHandlerTest, StatePreservedWhenScreenUnlocks) {
   state_handler_->ChangeState(
       EasyUnlockScreenlockStateHandler::STATE_AUTHENTICATED);
 
   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
-  EXPECT_EQ(ScreenlockBridge::LockHandler::USER_CLICK,
+  EXPECT_EQ(SigninScreenBridge::LockHandler::USER_CLICK,
             lock_handler_->GetAuthType(user_email_));
   ASSERT_TRUE(lock_handler_->HasCustomIcon());
 
-  ScreenlockBridge::Get()->SetLockHandler(NULL);
+  SigninScreenBridge::Get()->SetLockHandler(NULL);
   lock_handler_.reset(new TestLockHandler(user_email_));
   EXPECT_EQ(0u, lock_handler_->GetAndResetShowIconCount());
-  ScreenlockBridge::Get()->SetLockHandler(lock_handler_.get());
+  SigninScreenBridge::Get()->SetLockHandler(lock_handler_.get());
 
   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
-  EXPECT_EQ(ScreenlockBridge::LockHandler::USER_CLICK,
+  EXPECT_EQ(SigninScreenBridge::LockHandler::USER_CLICK,
             lock_handler_->GetAuthType(user_email_));
   ASSERT_TRUE(lock_handler_->HasCustomIcon());
 }
 
 TEST_F(EasyUnlockScreenlockStateHandlerTest, StateChangeWhileScreenUnlocked) {
   state_handler_->ChangeState(
       EasyUnlockScreenlockStateHandler::STATE_AUTHENTICATED);
 
   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
-  EXPECT_EQ(ScreenlockBridge::LockHandler::USER_CLICK,
+  EXPECT_EQ(SigninScreenBridge::LockHandler::USER_CLICK,
             lock_handler_->GetAuthType(user_email_));
   ASSERT_TRUE(lock_handler_->HasCustomIcon());
 
-  ScreenlockBridge::Get()->SetLockHandler(NULL);
+  SigninScreenBridge::Get()->SetLockHandler(NULL);
   lock_handler_.reset(new TestLockHandler(user_email_));
   EXPECT_EQ(0u, lock_handler_->GetAndResetShowIconCount());
 
   state_handler_->ChangeState(
       EasyUnlockScreenlockStateHandler::STATE_BLUETOOTH_CONNECTING);
 
-  ScreenlockBridge::Get()->SetLockHandler(lock_handler_.get());
+  SigninScreenBridge::Get()->SetLockHandler(lock_handler_.get());
 
   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
-  EXPECT_EQ(ScreenlockBridge::LockHandler::OFFLINE_PASSWORD,
+  EXPECT_EQ(SigninScreenBridge::LockHandler::OFFLINE_PASSWORD,
             lock_handler_->GetAuthType(user_email_));
   ASSERT_TRUE(lock_handler_->HasCustomIcon());
   EXPECT_TRUE(lock_handler_->IsCustomIconAnimated());
 }
 
 TEST_F(EasyUnlockScreenlockStateHandlerTest,
        HardlockEnabledAfterInitialUnlock) {
   std::vector<EasyUnlockScreenlockStateHandler::State> states;
   states.push_back(
       EasyUnlockScreenlockStateHandler::STATE_BLUETOOTH_CONNECTING);
   states.push_back(
       EasyUnlockScreenlockStateHandler::STATE_PHONE_NOT_AUTHENTICATED);
   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);
   // This one should go last as changing state to AUTHENTICATED enables hard
   // locking.
   states.push_back(EasyUnlockScreenlockStateHandler::STATE_AUTHENTICATED);
 
   for (size_t i = 0; i < states.size(); ++i) {
     state_handler_->ChangeState(states[i]);
     ASSERT_TRUE(lock_handler_->HasCustomIcon()) << "State: " << states[i];
     EXPECT_FALSE(lock_handler_->CustomIconHardlocksOnClick())
         << "State: " << states[i];
   }
 
-  ScreenlockBridge::Get()->SetLockHandler(NULL);
+  SigninScreenBridge::Get()->SetLockHandler(NULL);
   lock_handler_.reset(new TestLockHandler(user_email_));
-  ScreenlockBridge::Get()->SetLockHandler(lock_handler_.get());
+  SigninScreenBridge::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, InactiveStateHidesIcon) {
@@ skipping 45 matching lines @@
   EXPECT_EQ(base::ASCIIToUTF16("xxx"), lock_handler_->GetAuthValue());
   EXPECT_TRUE(lock_handler_->IsCustomIconAnimated());
 }
 
 TEST_F(EasyUnlockScreenlockStateHandlerTest, StateChangesIgnoredIfHardlocked) {
   state_handler_->ChangeState(
       EasyUnlockScreenlockStateHandler::STATE_AUTHENTICATED);
 
   lock_handler_->SetAuthType(
       user_email_,
-      ScreenlockBridge::LockHandler::FORCE_OFFLINE_PASSWORD,
+      SigninScreenBridge::LockHandler::FORCE_OFFLINE_PASSWORD,
       base::string16());
   lock_handler_->HideUserPodCustomIcon(user_email_);
 
   state_handler_->ChangeState(
       EasyUnlockScreenlockStateHandler::STATE_NO_PHONE);
   EXPECT_FALSE(lock_handler_->HasCustomIcon());
 
   state_handler_->ChangeState(
       EasyUnlockScreenlockStateHandler::STATE_AUTHENTICATED);
   EXPECT_FALSE(lock_handler_->HasCustomIcon());
-  EXPECT_EQ(ScreenlockBridge::LockHandler::FORCE_OFFLINE_PASSWORD,
+  EXPECT_EQ(SigninScreenBridge::LockHandler::FORCE_OFFLINE_PASSWORD,
             lock_handler_->GetAuthType(user_email_));
 }
 
 TEST_F(EasyUnlockScreenlockStateHandlerTest,
        LockScreenChangeableAfterHardlockUnlocked) {
   state_handler_->ChangeState(
       EasyUnlockScreenlockStateHandler::STATE_AUTHENTICATED);
 
   lock_handler_->SetAuthType(
       user_email_,
-      ScreenlockBridge::LockHandler::FORCE_OFFLINE_PASSWORD,
+      SigninScreenBridge::LockHandler::FORCE_OFFLINE_PASSWORD,
       base::string16());
   lock_handler_->HideUserPodCustomIcon(user_email_);
 
   state_handler_->ChangeState(
       EasyUnlockScreenlockStateHandler::STATE_NO_PHONE);
   EXPECT_FALSE(lock_handler_->HasCustomIcon());
 
-  ScreenlockBridge::Get()->SetLockHandler(NULL);
+  SigninScreenBridge::Get()->SetLockHandler(NULL);
   lock_handler_.reset(new TestLockHandler(user_email_));
   EXPECT_EQ(0u, lock_handler_->GetAndResetShowIconCount());
-  ScreenlockBridge::Get()->SetLockHandler(lock_handler_.get());
+  SigninScreenBridge::Get()->SetLockHandler(lock_handler_.get());
 
   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
   EXPECT_TRUE(lock_handler_->HasCustomIcon());
-  EXPECT_EQ(ScreenlockBridge::LockHandler::OFFLINE_PASSWORD,
+  EXPECT_EQ(SigninScreenBridge::LockHandler::OFFLINE_PASSWORD,
             lock_handler_->GetAuthType(user_email_));
 
   state_handler_->ChangeState(
       EasyUnlockScreenlockStateHandler::STATE_AUTHENTICATED);
   EXPECT_EQ(1u, lock_handler_->GetAndResetShowIconCount());
   EXPECT_TRUE(lock_handler_->HasCustomIcon());
-  EXPECT_EQ(ScreenlockBridge::LockHandler::USER_CLICK,
+  EXPECT_EQ(SigninScreenBridge::LockHandler::USER_CLICK,
             lock_handler_->GetAuthType(user_email_));
   EXPECT_TRUE(lock_handler_->CustomIconHardlocksOnClick());
 }
 
 }  // namespace