PART1: Initiated the SignedSettings refactoring.

chrome/browser/chromeos/login/user_manager.cc

 // Copyright (c) 2011 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/user_manager.h"
 
+#include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
+#include "base/memory/weak_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/rand_util.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "crypto/nss_util.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/chromeos/cros_settings.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros/cryptohome_library.h"
 #include "chrome/browser/chromeos/input_method/input_method_manager.h"
 #include "chrome/browser/chromeos/login/default_user_images.h"
 #include "chrome/browser/chromeos/login/login_display.h"
 #include "chrome/browser/chromeos/login/ownership_service.h"
 #include "chrome/browser/chromeos/user_cros_settings_provider.h"
 #include "chrome/browser/chromeos/wm_ipc.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/prefs/pref_service.h"
@@ skipping 92 matching lines @@
   if (file_util::WriteFile(image_path,
                            reinterpret_cast<char*>(&encoded_image[0]),
                            encoded_image.size()) == -1) {
     LOG(ERROR) << "Failed to save image to file.";
     return;
   }
 
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
-      NewRunnableFunction(&SavePathToLocalState,
-                          username, image_path.value()));
+      base::Bind(&SavePathToLocalState,
+                 username, image_path.value()));
 }
 
 // Deletes user's image file. Runs on FILE thread.
 void DeleteUserImage(const FilePath& image_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   if (!file_util::Delete(image_path, false)) {
     LOG(ERROR) << "Failed to remove user image.";
     return;
   }
 }
