Add FingerprintUnlock KeyedService for each profile

chrome/browser/chromeos/login/lock/screen_locker.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 "chrome/browser/chromeos/login/lock/screen_locker.h"
 
 #include <string>
 #include <vector>
 
 #include "ash/common/wallpaper/wallpaper_controller.h"
@@ skipping 12 matching lines @@
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/accessibility/accessibility_manager.h"
 #include "chrome/browser/chromeos/login/lock/webui_screen_locker.h"
-#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/session/user_session_manager.h"
 #include "chrome/browser/chromeos/login/supervised/supervised_user_authentication.h"
 #include "chrome/browser/chromeos/login/ui/user_adding_screen.h"
 #include "chrome/browser/chromeos/login/users/chrome_user_manager.h"
 #include "chrome/browser/chromeos/login/users/supervised_user_manager.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chrome/browser/signin/easy_unlock_service.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/ui/webui/chromeos/login/screenlock_icon_provider.h"
 #include "chrome/browser/ui/webui/chromeos/login/screenlock_icon_source.h"
@@ skipping 61 matching lines @@
   void Observe(int type,
                const content::NotificationSource& source,
                const content::NotificationDetails& details) override {
     if (type == chrome::NOTIFICATION_SESSION_STARTED) {
       session_started_ = true;
 
       // The user session has just started, so the user has logged in. Mark a
       // strong authentication to allow them to use PIN to unlock the device.
       user_manager::User* user =
           content::Details<user_manager::User>(details).ptr();
-      quick_unlock::PinStorage* pin_storage =
-          quick_unlock::PinStorageFactory::GetForUser(user);
-      if (pin_storage)
-        pin_storage->MarkStrongAuth();
+      quick_unlock::QuickUnlockStorage* quick_unlock_storage =
+          quick_unlock::QuickUnlockFactory::GetForUser(user);
+      if (quick_unlock_storage)
+        quick_unlock_storage->MarkStrongAuth();
     } else {
       NOTREACHED() << "Unexpected notification " << type;
     }
   }
 
   // UserAddingScreen::Observer overrides:
   void OnUserAddingFinished() override {
     UserAddingScreen::Get()->RemoveObserver(this);
     ScreenLocker::HandleLockScreenRequest();
   }
@@ skipping 108 matching lines @@
           user_context.GetAccountId());
     }
 
     // Reset the number of PIN attempts available to the user. We always do this
     // because:
     // 1. If the user signed in with a PIN, that means they should be able to
     //    continue signing in with a PIN.
     // 2. If the user signed in with cryptohome keys, then the PIN timeout is
     //    going to be reset as well, so it is safe to reset the unlock attempt
     //    count.
-    quick_unlock::PinStorage* pin_storage =
-        quick_unlock::PinStorageFactory::GetForUser(user);
-    if (pin_storage)
-      pin_storage->ResetUnlockAttemptCount();
+    quick_unlock::QuickUnlockStorage* quick_unlock_storage =
+        quick_unlock::QuickUnlockFactory::GetForUser(user);
+    if (quick_unlock_storage) {
+      quick_unlock_storage->pin_storage()->ResetUnlockAttemptCount();
+      quick_unlock_storage->fingerprint_storage()->ResetUnlockAttemptCount();
+    }
 
     UserSessionManager::GetInstance()->UpdateEasyUnlockKeys(user_context);
   } else {
     NOTREACHED() << "Logged in user not found.";
   }
 
   authentication_capture_.reset(new AuthenticationParametersCapture());
   authentication_capture_->user_context = user_context;
 
   // Add guard for case when something get broken in call chain to unlock
   // for sure.
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&ScreenLocker::UnlockOnLoginSuccess,
                             weak_factory_.GetWeakPtr()),
       base::TimeDelta::FromMilliseconds(kUnlockGuardTimeoutMs));
   web_ui()->AnimateAuthenticationSuccess();
 }
 
 void ScreenLocker::OnPasswordAuthSuccess(const UserContext& user_context) {
   // The user has signed in using their password, so reset the PIN timeout.
-  quick_unlock::PinStorage* pin_storage =
-      quick_unlock::PinStorageFactory::GetForAccountId(
+  quick_unlock::QuickUnlockStorage* quick_unlock_storage =
+      quick_unlock::QuickUnlockFactory::GetForAccountId(
           user_context.GetAccountId());
-  if (pin_storage)
-    pin_storage->MarkStrongAuth();
+  if (quick_unlock_storage)
+    quick_unlock_storage->MarkStrongAuth();
 }
 
 void ScreenLocker::UnlockOnLoginSuccess() {
   DCHECK(base::MessageLoopForUI::IsCurrent());
   if (!authentication_capture_.get()) {
     LOG(WARNING) << "Call to UnlockOnLoginSuccess without previous " <<
       "authentication success.";
     return;
   }
 
@@ skipping 18 matching lines @@
   const user_manager::User* user = FindUnlockUser(user_context.GetAccountId());
   if (user) {
     // Check to see if the user submitted a PIN and it is valid.
     const std::string pin = user_context.GetKey()->GetSecret();
 
     // We only want to try authenticating the pin if it is a number,
     // otherwise we will timeout PIN if the user enters their account password
     // incorrectly more than a few times.
     int dummy_value;
     if (is_pin_attempt_ && base::StringToInt(pin, &dummy_value)) {
-      quick_unlock::PinStorage* pin_storage =
-          quick_unlock::PinStorageFactory::GetForUser(user);
-      if (pin_storage && pin_storage->TryAuthenticatePin(pin)) {
+      quick_unlock::QuickUnlockStorage* quick_unlock_storage =
+          quick_unlock::QuickUnlockFactory::GetForUser(user);
+      if (quick_unlock_storage &&
+          quick_unlock_storage->TryAuthenticatePin(pin)) {
         OnAuthSuccess(user_context);
         return;
       }
     }
 
     // Special case: supervised users. Use special authenticator.
     if (user->GetType() == user_manager::USER_TYPE_SUPERVISED) {
       UserContext updated_context = ChromeUserManager::Get()
                                         ->GetSupervisedUserManager()
                                         ->GetAuthentication()
@@ skipping 228 matching lines @@
 
 bool ScreenLocker::IsUserLoggedIn(const AccountId& account_id) const {
   for (user_manager::User* user : users_) {
     if (user->GetAccountId() == account_id)
       return true;
   }
   return false;
 }
 
 }  // namespace chromeos