Tame the proliferation of UserContext constructors

chrome/browser/chromeos/login/auth/parallel_authenticator.cc

 // Copyright 2014 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/auth/parallel_authenticator.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/boot_times_loader.h"
 #include "chrome/browser/chromeos/login/auth/authentication_notification_details.h"
 #include "chrome/browser/chromeos/login/auth/login_status_consumer.h"
 #include "chrome/browser/chromeos/login/users/user.h"
 #include "chrome/browser/chromeos/login/users/user_manager.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/common/chrome_switches.h"
 #include "chromeos/cryptohome/async_method_caller.h"
 #include "chromeos/cryptohome/system_salt_getter.h"
 #include "chromeos/dbus/cryptohome_client.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/login/login_state.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "crypto/sha2.h"
-#include "google_apis/gaia/gaia_auth_util.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 using content::BrowserThread;
 
 namespace chromeos {
 
 namespace {
 
 // Length of password hashed with SHA-256.
 const int kPasswordHashLength = 32;
@@ skipping 179 matching lines @@
       already_reported_success_(false),
       owner_is_verified_(false),
       user_can_login_(false),
       remove_user_data_on_failure_(false),
       delayed_login_failure_(NULL) {
 }
 
 void ParallelAuthenticator::AuthenticateToLogin(
     Profile* profile,
     const UserContext& user_context) {
-  std::string canonicalized = gaia::CanonicalizeEmail(user_context.GetUserID());
   authentication_profile_ = profile;
-  current_state_.reset(
-      new AuthAttemptState(
-          UserContext(canonicalized,
-                      user_context.GetPassword(),
-                      user_context.GetAuthCode()),
-          std::string(), // login_token, not used.
-          std::string(), // login_captcha, not used.
-          User::USER_TYPE_REGULAR,
-          !UserManager::Get()->IsKnownUser(canonicalized)));
+  current_state_.reset(new AuthAttemptState(
+      user_context,
+      User::USER_TYPE_REGULAR,
+      false,  // unlock
+      false,  // online_complete
+      !UserManager::Get()->IsKnownUser(user_context.GetUserID())));
   // Reset the verified flag.
   owner_is_verified_ = false;
 
   SystemSaltGetter::Get()->GetSystemSalt(
       base::Bind(&Mount,
                  current_state_.get(),
                  scoped_refptr<ParallelAuthenticator>(this),
                  cryptohome::MOUNT_FLAGS_NONE));
 }
 
 void ParallelAuthenticator::CompleteLogin(Profile* profile,
                                           const UserContext& user_context) {
-  std::string canonicalized = gaia::CanonicalizeEmail(user_context.GetUserID());
   authentication_profile_ = profile;
-  current_state_.reset(
-      new AuthAttemptState(
-          UserContext(canonicalized,
-                      user_context.GetPassword(),
-                      user_context.GetAuthCode(),
-                      user_context.GetUserIDHash(),
-                      user_context.IsUsingOAuth(),
-                      user_context.GetAuthFlow()),
-          !UserManager::Get()->IsKnownUser(canonicalized)));
+  current_state_.reset(new AuthAttemptState(
+      user_context,
+      User::USER_TYPE_REGULAR,
+      true,   // unlock
+      false,  // online_complete
+      !UserManager::Get()->IsKnownUser(user_context.GetUserID())));
 
   // Reset the verified flag.
   owner_is_verified_ = false;
 
   SystemSaltGetter::Get()->GetSystemSalt(
       base::Bind(&Mount,
                  current_state_.get(),
                  scoped_refptr<ParallelAuthenticator>(this),
                  cryptohome::MOUNT_FLAGS_NONE));
 
   // For login completion from extension, we just need to resolve the current
   // auth attempt state, the rest of OAuth related tasks will be done in
   // parallel.
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&ParallelAuthenticator::ResolveLoginCompletionStatus, this));
 }
 
 void ParallelAuthenticator::AuthenticateToUnlock(
     const UserContext& user_context) {
-  current_state_.reset(
-      new AuthAttemptState(
-          gaia::CanonicalizeEmail(user_context.GetUserID()),
-          user_context.GetPassword()));
+  current_state_.reset(new AuthAttemptState(user_context,
+                                            User::USER_TYPE_REGULAR,
+                                            true,     // unlock
+                                            true,     // online_complete
+                                            false));  // user_is_new
   remove_user_data_on_failure_ = false;
   check_key_attempted_ = true;
   SystemSaltGetter::Get()->GetSystemSalt(
       base::Bind(&CheckKey,
                  current_state_.get(),
                  scoped_refptr<ParallelAuthenticator>(this)));
 }
 
 void ParallelAuthenticator::LoginAsLocallyManagedUser(
     const UserContext& user_context) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // TODO(nkostylev): Pass proper value for |user_is_new| or remove (not used).
   current_state_.reset(
       new AuthAttemptState(user_context,
-                           "",   // login_token
-                           "",   // login_captcha
                            User::USER_TYPE_LOCALLY_MANAGED,
-                           false));
+                           false,    // unlock
+                           false,    // online_complete
+                           false));  // user_is_new
   remove_user_data_on_failure_ = false;
   SystemSaltGetter::Get()->GetSystemSalt(
       base::Bind(&Mount,
                  current_state_.get(),
                  scoped_refptr<ParallelAuthenticator>(this),
                  cryptohome::MOUNT_FLAGS_NONE));
 }
 
 void ParallelAuthenticator::LoginRetailMode() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Note: |kRetailModeUserEMail| is used in other places to identify a retail
   // mode session.
   current_state_.reset(new AuthAttemptState(
-        UserContext(UserManager::kRetailModeUserName,
-                    std::string(),   // password
-                    std::string()),  // auth_code
-        std::string(),  // login_token
-        std::string(),  // login_captcha
-        User::USER_TYPE_RETAIL_MODE,
-        false));
+      UserContext(UserManager::kRetailModeUserName),
+      User::USER_TYPE_RETAIL_MODE,
+      false,    // unlock
+      false,    // online_complete
+      false));  // user_is_new
   remove_user_data_on_failure_ = false;
   ephemeral_mount_attempted_ = true;
   MountGuest(current_state_.get(),
              scoped_refptr<ParallelAuthenticator>(this));
 }
 
 void ParallelAuthenticator::LoginOffTheRecord() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   current_state_.reset(new AuthAttemptState(
-      UserContext(UserManager::kGuestUserName,  // username
-                  std::string(),                // password
-                  std::string()),               // auth_code
-      std::string(),  // login_token
-      std::string(),  // login_captcha
+      UserContext(UserManager::kGuestUserName),
       User::USER_TYPE_GUEST,
-      false));
+      false,    // unlock
+      false,    // online_complete
+      false));  // user_is_new
   remove_user_data_on_failure_ = false;
   ephemeral_mount_attempted_ = true;
   MountGuest(current_state_.get(),
              scoped_refptr<ParallelAuthenticator>(this));
 }
 
 void ParallelAuthenticator::LoginAsPublicAccount(const std::string& username) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  current_state_.reset(new AuthAttemptState(
-      UserContext(username,
-                  std::string(),  // password
-                  std::string()),  // auth_code
-      std::string(),  // login_token
-      std::string(),  // login_captcha
-      User::USER_TYPE_PUBLIC_ACCOUNT,
-      false));
+  current_state_.reset(new AuthAttemptState(UserContext(username),
+                                            User::USER_TYPE_PUBLIC_ACCOUNT,
+                                            false,    // unlock
+                                            false,    // online_complete
+                                            false));  // user_is_new
   remove_user_data_on_failure_ = false;
   ephemeral_mount_attempted_ = true;
   SystemSaltGetter::Get()->GetSystemSalt(
       base::Bind(&Mount,
                  current_state_.get(),
                  scoped_refptr<ParallelAuthenticator>(this),
                  cryptohome::CREATE_IF_MISSING | cryptohome::ENSURE_EPHEMERAL));
 }
 
 void ParallelAuthenticator::LoginAsKioskAccount(
     const std::string& app_user_id,
     bool use_guest_mount) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   const std::string user_id =
       use_guest_mount ? UserManager::kGuestUserName : app_user_id;
-  current_state_.reset(new AuthAttemptState(
-      UserContext(user_id,
-                  std::string(),  // password
-                  std::string()),  // auth_code
-      std::string(),  // login_token
-      std::string(),  // login_captcha
-      User::USER_TYPE_KIOSK_APP,
-      false));
+  current_state_.reset(new AuthAttemptState(UserContext(user_id),
+                                            User::USER_TYPE_KIOSK_APP,
+                                            false,    // unlock
+                                            false,    // online_complete
+                                            false));  // user_is_new
 
   remove_user_data_on_failure_ = true;
   if (!use_guest_mount) {
     MountPublic(current_state_.get(),
           scoped_refptr<ParallelAuthenticator>(this),
           cryptohome::CREATE_IF_MISSING);
   } else {
     ephemeral_mount_attempted_ = true;
     MountGuestAndGetHash(current_state_.get(),
                          scoped_refptr<ParallelAuthenticator>(this));
@@ skipping 444 matching lines @@
   Resolve();
 }
 
 void ParallelAuthenticator::SetOwnerState(bool owner_check_finished,
                                           bool check_result) {
   owner_is_verified_ = owner_check_finished;
   user_can_login_ = check_result;
 }
 
 }  // namespace chromeos