Switch from SignedSettings to DeviceSettingsService.

chrome/browser/chromeos/login/user_manager_impl.cc

 // Copyright (c) 2012 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_impl.h"
 
 #include <vector>
 
+#include "ash/desktop_background/desktop_background_controller.h"
 #include "ash/shell.h"
-#include "ash/desktop_background/desktop_background_controller.h"
 #include "base/bind.h"
 #include "base/chromeos/chromeos_version.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.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/cert_library.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros_settings.h"
 #include "chrome/browser/chromeos/cryptohome/async_method_caller.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/helper.h"
 #include "chrome/browser/chromeos/login/login_display.h"
-#include "chrome/browser/chromeos/login/ownership_service.h"
 #include "chrome/browser/chromeos/login/remove_user_delegate.h"
 #include "chrome/browser/chromeos/login/user_image.h"
 #include "chrome/browser/chromeos/login/wizard_controller.h"
 #include "chrome/browser/policy/browser_policy_connector.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/profiles/profile_downloader.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
@@ skipping 169 matching lines @@
           ash::GetInvalidWallpaperIndex())),
       ephemeral_users_enabled_(false),
       observed_sync_service_(NULL),
       last_image_set_async_(false),
       downloaded_profile_image_data_url_(chrome::kAboutBlankURL),
       downloading_profile_image_(false) {
   // UserManager instance should be used only on UI thread.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   MigrateWallpaperData();
-  registrar_.Add(this, chrome::NOTIFICATION_OWNER_KEY_FETCH_ATTEMPT_SUCCEEDED,
+  registrar_.Add(this, chrome::NOTIFICATION_OWNERSHIP_STATUS_CHANGED,
       content::NotificationService::AllSources());
   registrar_.Add(this, chrome::NOTIFICATION_PROFILE_ADDED,
       content::NotificationService::AllSources());
   RetrieveTrustedDevicePolicies();
 }
 
 UserManagerImpl::~UserManagerImpl() {
   // Can't use STLDeleteElements because of the private destructor of User.
-  for (size_t i = 0; i < users_.size();++i)
+  for (size_t i = 0; i < users_.size(); ++i)
     delete users_[i];
   users_.clear();
   if (is_current_user_ephemeral_)
     delete logged_in_user_;
 }
 
 const UserList& UserManagerImpl::GetUsers() const {
   const_cast<UserManagerImpl*>(this)->EnsureUsersLoaded();
   return users_;
 }
@@ skipping 422 matching lines @@
 }
 
 void UserManagerImpl::DownloadProfileImage(const std::string& reason) {
   DownloadProfileData(reason, true);
 }
 
 void UserManagerImpl::Observe(int type,
                               const content::NotificationSource& source,
                               const content::NotificationDetails& details) {
   switch (type) {
-    case chrome::NOTIFICATION_OWNER_KEY_FETCH_ATTEMPT_SUCCEEDED:
-      BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
-                              base::Bind(&UserManagerImpl::CheckOwnership,
-                                         base::Unretained(this)));
-      BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-          base::Bind(&UserManagerImpl::RetrieveTrustedDevicePolicies,
-          base::Unretained(this)));
+    case chrome::NOTIFICATION_OWNERSHIP_STATUS_CHANGED:
+      CheckOwnership();
+      RetrieveTrustedDevicePolicies();
       break;
     case chrome::NOTIFICATION_PROFILE_ADDED:
       if (IsUserLoggedIn() && !IsLoggedInAsGuest()) {
         Profile* profile = content::Source<Profile>(source).ptr();
         if (!profile->IsOffTheRecord() &&
             profile == ProfileManager::GetDefaultProfile()) {
           DCHECK(NULL == observed_sync_service_);
           observed_sync_service_ =
               ProfileSyncServiceFactory::GetForProfile(profile);
           if (observed_sync_service_)
             observed_sync_service_->AddObserver(this);
         }
       }
       break;
     default:
       NOTREACHED();
   }
 }
 
 void UserManagerImpl::OnStateChanged() {
   DCHECK(IsUserLoggedIn() && !IsLoggedInAsGuest());
   AuthError::State state = observed_sync_service_->GetAuthError().state();
   if (state != AuthError::NONE &&
       state != AuthError::CONNECTION_FAILED &&
       state != AuthError::SERVICE_UNAVAILABLE &&
       state != AuthError::REQUEST_CANCELED) {
-      // Invalidate OAuth token to force Gaia sign-in flow. This is needed
-      // because sign-out/sign-in solution is suggested to the user.
-      // TODO(altimofeev): this code isn't needed after crosbug.com/25978 is
-      // implemented.
-      DVLOG(1) << "Invalidate OAuth token because of a sync error.";
-      SaveUserOAuthStatus(GetLoggedInUser().email(),
-                          User::OAUTH_TOKEN_STATUS_INVALID);
+    // Invalidate OAuth token to force Gaia sign-in flow. This is needed
+    // because sign-out/sign-in solution is suggested to the user.
+    // TODO(altimofeev): this code isn't needed after crosbug.com/25978 is
+    // implemented.
+    DVLOG(1) << "Invalidate OAuth token because of a sync error.";
+    SaveUserOAuthStatus(GetLoggedInUser().email(),
+                        User::OAUTH_TOKEN_STATUS_INVALID);
   }
 }
 
 bool UserManagerImpl::IsCurrentUserOwner() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   base::AutoLock lk(is_current_user_owner_lock_);
   return is_current_user_owner_;
 }
 
 void UserManagerImpl::SetCurrentUserIsOwner(bool is_current_user_owner) {
@@ skipping 30 matching lines @@
 bool UserManagerImpl::IsLoggedInAsStub() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return IsUserLoggedIn() && logged_in_user_->email() == kStubUser;
 }
 
 bool UserManagerImpl::IsSessionStarted() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return session_started_;
 }
 
