Use GetSystemSalt from the cryptohome lib instead of reading salt off disk.

chrome/browser/chromeos/login/google_authenticator.cc

 // Copyright (c) 2010 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/google_authenticator.h"
 
 #include <string>
 #include <vector>
 
 #include "base/file_path.h"
@@ skipping 65 matching lines @@
     : Authenticator(consumer),
       fetcher_(NULL),
       getter_(NULL),
       checked_for_localaccount_(false),
       unlock_(false),
       try_again_(true) {
   CHECK(chromeos::CrosLibrary::Get()->EnsureLoaded());
 }
 
 GoogleAuthenticator::~GoogleAuthenticator() {
-  ChromeThread::DeleteSoon(ChromeThread::FILE, FROM_HERE, fetcher_);
+  delete fetcher_;
 }
 
 // static
 URLFetcher* GoogleAuthenticator::CreateClientLoginFetcher(
     URLRequestContextGetter* getter,
     const std::string& body,
     URLFetcher::Delegate* delegate) {
   URLFetcher* to_return =
       URLFetcher::Create(0,
                          GURL(AuthResponseHandler::kClientLoginUrl),
                          URLFetcher::POST,
                          delegate);
   to_return->set_request_context(getter);
   to_return->set_load_flags(net::LOAD_DO_NOT_SEND_COOKIES);
   to_return->set_upload_data("application/x-www-form-urlencoded", body);
   return to_return;
 }
 
 bool GoogleAuthenticator::AuthenticateToLogin(Profile* profile,
                                               const std::string& username,
                                               const std::string& password) {
-  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
   unlock_ = false;
   getter_ = profile->GetRequestContext();
 
   // TODO(cmasone): be more careful about zeroing memory that stores
   // the user's password.
   request_body_ = StringPrintf(kFormat,
                                UrlEncodeString(username).c_str(),
                                UrlEncodeString(password).c_str(),
                                kCookiePersistence,
                                kAccountType,
@@ skipping 128 matching lines @@
   NotificationService::current()->Notify(
       NotificationType::LOGIN_AUTHENTICATION,
       NotificationService::AllSources(),
       Details<AuthenticationNotificationDetails>(&details));
   LOG(WARNING) << "Login failed: " << data;
   // TODO(cmasone): what can we do to expose these OS/server-side error strings
   // in an internationalizable way?
   consumer_->OnLoginFailure(data);
 }
 
-void GoogleAuthenticator::LoadSystemSalt(const FilePath& path) {
+void GoogleAuthenticator::LoadSystemSalt() {
   if (!system_salt_.empty())
     return;
-  CHECK(PathExists(path)) << path.value() << " does not exist!";
-  int64 file_size;
-  CHECK(GetFileSize(path, &file_size)) << "Could not get size of "
-                                       << path.value();
-
-  char salt[file_size];
-  int data_read = ReadFile(path, salt, file_size);
-
-  CHECK_EQ(data_read % 2, 0);
-  system_salt_.assign(salt, salt + data_read);
+  system_salt_ = CrosLibrary::Get()->GetCryptohomeLibrary()->GetSystemSalt();
+  CHECK(!system_salt_.empty());
+  CHECK_EQ(system_salt_.size() % 2, 0U);
 }
 
 void GoogleAuthenticator::LoadLocalaccount(const std::string& filename) {
   if (checked_for_localaccount_)
     return;
   FilePath localaccount_file;
   std::string localaccount;
   if (PathService::Get(base::DIR_EXE, &localaccount_file)) {
     localaccount_file = localaccount_file.Append(filename);
     LOG(INFO) << "looking for localaccount in " << localaccount_file.value();
@@ skipping 31 matching lines @@
   std::vector<unsigned char> passhash(passhash_buf,
                                       passhash_buf + sizeof(passhash_buf));
   BinaryToHex(passhash,
               passhash.size() / 2,  // only want top half, at least for now.
               ascii_buf,
               sizeof(ascii_buf));
   ascii_hash_.assign(ascii_buf, sizeof(ascii_buf) - 1);
 }
 
 std::string GoogleAuthenticator::SaltAsAscii() {
-  LoadSystemSalt(FilePath(kSystemSalt));  // no-op if it's already loaded.
+  LoadSystemSalt();  // no-op if it's already loaded.
   unsigned int salt_len = system_salt_.size();
   char ascii_salt[2 * salt_len + 1];
   if (GoogleAuthenticator::BinaryToHex(system_salt_,
                                        salt_len,
                                        ascii_salt,
                                        sizeof(ascii_salt))) {
     return std::string(ascii_salt, sizeof(ascii_salt) - 1);
   } else {
     return std::string();
   }
@@ skipping 35 matching lines @@
   DCHECK_EQ(parts.size(), 2U) << "email_address should have only one @";
   RemoveChars(parts[0], ".", &parts[0]);
   if (parts[0].find('+') != std::string::npos)
     parts[0].erase(parts[0].find('+'));
   std::string new_email = StringToLowerASCII(JoinString(parts, at));
   LOG(INFO) << "Canonicalized " << email_address << " to " << new_email;
   return new_email;
 }
 
 }  // namespace chromeos