Revert 154457 - Switch from SignedSettings to DeviceSettingsService.

chrome/browser/chromeos/login/existing_user_controller.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/existing_user_controller.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 211 matching lines @@
   if (type == chrome::NOTIFICATION_SESSION_STARTED) {
     // Stop listening to any notification once session has started.
     // Sign in screen objects are marked for deletion with DeleteSoon so
     // make sure no object would be used after session has started.
     // http://crbug.com/125276
     registrar_.RemoveAll();
     return;
   }
   if (type == chrome::NOTIFICATION_SYSTEM_SETTING_CHANGED ||
       type == chrome::NOTIFICATION_POLICY_USER_LIST_CHANGED) {
-    if (host_ != NULL) {
-      // Signed settings or user list changed. Notify views and update them.
-      UpdateLoginDisplay(chromeos::UserManager::Get()->GetUsers());
-      return;
-    }
+    // Signed settings or user list changed. Notify views and update them.
+    const chromeos::UserList& users = chromeos::UserManager::Get()->GetUsers();
+    UpdateLoginDisplay(users);
+    return;
   }
   if (type == chrome::NOTIFICATION_AUTH_SUPPLIED) {
     // Possibly the user has authenticated against a proxy server and we might
     // need the credentials for enrollment and other system requests from the
     // main |g_browser_process| request context (see bug
     // http://crosbug.com/24861). So we transfer any credentials to the global
     // request context here.
     // The issue we have here is that the NOTIFICATION_AUTH_SUPPLIED is sent
     // just after the UI is closed but before the new credentials were stored
     // in the profile. Therefore we have to give it some time to make sure it
@@ skipping 86 matching lines @@
     ShowEnrollmentScreen(true, username);
   } else {
     CompleteLoginInternal(username, password);
   }
 }
 
 void ExistingUserController::CompleteLoginInternal(std::string username,
                                                    std::string password) {
   resume_login_callback_.Reset();
 
-  DeviceSettingsService::Get()->GetOwnershipStatusAsync(
-      base::Bind(&ExistingUserController::PerformLogin,
-                 weak_factory_.GetWeakPtr(), username, password,
-                 LoginPerformer::AUTH_MODE_EXTENSION));
+  if (!login_performer_.get()) {
+    LoginPerformer::Delegate* delegate = this;
+    if (login_performer_delegate_.get())
+      delegate = login_performer_delegate_.get();
+    // Only one instance of LoginPerformer should exist at a time.
+    login_performer_.reset(new LoginPerformer(delegate));
+  }
+
+  // If the device is not owned yet, successfully logged in user will be owner.
+  is_owner_login_ = OwnershipService::GetSharedInstance()->GetStatus(true) ==
+      OwnershipService::OWNERSHIP_NONE;
+
+  is_login_in_progress_ = true;
+  login_performer_->CompleteLogin(username, password);
+  accessibility::MaybeSpeak(
+      l10n_util::GetStringUTF8(IDS_CHROMEOS_ACC_LOGIN_SIGNING_IN));
 }
 
 void ExistingUserController::Login(const std::string& username,
                                    const std::string& password) {
   if (username.empty() || password.empty())
     return;
   // Disable clicking on other windows.
   login_display_->SetUIEnabled(false);
 
+  // If the device is not owned yet, successfully logged in user will be owner.
+  is_owner_login_ = OwnershipService::GetSharedInstance()->GetStatus(true) ==
+      OwnershipService::OWNERSHIP_NONE;
+
   BootTimesLoader::Get()->RecordLoginAttempted();
 
   if (last_login_attempt_username_ != username) {
     last_login_attempt_username_ = username;
     num_login_attempts_ = 0;
     // Also reset state variables, which are used to determine password change.
     offline_failed_ = false;
     online_succeeded_for_.clear();
   }
   num_login_attempts_++;
 
-  DeviceSettingsService::Get()->GetOwnershipStatusAsync(
-      base::Bind(&ExistingUserController::PerformLogin,
-                 weak_factory_.GetWeakPtr(), username, password,
-                 LoginPerformer::AUTH_MODE_INTERNAL));
-}
-
-void ExistingUserController::PerformLogin(
-    const std::string& username,
-    const std::string& password,
-    LoginPerformer::AuthorizationMode auth_mode,
-    DeviceSettingsService::OwnershipStatus ownership_status,
-    bool is_owner) {
-  // If the device is not owned yet, successfully logged in user will be owner.
-  is_owner_login_ = ownership_status == DeviceSettingsService::OWNERSHIP_NONE;
-
   // Use the same LoginPerformer for subsequent login as it has state
   // such as Authenticator instance.
   if (!login_performer_.get() || num_login_attempts_ <= 1) {
     LoginPerformer::Delegate* delegate = this;
     if (login_performer_delegate_.get())
       delegate = login_performer_delegate_.get();
     // Only one instance of LoginPerformer should exist at a time.
     login_performer_.reset(NULL);
     login_performer_.reset(new LoginPerformer(delegate));
   }
-
   is_login_in_progress_ = true;
-  login_performer_->PerformLogin(username, password, auth_mode);
+  login_performer_->Login(username, password);
   accessibility::MaybeSpeak(
       l10n_util::GetStringUTF8(IDS_CHROMEOS_ACC_LOGIN_SIGNING_IN));
 }
 
 void ExistingUserController::LoginAsDemoUser() {
   // Disable clicking on other windows.
   login_display_->SetUIEnabled(false);
   // TODO(rkc): Add a CHECK to make sure demo logins are allowed once
   // the enterprise policy wiring is done for kiosk mode.
 
@@ skipping 54 matching lines @@
 void ExistingUserController::Signout() {
   NOTREACHED();
 }
 
 void ExistingUserController::OnUserSelected(const std::string& username) {
   login_performer_.reset(NULL);
   num_login_attempts_ = 0;
 }
 
 void ExistingUserController::OnStartEnterpriseEnrollment() {
-  DeviceSettingsService::Get()->GetOwnershipStatusAsync(
+  OwnershipService::GetSharedInstance()->GetStatusAsync(
       base::Bind(&ExistingUserController::OnEnrollmentOwnershipCheckCompleted,
                  weak_factory_.GetWeakPtr()));
 }
 
 void ExistingUserController::OnEnrollmentOwnershipCheckCompleted(
-    DeviceSettingsService::OwnershipStatus status,
+    OwnershipService::Status status,
     bool current_user_is_owner) {
-  if (status == DeviceSettingsService::OWNERSHIP_NONE) {
+  if (status == OwnershipService::OWNERSHIP_NONE) {
     ShowEnrollmentScreen(false, std::string());
-  } else if (status == DeviceSettingsService::OWNERSHIP_TAKEN) {
+  } else if (status == OwnershipService::OWNERSHIP_TAKEN) {
     // On a device that is already owned we might want to allow users to
     // re-enroll if the policy information is invalid.
     CrosSettingsProvider::TrustedStatus trusted_status =
         CrosSettings::Get()->PrepareTrustedValues(
             base::Bind(
                 &ExistingUserController::OnEnrollmentOwnershipCheckCompleted,
                 weak_factory_.GetWeakPtr(), status, current_user_is_owner));
     if (trusted_status == CrosSettingsProvider::PERMANENTLY_UNTRUSTED)
       ShowEnrollmentScreen(false, std::string());
   } else {
@@ skipping 432 matching lines @@
   // Invalidate OAuth token, since it can't be correct after password is
   // changed.
   UserManager::Get()->SaveUserOAuthStatus(username,
                                           User::OAUTH_TOKEN_STATUS_INVALID);
 
   login_display_->SetUIEnabled(true);
   login_display_->ShowGaiaPasswordChanged(username);
 }
 
 }  // namespace chromeos