Copy Smart Lock user preferences to local state so we can access them on the sign-in screen.

chrome/browser/signin/easy_unlock_service.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/signin/easy_unlock_service.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 47 matching lines @@
   ExtensionService* extension_service = extension_system->extension_service();
   return extension_service->component_loader();
 }
 
 PrefService* GetLocalState() {
   return g_browser_process ? g_browser_process->local_state() : NULL;
 }
 
 }  // namespace
 
+EasyUnlockService::UserSettings::UserSettings() : check_close_proximity(false) {
+}
+
+EasyUnlockService::UserSettings::~UserSettings() {
+}
+
 // static
 EasyUnlockService* EasyUnlockService::Get(Profile* profile) {
   return EasyUnlockServiceFactory::GetForProfile(profile);
 }
 
 // static
 EasyUnlockService* EasyUnlockService::GetForUser(
     const user_manager::User& user) {
 #if defined(OS_CHROMEOS)
   Profile* profile = chromeos::ProfileHelper::Get()->GetProfileByUser(&user);
@@ skipping 148 matching lines @@
       new base::DictionaryValue(),
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterBooleanPref(
       prefs::kEasyUnlockProximityRequired,
       false,
       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 }
 
 // static
 void EasyUnlockService::RegisterPrefs(PrefRegistrySimple* registry) {
+  registry->RegisterDictionaryPref(prefs::kEasyUnlockLocalStateUserPrefs);
   registry->RegisterDictionaryPref(prefs::kEasyUnlockHardlockState);
 #if defined(OS_CHROMEOS)
   EasyUnlockTpmKeyManager::RegisterLocalStatePrefs(registry);
 #endif
 }
 
 // static
 void EasyUnlockService::ResetLocalStateForUser(const std::string& user_id) {
   DCHECK(!user_id.empty());
 
   PrefService* local_state = GetLocalState();
   if (!local_state)
     return;
 
   DictionaryPrefUpdate update(local_state, prefs::kEasyUnlockHardlockState);
   update->RemoveWithoutPathExpansion(user_id, NULL);
 
 #if defined(OS_CHROMEOS)
   EasyUnlockTpmKeyManager::ResetLocalStateForUser(user_id);
 #endif
 }
 
+// static
+EasyUnlockService::UserSettings EasyUnlockService::GetUserSettings(
+    const std::string& user_id) {
+  DCHECK(!user_id.empty());
+  UserSettings user_settings;
+
+  PrefService* local_state = GetLocalState();
+  if (!local_state)
+    return user_settings;
+
+  const base::DictionaryValue* all_user_prefs_dict =
+      local_state->GetDictionary(prefs::kEasyUnlockLocalStateUserPrefs);
+  if (!all_user_prefs_dict)
+    return user_settings;
+
+  const base::DictionaryValue* user_prefs_dict;
+  if (!all_user_prefs_dict->GetDictionaryWithoutPathExpansion(user_id,
+                                                              &user_prefs_dict))
+    return user_settings;
+
+  user_prefs_dict->GetBooleanWithoutPathExpansion(
+      prefs::kEasyUnlockProximityRequired,
+      &user_settings.check_close_proximity);
+
+  return user_settings;
+}
+
 bool EasyUnlockService::IsAllowed() {
   if (shut_down_)
     return false;
 
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           proximity_auth::switches::kDisableEasyUnlock)) {
     return false;
   }
 
   if (!IsAllowedInternal())
@@ skipping 453 matching lines @@
 
   // TODO(tbarzic): Set check_private_key only if previous sign-in attempt
   // failed.
   EasyUnlockTpmKeyManagerFactory::GetInstance()->Get(profile_)
       ->PrepareTpmKey(true /* check_private_key */,
                       base::Closure());
 #endif  // defined(OS_CHROMEOS)
 
   tpm_key_checked_ = true;
 }