Add FingerprintUnlock KeyedService for each profile

chrome/browser/chromeos/login/quick_unlock/pin_storage_unittest.cc

 // Copyright 2016 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/chromeos/login/quick_unlock/pin_storage.h"
-#include "chrome/browser/chromeos/login/quick_unlock/pin_storage_factory.h"
+#include "chrome/browser/chromeos/login/quick_unlock/quick_unlock_factory.h"
+#include "chrome/browser/chromeos/login/quick_unlock/quick_unlock_storage.h"
 #include "chrome/browser/chromeos/login/quick_unlock/quick_unlock_utils.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/scoped_user_pref_update.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chromeos {
 namespace {
@@ skipping 51 matching lines @@
 // 1. Prefs are initially empty
 // 2. Setting a PIN will update the pref system.
 // 3. Removing a PIN clears prefs.
 TEST_F(PinStorageUnitTest, PinStorageWritesToPrefs) {
   PrefService* prefs = profile_->GetPrefs();
 
   EXPECT_EQ("", prefs->GetString(prefs::kQuickUnlockPinSalt));
   EXPECT_EQ("", prefs->GetString(prefs::kQuickUnlockPinSecret));
 
   quick_unlock::PinStorage* pin_storage =
-      quick_unlock::PinStorageFactory::GetForProfile(profile_.get());
+      quick_unlock::QuickUnlockFactory::GetForProfile(profile_.get())
+          ->pin_storage();
   PinStorageTestApi pin_storage_test(pin_storage);
 
   pin_storage->SetPin("1111");
   EXPECT_TRUE(pin_storage->IsPinSet());
   EXPECT_EQ(pin_storage_test.PinSalt(),
             prefs->GetString(prefs::kQuickUnlockPinSalt));
   EXPECT_EQ(pin_storage_test.PinSecret(),
             prefs->GetString(prefs::kQuickUnlockPinSecret));
   EXPECT_NE("", pin_storage_test.PinSalt());
   EXPECT_NE("", pin_storage_test.PinSecret());
 
   pin_storage->RemovePin();
   EXPECT_FALSE(pin_storage->IsPinSet());
   EXPECT_EQ("", prefs->GetString(prefs::kQuickUnlockPinSalt));
   EXPECT_EQ("", prefs->GetString(prefs::kQuickUnlockPinSecret));
 }
 
 // Verifies that:
 // 1. Initial unlock attempt count is zero.
 // 2. Attempting unlock attempts correctly increases unlock attempt count.
 // 3. Resetting unlock attempt count correctly sets attempt count to 0.
 TEST_F(PinStorageUnitTest, UnlockAttemptCount) {
   quick_unlock::PinStorage* pin_storage =
-      quick_unlock::PinStorageFactory::GetForProfile(profile_.get());
+      quick_unlock::QuickUnlockFactory::GetForProfile(profile_.get())
+          ->pin_storage();
 
   EXPECT_EQ(0, pin_storage->unlock_attempt_count());
 
   pin_storage->AddUnlockAttempt();
   pin_storage->AddUnlockAttempt();
   pin_storage->AddUnlockAttempt();
   EXPECT_EQ(3, pin_storage->unlock_attempt_count());
 
   pin_storage->ResetUnlockAttemptCount();
   EXPECT_EQ(0, pin_storage->unlock_attempt_count());
 }
 
 // Verifies that marking the strong auth makes TimeSinceLastStrongAuth a > zero
 // value.
 TEST_F(PinStorageUnitTest, TimeSinceLastStrongAuthReturnsPositiveValue) {
   quick_unlock::PinStorage* pin_storage =
-      quick_unlock::PinStorageFactory::GetForProfile(profile_.get());
+      quick_unlock::QuickUnlockFactory::GetForProfile(profile_.get())
+          ->pin_storage();
   PinStorageTestApi pin_storage_test(pin_storage);
 
   EXPECT_FALSE(pin_storage_test.HasStrongAuthInfo());
 
   pin_storage->MarkStrongAuth();
 
   EXPECT_TRUE(pin_storage_test.HasStrongAuthInfo());
   pin_storage_test.ReduceRemainingStrongAuthTimeBy(
       base::TimeDelta::FromSeconds(60));
 
   EXPECT_TRUE(pin_storage->TimeSinceLastStrongAuth() >=
               base::TimeDelta::FromSeconds(30));
 }
 
 // Verifies that by altering the password confirmation preference, the pin
 // storage will request password reconfirmation as expected.
 TEST_F(PinStorageUnitTest, QuickUnlockPasswordConfirmationFrequencyPreference) {
   quick_unlock::PinStorage* pin_storage =
-      quick_unlock::PinStorageFactory::GetForProfile(profile_.get());
+      quick_unlock::QuickUnlockFactory::GetForProfile(profile_.get())
+          ->pin_storage();
   PrefService* pref_service = profile_->GetPrefs();
   PinStorageTestApi test_api(pin_storage);
 
   // The default is one day, so verify moving the last strong auth time back 13
   // hours should not request strong auth.
   pin_storage->MarkStrongAuth();
   test_api.ReduceRemainingStrongAuthTimeBy(base::TimeDelta::FromHours(13));
   EXPECT_TRUE(pin_storage->HasStrongAuth());
 
   // Verify moving the last strong auth time back another 13 hours should
@@ skipping 34 matching lines @@
   test_api.ReduceRemainingStrongAuthTimeBy(base::TimeDelta::FromHours(8));
   EXPECT_FALSE(pin_storage->HasStrongAuth());
   SetConfirmationFrequency(
       pref_service, quick_unlock::PasswordConfirmationFrequency::TWELVE_HOURS);
   EXPECT_TRUE(pin_storage->HasStrongAuth());
 }
 
 // Verifies that the correct pin can be used to authenticate.
 TEST_F(PinStorageUnitTest, AuthenticationSucceedsWithRightPin) {
   quick_unlock::PinStorage* pin_storage =
-      quick_unlock::PinStorageFactory::GetForProfile(profile_.get());
+      quick_unlock::QuickUnlockFactory::GetForProfile(profile_.get())
+          ->pin_storage();
 
   pin_storage->SetPin("1111");
 
   pin_storage->MarkStrongAuth();
   EXPECT_TRUE(pin_storage->TryAuthenticatePin("1111"));
 }
 
 // Verifies that the correct pin will fail to authenticate if too many
 // authentication attempts have been made.
 TEST_F(PinStorageUnitTest, AuthenticationFailsFromTooManyAttempts) {
   quick_unlock::PinStorage* pin_storage =
-      quick_unlock::PinStorageFactory::GetForProfile(profile_.get());
+      quick_unlock::QuickUnlockFactory::GetForProfile(profile_.get())
+          ->pin_storage();
 
   pin_storage->SetPin("1111");
 
   // Use up all of the authentication attempts so authentication fails.
   pin_storage->MarkStrongAuth();
   EXPECT_TRUE(pin_storage->IsPinAuthenticationAvailable());
   for (int i = 0; i < quick_unlock::PinStorage::kMaximumUnlockAttempts; ++i)
     EXPECT_FALSE(pin_storage->TryAuthenticatePin("foobar"));
 
   // We used up all of the attempts, so entering the right PIN will still fail.
   EXPECT_FALSE(pin_storage->IsPinAuthenticationAvailable());
   EXPECT_FALSE(pin_storage->TryAuthenticatePin("1111"));
 }
 
 // Verifies that the correct pin will fail to authenticate if it has been too
 // long since a strong-auth/password authentication.
 TEST_F(PinStorageUnitTest, AuthenticationFailsFromTimeout) {
   quick_unlock::PinStorage* pin_storage =
-      quick_unlock::PinStorageFactory::GetForProfile(profile_.get());
+      quick_unlock::QuickUnlockFactory::GetForProfile(profile_.get())
+          ->pin_storage();
   PinStorageTestApi pin_storage_test(pin_storage);
 
   pin_storage->SetPin("1111");
   pin_storage->MarkStrongAuth();
   EXPECT_TRUE(pin_storage->IsPinAuthenticationAvailable());
 
   // Remove all of the strong auth time so that we have a strong auth timeout.
   pin_storage_test.ReduceRemainingStrongAuthTimeBy(
       base::TimeDelta::FromDays(10));
 
   EXPECT_FALSE(pin_storage->IsPinAuthenticationAvailable());
 }
 }  // namespace chromeos