Disable lock if no credentials are present

chrome/browser/signin/local_auth.cc

 // Copyright 2013 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/local_auth.h"
 
 #include "base/base64.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
@@ skipping 76 matching lines @@
 
   // Stored record is base64; convert to binary.
   std::string unbase64;
   if (!base::Base64Decode(encoded.substr(1), &unbase64))
     return false;
 
   // Decrypt the record using the OS account-password protection (if available).
   return OSCrypt::DecryptString(unbase64, decoded);
 }
 
+size_t GetProfileInfoIndexOfProfile(const Profile* profile) {
+  DCHECK(profile);
+
+  ProfileInfoCache& info =
+      g_browser_process->profile_manager()->GetProfileInfoCache();
+  return info.GetIndexOfProfileWithPath(profile->GetPath());
+}
+
 }  // namespace
 
 namespace chrome {
 
 void RegisterLocalAuthPrefs(user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterStringPref(
       prefs::kGoogleServicesPasswordHash,
       std::string(),
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
 void SetLocalAuthCredentials(size_t info_index,
                              const std::string& password) {
+  if (info_index == std::string::npos) {
+    NOTREACHED();
+    return;
+  }
   DCHECK(password.length());
 
   // Salt should be random data, as long as the hash length, and different with
   // every save.
   std::string salt_str;
   crypto::RandBytes(WriteInto(&salt_str, kHash1Bytes + 1), kHash1Bytes);
   DCHECK_EQ(kHash1Bytes, salt_str.length());
 
   // Perform secure hash of password for storage.
   std::string password_hash = CreateSecurePasswordHash(
       salt_str, password, kHash1Encoding);
   DCHECK_EQ(kHash1Bytes, password_hash.length());
 
   // Group all fields into a single record for storage;
   std::string record;
   record.append(salt_str);
   record.append(password_hash);
 
   // Encode it and store it.
   std::string encoded = EncodePasswordHashRecord(record, kHash1Encoding);
   ProfileInfoCache& info =
       g_browser_process->profile_manager()->GetProfileInfoCache();
   info.SetLocalAuthCredentialsOfProfileAtIndex(info_index, encoded);
 }
 
 void SetLocalAuthCredentials(const Profile* profile,
                              const std::string& password) {
-  DCHECK(profile);
-
-  ProfileInfoCache& info =
-      g_browser_process->profile_manager()->GetProfileInfoCache();
-  size_t info_index = info.GetIndexOfProfileWithPath(profile->GetPath());
-  if (info_index == std::string::npos) {
-    NOTREACHED();
-    return;
-  }
-  SetLocalAuthCredentials(info_index, password);
+  SetLocalAuthCredentials(GetProfileInfoIndexOfProfile(profile), password);
 }
 
 bool ValidateLocalAuthCredentials(size_t info_index,
                                   const std::string& password) {
+  if (info_index == std::string::npos) {
+    NOTREACHED();
+    return false;
+  }
+
   std::string record;
   char encoding;
 
   ProfileInfoCache& info =
       g_browser_process->profile_manager()->GetProfileInfoCache();
 
   std::string encodedhash =
       info.GetLocalAuthCredentialsOfProfileAtIndex(info_index);
   if (encodedhash.length() == 0 && password.length() == 0)
     return true;
@@ skipping 18 matching lines @@
     // unknown encoding
     return false;
   }
 
   return crypto::SecureMemEqual(password_saved, password_check,
                                 password_length);
 }
 
 bool ValidateLocalAuthCredentials(const Profile* profile,
                                   const std::string& password) {
-  DCHECK(profile);
+  return ValidateLocalAuthCredentials(GetProfileInfoIndexOfProfile(profile),
+                                      password);
+}
+
+bool LocalAuthCredentialsExist(size_t profile_info_index) {
+  if (profile_info_index == std::string::npos) {
+    NOTREACHED();
+    return false;
+  }
 
   ProfileInfoCache& info =
       g_browser_process->profile_manager()->GetProfileInfoCache();
-  size_t info_index = info.GetIndexOfProfileWithPath(profile->GetPath());
-  if (info_index == std::string::npos) {
-    NOTREACHED();  // This should never happen but fail safely if it does.
-    return false;
-  }
-  return ValidateLocalAuthCredentials(info_index, password);
+
+  std::string encodedhash =
+      info.GetLocalAuthCredentialsOfProfileAtIndex(profile_info_index);
+
+  return !encodedhash.empty();
+}
+
+bool LocalAuthCredentialsExist(const Profile* profile) {
+  return LocalAuthCredentialsExist(GetProfileInfoIndexOfProfile(profile));
 }
 
 }  // namespace chrome