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"

[Ilya Sherman, 2015/04/24 21:22:01]

nit: Not needed?

[msarda, 2015/04/27 11:29:24]

Done.

 #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"

[Ilya Sherman, 2015/04/24 21:22:01]

nit: Not needed?

[msarda, 2015/04/27 11:29:24]

Done.

+#include "components/proximity_auth/screenlock_bridge.h"
+#include "components/signin/core/browser/signin_manager_base.h"

[Ilya Sherman, 2015/04/24 21:22:01]

nit: Not needed?

[msarda, 2015/04/27 11:29:24]

Done.

 #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 73 matching lines @@
   }
 
  private:
   size_t auth_attempt_count_;
   bool auth_attempt_should_fail_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeAppManager);
 };
 
 // Fake lock handler to be used in these tests.
-class TestLockHandler : public ScreenlockBridge::LockHandler {
+class TestLockHandler : public proximity_auth::ScreenlockBridge::LockHandler {
  public:
   // The state of unlock/signin procedure.
   enum AuthState {
     STATE_NONE,
     STATE_ATTEMPTING_UNLOCK,
     STATE_UNLOCK_CANCELED,
     STATE_UNLOCK_DONE,
     STATE_ATTEMPTING_SIGNIN,
     STATE_SIGNIN_CANCELED,
     STATE_SIGNIN_DONE
@@ skipping 12 matching lines @@
   void set_user_id(const std::string& value) { user_id_ = value; }
 
   // Sets the secret that is expected to be sent to |AttemptEasySignin|
   void set_expected_secret(const std::string& value) {
     expected_secret_ = value;
   }
 
   // Not using |SetAuthType| to make sure it's not called during tests.
   void set_auth_type(AuthType value) { auth_type_ = value; }
 
-  // ScreenlockBridge::LockHandler implementation:
+  // proximity_auth::ScreenlockBridge::LockHandler implementation:
   void ShowBannerMessage(const base::string16& message) override {
     ADD_FAILURE() << "Should not be reached.";
   }
 
   void ShowUserPodCustomIcon(
       const std::string& user_email,
-      const ScreenlockBridge::UserPodCustomIconOptions& icon) override {
+      const proximity_auth::ScreenlockBridge::UserPodCustomIconOptions& icon)
+      override {
     ADD_FAILURE() << "Should not be reached.";
   }
 
   void HideUserPodCustomIcon(const std::string& user_email) override {
     ADD_FAILURE() << "Should not be reached.";
   }
 
   void EnableInput() override {
     ASSERT_EQ(STATE_ATTEMPTING_UNLOCK, state_);
     state_ = STATE_UNLOCK_CANCELED;
@@ skipping 54 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);
+  lock_handler_->set_auth_type(
+      proximity_auth::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);
+  lock_handler_->set_auth_type(
+      proximity_auth::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