Various supervised user password fixes - 2

chrome/browser/chromeos/login/managed/managed_user_creation_controller_new.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/managed/managed_user_creation_controller_new.h"
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
@@ skipping 118 matching lines @@
   creation_context_->signature_key = signature_key;
   creation_context_->encryption_key = encryption_key;
 
   creation_context_->password_data.MergeDictionary(password_data);
 
   StartCreationImpl();
 }
 
 void ManagedUserCreationControllerNew::StartCreationImpl() {
   DCHECK(creation_context_);
-  DCHECK(stage_ == STAGE_INITIAL);
+  DCHECK_EQ(STAGE_INITIAL, stage_);
   VLOG(1) << "Starting supervised user creation";
   VLOG(1) << " Phase 1 : Prepare keys";
 
   SupervisedUserManager* manager =
       UserManager::Get()->GetSupervisedUserManager();
   manager->StartCreationTransaction(creation_context_->display_name);
 
   creation_context_->local_user_id = manager->GenerateUserId();
   if (creation_context_->creation_type == NEW_USER) {
     creation_context_->sync_user_id =
@@ skipping 92 matching lines @@
       NOTREACHED();
   }
   stage_ = STAGE_ERROR;
   if (consumer_)
     consumer_->OnCreationError(code);
 }
 
 void ManagedUserCreationControllerNew::OnMountSuccess(
     const std::string& mount_hash) {
   DCHECK(creation_context_);
-  DCHECK(stage_ == KEYS_GENERATED);
+  DCHECK_EQ(KEYS_GENERATED, stage_);
   VLOG(1) << " Phase 2.2 : Created home dir with master key";
 
   creation_context_->mount_hash = mount_hash;
 
   // Plain text password, hashed and salted with individual salt.
   // It can be used for mounting homedir, and can be replaced only when signed.
   cryptohome::KeyDefinition password_key(creation_context_->salted_password,
                                          kCryptohomeManagedUserKeyLabel,
                                          kCryptohomeManagedUserKeyPrivileges);
   base::Base64Decode(creation_context_->encryption_key,
@@ skipping 11 matching lines @@
   authenticator_->AddKey(
       context,
       password_key,
       true,
       base::Bind(&ManagedUserCreationControllerNew::OnAddKeySuccess,
                  weak_factory_.GetWeakPtr()));
 }
 
 void ManagedUserCreationControllerNew::OnAddKeySuccess() {
   DCHECK(creation_context_);
-  DCHECK(stage_ == KEYS_GENERATED);
+  DCHECK_EQ(KEYS_GENERATED, stage_);
   stage_ = CRYPTOHOME_CREATED;
 
   VLOG(1) << " Phase 3 : Create/update user on chrome.com/manage";
 
   ProfileSyncService* sync_service =
       ProfileSyncServiceFactory::GetInstance()->GetForProfile(
           creation_context_->manager_profile);
   ProfileSyncService::SyncStatusSummary status =
       sync_service->QuerySyncStatusSummary();
 
@@ skipping 17 matching lines @@
       creation_context_->sync_user_id,
       info,
       base::Bind(&ManagedUserCreationControllerNew::RegistrationCallback,
                  weak_factory_.GetWeakPtr()));
 }
 
 void ManagedUserCreationControllerNew::RegistrationCallback(
     const GoogleServiceAuthError& error,
     const std::string& token) {
   DCHECK(creation_context_);
-  DCHECK(stage_ == CRYPTOHOME_CREATED);
+  DCHECK_EQ(CRYPTOHOME_CREATED, stage_);
 
   stage_ = DASHBOARD_CREATED;
 
   if (error.state() == GoogleServiceAuthError::NONE) {
     creation_context_->token = token;
 
     PostTaskAndReplyWithResult(
         content::BrowserThread::GetBlockingPool(),
         FROM_HERE,
         base::Bind(&StoreManagedUserFiles,
                    creation_context_->token,
                    MountManager::GetHomeDir(creation_context_->mount_hash)),
         base::Bind(&ManagedUserCreationControllerNew::OnManagedUserFilesStored,
                    weak_factory_.GetWeakPtr()));
   } else {
     stage_ = STAGE_ERROR;
     LOG(ERROR) << "Managed user creation failed. Error code " << error.state();
     if (consumer_)
       consumer_->OnCreationError(CLOUD_SERVER_ERROR);
   }
 }
 
 void ManagedUserCreationControllerNew::OnManagedUserFilesStored(bool success) {
   DCHECK(creation_context_);
-  DCHECK(stage_ == DASHBOARD_CREATED);
+  DCHECK_EQ(DASHBOARD_CREATED, stage_);
 
   if (!success) {
     stage_ = STAGE_ERROR;
     if (consumer_)
       consumer_->OnCreationError(TOKEN_WRITE_FAILED);
     return;
   }
   // Assume that new token is valid. It will be automatically invalidated if
   // sync service fails to use it.
   UserManager::Get()->SaveUserOAuthStatus(creation_context_->local_user_id,
@@ skipping 26 matching lines @@
   creation_context_->registration_utility.reset();
   chrome::AttemptUserExit();
 }
 
 std::string ManagedUserCreationControllerNew::GetManagedUserId() {
   DCHECK(creation_context_);
   return creation_context_->local_user_id;
 }
 
 }  // namespace chromeos