Comb up ownership things.

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/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
+#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/nss_util.h"
 #include "base/path_service.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 "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
@@ skipping 37 matching lines @@
 
 // Resource IDs of default user images.
 const int kDefaultImageResources[] = {
   IDR_LOGIN_DEFAULT_USER,
   IDR_LOGIN_DEFAULT_USER_1,
   IDR_LOGIN_DEFAULT_USER_2,
   IDR_LOGIN_DEFAULT_USER_3,
   IDR_LOGIN_DEFAULT_USER_4
 };
 
-// The one true UserManager.
-static UserManager* user_manager_ = NULL;
+base::LazyInstance<UserManager> g_user_manager(base::LINKER_INITIALIZED);
 
 // Stores path to the image in local state. Runs on UI thread.
 void SavePathToLocalState(const std::string& username,
                           const std::string& image_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   PrefService* local_state = g_browser_process->local_state();
   DictionaryValue* images =
       local_state->GetMutableDictionary(kUserImages);
   images->SetWithoutPathExpansion(username, new StringValue(image_path));
   DVLOG(1) << "Saving path to user image in Local State.";
@@ skipping 46 matching lines @@
       return true;
     }
   }
   return false;
 }
 
 // Updates current user ownership on UI thread.
 void UpdateOwnership(bool is_owner) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  UserManager* user_manager = UserManager::Get();
-  user_manager->set_current_user_is_owner(is_owner);
-
+  g_user_manager.Get().set_current_user_is_owner(is_owner);
+  NotificationService::current()->Notify(NotificationType::OWNERSHIP_CHECKED,
+                                         NotificationService::AllSources(),
+                                         NotificationService::NoDetails());
   if (is_owner) {
     // Also update cached value.
     UserCrosSettingsProvider::UpdateCachedOwner(
-      user_manager->logged_in_user().email());
+      g_user_manager.Get().logged_in_user().email());
   }
 }
 
 // Checks current user's ownership on file thread.
 void CheckOwnership() {
   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));
 }
 
 // Used to handle the asynchronous response of deleting a cryptohome directory.
 class RemoveAttempt : public CryptohomeLibrary::Delegate {
  public:
@@ skipping 90 matching lines @@
                                          user_email.length() - domain_start);
   return base::StringPrintf("%s (%s)",
                             GetDisplayName().c_str(),
                             domain.c_str());
 }
 
 // static
 UserManager* UserManager::Get() {
   // Not thread-safe.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (!user_manager_)
-    user_manager_ = new UserManager();
-  return user_manager_;
+  return &g_user_manager.Get();
 }
 
 // static
 void UserManager::RegisterPrefs(PrefService* local_state) {
   local_state->RegisterListPref(kLoggedInUsers);
   local_state->RegisterDictionaryPref(kUserImages);
 }
 
 std::vector<UserManager::User> UserManager::GetUsers() const {
   std::vector<User> users;
@@ skipping 295 matching lines @@
 void UserManager::Observe(NotificationType type,
                           const NotificationSource& source,
                           const NotificationDetails& details) {
   if (type == NotificationType::OWNER_KEY_FETCH_ATTEMPT_SUCCEEDED) {
     BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
         NewRunnableFunction(&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;
 }
 
 }  // namespace chromeos