@@ skipping 19 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   bool is_owner = OwnershipService::GetSharedInstance()->CurrentUserIsOwner();
   VLOG(1) << "Current user " << (is_owner ? "is owner" : "is not owner");
 
   g_user_manager.Get().set_current_user_is_owner(is_owner);
 
   // UserManager should be accessed only on UI thread.
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
-      NewRunnableFunction(&UpdateOwnership, is_owner));
+      base::Bind(&UpdateOwnership, is_owner));
 }
 
 // Used to handle the asynchronous response of deleting a cryptohome directory.
 class RemoveAttempt : public CryptohomeLibrary::Delegate {
  public:
   // Creates new remove attempt for the given user. Note, |delegate| can
   // be NULL.
   RemoveAttempt(const std::string& user_email,
                 chromeos::RemoveUserDelegate* delegate)
       : user_email_(user_email),
         delegate_(delegate),
-        method_factory_(this) {
+        pointer_factory_(this) {
     RemoveUser();
   }
 
   virtual ~RemoveAttempt() {}
 
   void RemoveUser() {
     // Owner is not allowed to be removed from the device.
     // Must not proceed without signature verification.
-    UserCrosSettingsProvider user_settings;
-    bool trusted_owner_available = user_settings.RequestTrustedOwner(
-        method_factory_.NewRunnableMethod(&RemoveAttempt::RemoveUser));
+    CrosSettings* cros_settings = CrosSettings::Get();
+    bool trusted_owner_available = cros_settings->GetTrusted(
+        kDeviceOwner,
+        base::Bind(&RemoveAttempt::RemoveUser, pointer_factory_.GetWeakPtr()));
     if (!trusted_owner_available) {
       // Value of owner email is still not verified.
       // Another attempt will be invoked after verification completion.
       return;
     }
-    if (user_email_ == UserCrosSettingsProvider::cached_owner()) {
+    std::string owner;
+    cros_settings->GetString(kDeviceOwner, &owner);
+    if (user_email_ == owner) {
       // Owner is not allowed to be removed from the device. Probably on
       // the stack, so deffer the deletion.
       MessageLoop::current()->DeleteSoon(FROM_HERE, this);
       return;
     }
 
     if (delegate_)
       delegate_->OnBeforeUserRemoved(user_email_);
 
     chromeos::UserManager::Get()->RemoveUserFromList(user_email_);
@@ skipping 17 matching lines @@
               << " failed, return code: " << return_code;
     }
     delete this;
   }
 
  private:
   std::string user_email_;
   chromeos::RemoveUserDelegate* delegate_;
 
   // Factory of callbacks.
-  ScopedRunnableMethodFactory<RemoveAttempt> method_factory_;
+  base::WeakPtrFactory<RemoveAttempt> pointer_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RemoveAttempt);
 };
 
 }  // namespace
 
 UserManager::User::User() : oauth_token_status_(OAUTH_TOKEN_STATUS_UNKNOWN),
                             is_displayname_unique_(false) {
   image_ = *ResourceBundle::GetSharedInstance().GetBitmapNamed(
       kDefaultImageResources[0]);
@@ skipping 222 matching lines @@
   prefs_oauth_update->RemoveWithoutPathExpansion(email, NULL);
 
   prefs->SavePersistentPrefs();
 
   int default_image_id = kDefaultImagesCount;
   if (!IsDefaultImagePath(image_path_string, &default_image_id)) {
     FilePath image_path(image_path_string);
     BrowserThread::PostTask(
         BrowserThread::FILE,
         FROM_HERE,
-        NewRunnableFunction(&DeleteUserImage,
-                            image_path));
+        base::Bind(&DeleteUserImage, image_path));
   }
 }
 
 bool UserManager::IsKnownUser(const std::string& email) {
   std::vector<User> users = GetUsers();
   for (std::vector<User>::iterator it = users.begin();
        it < users.end();
        ++it) {
     if (it->email() == email)
       return true;
@@ skipping 32 matching lines @@
 
 void UserManager::SaveUserImage(const std::string& username,
                                 const SkBitmap& image) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   FilePath image_path = GetImagePathForUser(username);
   DVLOG(1) << "Saving user image to " << image_path.value();
 
   BrowserThread::PostTask(
       BrowserThread::FILE,
       FROM_HERE,
-      NewRunnableFunction(&SaveImageToFile,
-                          image, image_path, username));
+      base::Bind(&SaveImageToFile,
+                 image, image_path, username));
 }
 
 void UserManager::SaveUserOAuthStatus(const std::string& username,
                                       OAuthTokenStatus oauth_token_status) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   SaveOAuthTokenStatusToLocalState(username, oauth_token_status);
 }
 
 UserManager::OAuthTokenStatus UserManager::GetUserOAuthStatus(
     const std::string& username) {
@@ skipping 126 matching lines @@
   // Only load the Opencryptoki library into NSS if we have this switch.
   // TODO(gspencer): Remove this switch once cryptohomed work is finished:
   // http://crosbug.com/12295 and http://crosbug.com/12304
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kLoadOpencryptoki)) {
     crypto::EnableTPMTokenForNSS(new RealTPMTokenInfoDelegate());
   }
 
   // Schedules current user ownership check on file thread.
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
-      NewRunnableFunction(&CheckOwnership));
+      base::Bind(&CheckOwnership));
 }
 
 void UserManager::Observe(int type,
                           const NotificationSource& source,
                           const NotificationDetails& details) {
   if (type == chrome::NOTIFICATION_OWNER_KEY_FETCH_ATTEMPT_SUCCEEDED) {
     BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
-        NewRunnableFunction(&CheckOwnership));
+        base::Bind(&CheckOwnership));
   }
 }
 
 bool UserManager::current_user_is_owner() const {
   base::AutoLock lk(current_user_is_owner_lock_);
   return current_user_is_owner_;
 }
 
 void UserManager::set_current_user_is_owner(bool current_user_is_owner) {
   base::AutoLock lk(current_user_is_owner_lock_);
   current_user_is_owner_ = current_user_is_owner;
 }
 
 void UserManager::AddObserver(Observer* obs) {
   observer_list_.AddObserver(obs);
 }
 
 void UserManager::RemoveObserver(Observer* obs) {
   observer_list_.RemoveObserver(obs);
 }
 
 void UserManager::NotifyLocalStateChanged() {
  FOR_EACH_OBSERVER(
     Observer,
     observer_list_,
     LocalStateChanged(this));
 }
 
 }  // namespace chromeos