Move screenlock_bridge to components/proximity_auth

chrome/browser/signin/easy_unlock_auth_attempt_unittest.cc

 // Copyright 2015 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_auth_attempt.h"
 
 #include "base/macros.h"
+#include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/easy_unlock_app_manager.h"
-#include "chrome/browser/signin/screenlock_bridge.h"
+#include "chrome/browser/signin/easy_unlock_util.h"
+#include "chrome/browser/signin/signin_manager_factory.h"
+#include "components/proximity_auth/screenlock_bridge.h"
+#include "components/signin/core/browser/signin_manager_base.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/login/easy_unlock/easy_unlock_key_manager.h"
 #endif
 
 namespace {
 
 // Fake user ids used in tests.
 const char kTestUser1[] = "user1";
@@ skipping 188 matching lines @@
   ~EasyUnlockAuthAttemptUnlockTest() override {}
 
   void SetUp() override {
     app_manager_.reset(new FakeAppManager());
     auth_attempt_.reset(new EasyUnlockAuthAttempt(
         app_manager_.get(), kTestUser1, EasyUnlockAuthAttempt::TYPE_UNLOCK,
         EasyUnlockAuthAttempt::FinalizedCallback()));
   }
 
   void TearDown() override {
-    ScreenlockBridge::Get()->SetLockHandler(NULL);
+    GetScreenlockBridgeInstance()->SetLockHandler(NULL);
     auth_attempt_.reset();
   }
 
  protected:
   void InitScreenLock() {
     lock_handler_.reset(new TestLockHandler(kTestUser1));
     lock_handler_->set_state(TestLockHandler::STATE_ATTEMPTING_UNLOCK);
-    ScreenlockBridge::Get()->SetLockHandler(lock_handler_.get());
+    GetScreenlockBridgeInstance()->SetLockHandler(lock_handler_.get());
   }
 
   scoped_ptr<EasyUnlockAuthAttempt> auth_attempt_;
   scoped_ptr<FakeAppManager> app_manager_;
   scoped_ptr<TestLockHandler> lock_handler_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(EasyUnlockAuthAttemptUnlockTest);
 };
 
 TEST_F(EasyUnlockAuthAttemptUnlockTest, StartWhenNotLocked) {
-  ASSERT_FALSE(ScreenlockBridge::Get()->IsLocked());
+  ASSERT_FALSE(GetScreenlockBridgeInstance()->IsLocked());
 
   EXPECT_FALSE(auth_attempt_->Start());
   EXPECT_EQ(0u, app_manager_->auth_attempt_count());
 }
 
 TEST_F(EasyUnlockAuthAttemptUnlockTest, StartWhenAuthTypeIsPassword) {
   InitScreenLock();
-  ASSERT_TRUE(ScreenlockBridge::Get()->IsLocked());
+  ASSERT_TRUE(GetScreenlockBridgeInstance()->IsLocked());
   ASSERT_EQ(TestLockHandler::STATE_ATTEMPTING_UNLOCK, lock_handler_->state());
 
   lock_handler_->set_auth_type(ScreenlockBridge::LockHandler::OFFLINE_PASSWORD);
 
   EXPECT_FALSE(auth_attempt_->Start());
 
   EXPECT_EQ(0u, app_manager_->auth_attempt_count());
   EXPECT_EQ(TestLockHandler::STATE_UNLOCK_CANCELED, lock_handler_->state());
 }
 
 TEST_F(EasyUnlockAuthAttemptUnlockTest,
        StartWhenDispatchingAuthAttemptEventFails) {
   InitScreenLock();
-  ASSERT_TRUE(ScreenlockBridge::Get()->IsLocked());
+  ASSERT_TRUE(GetScreenlockBridgeInstance()->IsLocked());
   ASSERT_EQ(TestLockHandler::STATE_ATTEMPTING_UNLOCK, lock_handler_->state());
 
   app_manager_->set_auth_attempt_should_fail(true);
 
   EXPECT_FALSE(auth_attempt_->Start());
 
   EXPECT_EQ(1u, app_manager_->auth_attempt_count());
   EXPECT_EQ(TestLockHandler::STATE_UNLOCK_CANCELED, lock_handler_->state());
 }
 
 TEST_F(EasyUnlockAuthAttemptUnlockTest, ResetBeforeFinalizeUnlock) {
   InitScreenLock();
-  ASSERT_TRUE(ScreenlockBridge::Get()->IsLocked());
+  ASSERT_TRUE(GetScreenlockBridgeInstance()->IsLocked());
   ASSERT_EQ(TestLockHandler::STATE_ATTEMPTING_UNLOCK, lock_handler_->state());
 
   ASSERT_TRUE(auth_attempt_->Start());
 
   ASSERT_EQ(1u, app_manager_->auth_attempt_count());
   EXPECT_EQ(TestLockHandler::STATE_ATTEMPTING_UNLOCK, lock_handler_->state());
 
   auth_attempt_.reset();
 
   EXPECT_EQ(TestLockHandler::STATE_UNLOCK_CANCELED, lock_handler_->state());
 }
 
 TEST_F(EasyUnlockAuthAttemptUnlockTest, FinalizeUnlockFailure) {
   InitScreenLock();
-  ASSERT_TRUE(ScreenlockBridge::Get()->IsLocked());
+  ASSERT_TRUE(GetScreenlockBridgeInstance()->IsLocked());
   ASSERT_EQ(TestLockHandler::STATE_ATTEMPTING_UNLOCK, lock_handler_->state());
 
   ASSERT_TRUE(auth_attempt_->Start());
 
   ASSERT_EQ(1u, app_manager_->auth_attempt_count());
   EXPECT_EQ(TestLockHandler::STATE_ATTEMPTING_UNLOCK, lock_handler_->state());
 
   auth_attempt_->FinalizeUnlock(kTestUser1, false);
 
   EXPECT_EQ(TestLockHandler::STATE_UNLOCK_CANCELED, lock_handler_->state());
 }
 
 TEST_F(EasyUnlockAuthAttemptUnlockTest, FinalizeSigninCalled) {
   InitScreenLock();
-  ASSERT_TRUE(ScreenlockBridge::Get()->IsLocked());
+  ASSERT_TRUE(GetScreenlockBridgeInstance()->IsLocked());
   ASSERT_EQ(TestLockHandler::STATE_ATTEMPTING_UNLOCK, lock_handler_->state());
 
   ASSERT_TRUE(auth_attempt_->Start());
 
   ASSERT_EQ(1u, app_manager_->auth_attempt_count());
   EXPECT_EQ(TestLockHandler::STATE_ATTEMPTING_UNLOCK, lock_handler_->state());
 
   // Wrapped secret and key should be irrelevant in this case.
   auth_attempt_->FinalizeSignin(kTestUser1, GetWrappedSecret(),
                                 GetSessionKey());
 
   EXPECT_EQ(TestLockHandler::STATE_UNLOCK_CANCELED, lock_handler_->state());
 }
 
 TEST_F(EasyUnlockAuthAttemptUnlockTest, UnlockSucceeds) {
   InitScreenLock();
-  ASSERT_TRUE(ScreenlockBridge::Get()->IsLocked());
+  ASSERT_TRUE(GetScreenlockBridgeInstance()->IsLocked());
   ASSERT_EQ(TestLockHandler::STATE_ATTEMPTING_UNLOCK, lock_handler_->state());
 
   ASSERT_TRUE(auth_attempt_->Start());
 
   ASSERT_EQ(1u, app_manager_->auth_attempt_count());
   EXPECT_EQ(TestLockHandler::STATE_ATTEMPTING_UNLOCK, lock_handler_->state());
 
   auth_attempt_->FinalizeUnlock(kTestUser1, true);
 
   ASSERT_EQ(TestLockHandler::STATE_UNLOCK_DONE, lock_handler_->state());
 }
 
 TEST_F(EasyUnlockAuthAttemptUnlockTest, FinalizeUnlockCalledForWrongUser) {
   InitScreenLock();
-  ASSERT_TRUE(ScreenlockBridge::Get()->IsLocked());
+  ASSERT_TRUE(GetScreenlockBridgeInstance()->IsLocked());
   ASSERT_EQ(TestLockHandler::STATE_ATTEMPTING_UNLOCK, lock_handler_->state());
 
   ASSERT_TRUE(auth_attempt_->Start());
 
   ASSERT_EQ(1u, app_manager_->auth_attempt_count());
   EXPECT_EQ(TestLockHandler::STATE_ATTEMPTING_UNLOCK, lock_handler_->state());
 
   auth_attempt_->FinalizeUnlock(kTestUser2, true);
 
   // If FinalizeUnlock is called for an incorrect user, it should be ignored
@@ skipping 14 matching lines @@
   ~EasyUnlockAuthAttemptSigninTest() override {}
 
   void SetUp() override {
     app_manager_.reset(new FakeAppManager());
     auth_attempt_.reset(new EasyUnlockAuthAttempt(
         app_manager_.get(), kTestUser1, EasyUnlockAuthAttempt::TYPE_SIGNIN,
         EasyUnlockAuthAttempt::FinalizedCallback()));
   }
 
   void TearDown() override {
-    ScreenlockBridge::Get()->SetLockHandler(NULL);
+    GetScreenlockBridgeInstance()->SetLockHandler(NULL);
     auth_attempt_.reset();
   }
 
  protected:
   void InitScreenLock() {
     lock_handler_.reset(new TestLockHandler(kTestUser1));
     lock_handler_->set_state(TestLockHandler::STATE_ATTEMPTING_SIGNIN);
-    ScreenlockBridge::Get()->SetLockHandler(lock_handler_.get());
+    GetScreenlockBridgeInstance()->SetLockHandler(lock_handler_.get());
   }
 
   scoped_ptr<EasyUnlockAuthAttempt> auth_attempt_;
   scoped_ptr<FakeAppManager> app_manager_;
   scoped_ptr<TestLockHandler> lock_handler_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(EasyUnlockAuthAttemptSigninTest);
 };
 
 TEST_F(EasyUnlockAuthAttemptSigninTest, StartWhenNotLocked) {
-  ASSERT_FALSE(ScreenlockBridge::Get()->IsLocked());
+  ASSERT_FALSE(GetScreenlockBridgeInstance()->IsLocked());
 
   EXPECT_FALSE(auth_attempt_->Start());
   EXPECT_EQ(0u, app_manager_->auth_attempt_count());
 }
 
 TEST_F(EasyUnlockAuthAttemptSigninTest, StartWhenAuthTypeIsPassword) {
   InitScreenLock();
-  ASSERT_TRUE(ScreenlockBridge::Get()->IsLocked());
+  ASSERT_TRUE(GetScreenlockBridgeInstance()->IsLocked());
   ASSERT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 
   lock_handler_->set_auth_type(ScreenlockBridge::LockHandler::OFFLINE_PASSWORD);
 
   EXPECT_FALSE(auth_attempt_->Start());
 
   EXPECT_EQ(0u, app_manager_->auth_attempt_count());
   EXPECT_EQ(TestLockHandler::STATE_SIGNIN_CANCELED, lock_handler_->state());
 }
 
 TEST_F(EasyUnlockAuthAttemptSigninTest,
        StartWhenDispatchingAuthAttemptEventFails) {
   InitScreenLock();
-  ASSERT_TRUE(ScreenlockBridge::Get()->IsLocked());
+  ASSERT_TRUE(GetScreenlockBridgeInstance()->IsLocked());
   ASSERT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 
   app_manager_->set_auth_attempt_should_fail(true);
 
   EXPECT_FALSE(auth_attempt_->Start());
 
   EXPECT_EQ(1u, app_manager_->auth_attempt_count());
   EXPECT_EQ(TestLockHandler::STATE_SIGNIN_CANCELED, lock_handler_->state());
 }
 
 TEST_F(EasyUnlockAuthAttemptSigninTest, ResetBeforeFinalizeSignin) {
   InitScreenLock();
-  ASSERT_TRUE(ScreenlockBridge::Get()->IsLocked());
+  ASSERT_TRUE(GetScreenlockBridgeInstance()->IsLocked());
   ASSERT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 
   ASSERT_TRUE(auth_attempt_->Start());
 
   ASSERT_EQ(1u, app_manager_->auth_attempt_count());
   EXPECT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 
   auth_attempt_.reset();
 
   EXPECT_EQ(TestLockHandler::STATE_SIGNIN_CANCELED, lock_handler_->state());
 }
 
 TEST_F(EasyUnlockAuthAttemptSigninTest, FinalizeSigninWithEmtpySecret) {
   InitScreenLock();
-  ASSERT_TRUE(ScreenlockBridge::Get()->IsLocked());
+  ASSERT_TRUE(GetScreenlockBridgeInstance()->IsLocked());
   ASSERT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 
   ASSERT_TRUE(auth_attempt_->Start());
 
   ASSERT_EQ(1u, app_manager_->auth_attempt_count());
   EXPECT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 
   auth_attempt_->FinalizeSignin(kTestUser1, "", GetSessionKey());
 
   EXPECT_EQ(TestLockHandler::STATE_SIGNIN_CANCELED, lock_handler_->state());
 }
 
 TEST_F(EasyUnlockAuthAttemptSigninTest, FinalizeSigninWithEmtpyKey) {
   InitScreenLock();
-  ASSERT_TRUE(ScreenlockBridge::Get()->IsLocked());
+  ASSERT_TRUE(GetScreenlockBridgeInstance()->IsLocked());
   ASSERT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 
   ASSERT_TRUE(auth_attempt_->Start());
 
   ASSERT_EQ(1u, app_manager_->auth_attempt_count());
   EXPECT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 
   auth_attempt_->FinalizeSignin(kTestUser1, GetWrappedSecret(), "");
 
   EXPECT_EQ(TestLockHandler::STATE_SIGNIN_CANCELED, lock_handler_->state());
 }
 
 TEST_F(EasyUnlockAuthAttemptSigninTest, SigninSuccess) {
   InitScreenLock();
-  ASSERT_TRUE(ScreenlockBridge::Get()->IsLocked());
+  ASSERT_TRUE(GetScreenlockBridgeInstance()->IsLocked());
   ASSERT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 
   ASSERT_TRUE(auth_attempt_->Start());
 
   ASSERT_EQ(1u, app_manager_->auth_attempt_count());
   EXPECT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 
   lock_handler_->set_expected_secret(GetSecret());
   auth_attempt_->FinalizeSignin(kTestUser1, GetWrappedSecret(),
                                 GetSessionKey());
 
   EXPECT_EQ(TestLockHandler::STATE_SIGNIN_DONE, lock_handler_->state());
 }
 
 TEST_F(EasyUnlockAuthAttemptSigninTest, WrongWrappedSecret) {
   InitScreenLock();
-  ASSERT_TRUE(ScreenlockBridge::Get()->IsLocked());
+  ASSERT_TRUE(GetScreenlockBridgeInstance()->IsLocked());
   ASSERT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 
   ASSERT_TRUE(auth_attempt_->Start());
 
   ASSERT_EQ(1u, app_manager_->auth_attempt_count());
   EXPECT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 
   auth_attempt_->FinalizeSignin(kTestUser1, "wrong_secret", GetSessionKey());
 
   EXPECT_EQ(TestLockHandler::STATE_SIGNIN_CANCELED, lock_handler_->state());
 }
 
 TEST_F(EasyUnlockAuthAttemptSigninTest, InvalidSessionKey) {
   InitScreenLock();
-  ASSERT_TRUE(ScreenlockBridge::Get()->IsLocked());
+  ASSERT_TRUE(GetScreenlockBridgeInstance()->IsLocked());
   ASSERT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 
   ASSERT_TRUE(auth_attempt_->Start());
 
   ASSERT_EQ(1u, app_manager_->auth_attempt_count());
   EXPECT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 
   auth_attempt_->FinalizeSignin(kTestUser1, GetWrappedSecret(), "invalid_key");
 
   EXPECT_EQ(TestLockHandler::STATE_SIGNIN_CANCELED, lock_handler_->state());
 }
 
 TEST_F(EasyUnlockAuthAttemptSigninTest, FinalizeUnlockCalled) {
   InitScreenLock();
-  ASSERT_TRUE(ScreenlockBridge::Get()->IsLocked());
+  ASSERT_TRUE(GetScreenlockBridgeInstance()->IsLocked());
   ASSERT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 
   ASSERT_TRUE(auth_attempt_->Start());
 
   ASSERT_EQ(1u, app_manager_->auth_attempt_count());
   EXPECT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 
   auth_attempt_->FinalizeUnlock(kTestUser1, true);
 
   EXPECT_EQ(TestLockHandler::STATE_SIGNIN_CANCELED, lock_handler_->state());
 }
 
 TEST_F(EasyUnlockAuthAttemptSigninTest, FinalizeSigninCalledForWrongUser) {
   InitScreenLock();
-  ASSERT_TRUE(ScreenlockBridge::Get()->IsLocked());
+  ASSERT_TRUE(GetScreenlockBridgeInstance()->IsLocked());
   ASSERT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 
   ASSERT_TRUE(auth_attempt_->Start());
 
   ASSERT_EQ(1u, app_manager_->auth_attempt_count());
   EXPECT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 
   lock_handler_->set_expected_secret(GetSecret());
 
   auth_attempt_->FinalizeSignin(kTestUser2, GetWrappedSecret(),
                                 GetSessionKey());
 
   EXPECT_EQ(TestLockHandler::STATE_ATTEMPTING_SIGNIN, lock_handler_->state());
 
   auth_attempt_->FinalizeSignin(kTestUser1, GetWrappedSecret(),
                                 GetSessionKey());
 
   EXPECT_EQ(TestLockHandler::STATE_SIGNIN_DONE, lock_handler_->state());
 }
 #endif  // defined(OS_CHROMEOS)
 
 }  // namespace