Rename components's Encryptor to OSEncrypt.

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"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_util.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/pref_names.h"
-#include "components/encryptor/encryptor.h"
+#include "components/encryptor/os_crypt.h"
 #include "components/user_prefs/pref_registry_syncable.h"
 #include "crypto/random.h"
 #include "crypto/secure_util.h"
 #include "crypto/symmetric_key.h"
 
 namespace {
 
 // WARNING: Changing these values will make it impossible to do off-line
 // authentication until the next successful on-line authentication.  To change
 // these safely, change the "encoding" version below and make verification
@@ skipping 27 matching lines @@
 
   return password_hash;
 }
 
 std::string EncodePasswordHashRecord(const std::string& record,
                                      char encoding) {
   DCHECK_EQ(kHash1Encoding, encoding);  // Currently support only one method.
 
   // Encrypt the hash using the OS account-password protection (if available).
   std::string encoded;
-  const bool success = Encryptor::EncryptString(record, &encoded);
+  const bool success = OSCrypt::EncryptString(record, &encoded);
   DCHECK(success);
 
   // Convert binary record to text for preference database.
   std::string encoded64;
   base::Base64Encode(encoded, &encoded64);
 
   // Stuff the "encoding" value into the first byte.
   encoded64.insert(0, &encoding, sizeof(encoding));
 
   return encoded64;
 }
 
 bool DecodePasswordHashRecord(const std::string& encoded,
                               std::string* decoded,
                               char* encoding) {
   // Extract the "encoding" value from the first byte and validate.
   if (encoded.length() < 1)
     return false;
   *encoding = encoded[0];
   if (*encoding != kHash1Encoding)
     return false;
 
   // 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 Encryptor::DecryptString(unbase64, decoded);
+  return OSCrypt::DecryptString(unbase64, decoded);
 }
 
 }  // namespace
 
 namespace chrome {
 
 void RegisterLocalAuthPrefs(user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterStringPref(
       prefs::kGoogleServicesPasswordHash,
       std::string(),
@@ skipping 87 matching lines @@
       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);
 }
 
 }  // namespace chrome