-void UserManagerImpl::AddObserver(Observer* obs) {
+void UserManagerImpl::AddObserver(UserManager::Observer* obs) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   observer_list_.AddObserver(obs);
 }
 
-void UserManagerImpl::RemoveObserver(Observer* obs) {
+void UserManagerImpl::RemoveObserver(UserManager::Observer* obs) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   observer_list_.RemoveObserver(obs);
 }
 
 const SkBitmap& UserManagerImpl::DownloadedProfileImage() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return downloaded_profile_image_;
 }
 
 void UserManagerImpl::NotifyLocalStateChanged() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  FOR_EACH_OBSERVER(
-    Observer,
-    observer_list_,
-    LocalStateChanged(this));
+  FOR_EACH_OBSERVER(UserManager::Observer, observer_list_,
+                    LocalStateChanged(this));
 }
 
 FilePath UserManagerImpl::GetImagePathForUser(const std::string& username) {
   std::string filename = username + ".png";
   FilePath user_data_dir;
   PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
   return user_data_dir.AppendASCII(filename);
 }
 
 FilePath UserManagerImpl::GetWallpaperPathForUser(const std::string& username,
@@ skipping 201 matching lines @@
 
 void UserManagerImpl::NotifyOnLogin() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_LOGIN_USER_CHANGED,
       content::Source<UserManagerImpl>(this),
       content::Details<const User>(logged_in_user_));
 
   CrosLibrary::Get()->GetCertLibrary()->LoadKeyStore();
 
-  // Schedules current user ownership check on file thread.
-  BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
-                          base::Bind(&UserManagerImpl::CheckOwnership,
-                                     base::Unretained(this)));
+  // Indicate to DeviceSettingsService that the owner key may have become
+  // available.
+  DeviceSettingsService::Get()->SetUsername(logged_in_user_->email());
 }
 
 void UserManagerImpl::SetInitialUserImage(const std::string& username) {
   // Choose a random default image.
   int image_id = base::RandInt(0, kDefaultImagesCount - 1);
   SaveUserDefaultImageIndex(username, image_id);
 }
 
 void UserManagerImpl::SetInitialUserWallpaper(const std::string& username) {
   current_user_wallpaper_type_ = User::DEFAULT;
@@ skipping 439 matching lines @@
 }
 
 void UserManagerImpl::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;
   }
 }
 
-void UserManagerImpl::UpdateOwnership(bool is_owner) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+void UserManagerImpl::UpdateOwnership(
+    DeviceSettingsService::OwnershipStatus status,
+    bool is_owner) {
+  VLOG(1) << "Current user " << (is_owner ? "is owner" : "is not owner");
 
   SetCurrentUserIsOwner(is_owner);
-  content::NotificationService::current()->Notify(
-      chrome::NOTIFICATION_OWNERSHIP_CHECKED,
-      content::NotificationService::AllSources(),
-      content::NotificationService::NoDetails());
-  if (is_owner) {
-    // Also update cached value.
-    CrosSettings::Get()->SetString(kDeviceOwner, GetLoggedInUser().email());
-  }
 }
 
 void UserManagerImpl::CheckOwnership() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  bool is_owner = OwnershipService::GetSharedInstance()->IsCurrentUserOwner();
-  VLOG(1) << "Current user " << (is_owner ? "is owner" : "is not owner");
-
-  // UserManagerImpl should be accessed only on UI thread.
-  BrowserThread::PostTask(
-      BrowserThread::UI,
-      FROM_HERE,
+  DeviceSettingsService::Get()->GetOwnershipStatusAsync(
       base::Bind(&UserManagerImpl::UpdateOwnership,
-                 base::Unretained(this),
-                 is_owner));
+                 base::Unretained(this)));
 }
 
 // ProfileDownloaderDelegate override.
 bool UserManagerImpl::NeedsProfilePicture() const {
   return downloading_profile_image_;
 }
 
 // ProfileDownloaderDelegate override.
 int UserManagerImpl::GetDesiredImageSideLength() const {
   return GetCurrentUserImageSize();
@@ skipping 179 matching lines @@
     BrowserThread::PostTask(
         BrowserThread::FILE,
         FROM_HERE,
         base::Bind(&UserManagerImpl::DeleteUserImage,
                    base::Unretained(this),
                    image_path));
   }
 }
 
 }  // namespace chromeos