Rename TaskRunner::RunsTasksOnCurrentThread() in //dbus, //chromeos, //ppapi

chromeos/login/auth/cryptohome_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 "chromeos/login/auth/cryptohome_authenticator.h"
 
 #include <stdint.h>
 
 #include <vector>
 
@@ skipping 532 matching lines @@
                                             false));  // user_is_new
   remove_user_data_on_failure_ = false;
   check_key_attempted_ = true;
   SystemSaltGetter::Get()->GetSystemSalt(
       base::Bind(&CheckKey, current_state_->AsWeakPtr(),
                  scoped_refptr<CryptohomeAuthenticator>(this)));
 }
 
 void CryptohomeAuthenticator::LoginAsSupervisedUser(
     const UserContext& user_context) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   DCHECK_EQ(user_manager::USER_TYPE_SUPERVISED, user_context.GetUserType());
 
   // TODO(nkostylev): Pass proper value for |user_is_new| or remove (not used).
   current_state_.reset(new AuthAttemptState(user_context,
                                             false,    // unlock
                                             false,    // online_complete
                                             false));  // user_is_new
   remove_user_data_on_failure_ = false;
   StartMount(current_state_->AsWeakPtr(),
              scoped_refptr<CryptohomeAuthenticator>(this),
              false /* ephemeral */, false /* create_if_nonexistent */);
 }
 
 void CryptohomeAuthenticator::LoginOffTheRecord() {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   current_state_.reset(
       new AuthAttemptState(UserContext(user_manager::USER_TYPE_GUEST,
                                        user_manager::GuestAccountId()),
                            false,    // unlock
                            false,    // online_complete
                            false));  // user_is_new
   remove_user_data_on_failure_ = false;
   ephemeral_mount_attempted_ = true;
   MountGuestAndGetHash(current_state_->AsWeakPtr(),
                        scoped_refptr<CryptohomeAuthenticator>(this));
 }
 
 void CryptohomeAuthenticator::LoginAsPublicSession(
     const UserContext& user_context) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   DCHECK_EQ(user_manager::USER_TYPE_PUBLIC_ACCOUNT, user_context.GetUserType());
 
   current_state_.reset(
       new AuthAttemptState(user_context,
                            false,    // unlock
                            false,    // online_complete
                            false));  // user_is_new
   remove_user_data_on_failure_ = false;
   ephemeral_mount_attempted_ = true;
   StartMount(current_state_->AsWeakPtr(),
              scoped_refptr<CryptohomeAuthenticator>(this), true /* ephemeral */,
              true /* create_if_nonexistent */);
 }
 
 void CryptohomeAuthenticator::LoginAsKioskAccount(
     const AccountId& app_account_id,
     bool use_guest_mount) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
 
   const AccountId& account_id =
       use_guest_mount ? user_manager::GuestAccountId() : app_account_id;
   current_state_.reset(new AuthAttemptState(
       UserContext(user_manager::USER_TYPE_KIOSK_APP, account_id),
       false,    // unlock
       false,    // online_complete
       false));  // user_is_new
 
   remove_user_data_on_failure_ = true;
   if (!use_guest_mount) {
     MountPublic(current_state_->AsWeakPtr(),
                 scoped_refptr<CryptohomeAuthenticator>(this),
                 cryptohome::CREATE_IF_MISSING);
   } else {
     ephemeral_mount_attempted_ = true;
     MountGuestAndGetHash(current_state_->AsWeakPtr(),
                          scoped_refptr<CryptohomeAuthenticator>(this));
   }
 }
 
 void CryptohomeAuthenticator::LoginAsArcKioskAccount(
     const AccountId& app_account_id) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
 
   current_state_.reset(new AuthAttemptState(
       UserContext(user_manager::USER_TYPE_ARC_KIOSK_APP, app_account_id),
       false,    // unlock
       false,    // online_complete
       false));  // user_is_new
 
   remove_user_data_on_failure_ = true;
   MountPublic(current_state_->AsWeakPtr(),
               scoped_refptr<CryptohomeAuthenticator>(this),
               cryptohome::CREATE_IF_MISSING);
 }
 
 void CryptohomeAuthenticator::OnAuthSuccess() {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   VLOG(1) << "Login success";
   // Send notification of success
   chromeos::LoginEventRecorder::Get()->RecordAuthenticationSuccess();
   {
     base::AutoLock for_this_block(success_lock_);
     already_reported_success_ = true;
   }
   if (consumer_)
     consumer_->OnAuthSuccess(current_state_->user_context);
 }
 
 void CryptohomeAuthenticator::OnOffTheRecordAuthSuccess() {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   chromeos::LoginEventRecorder::Get()->RecordAuthenticationSuccess();
   if (consumer_)
     consumer_->OnOffTheRecordAuthSuccess();
 }
 
 void CryptohomeAuthenticator::OnPasswordChangeDetected() {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   if (consumer_)
     consumer_->OnPasswordChangeDetected();
 }
 
 void CryptohomeAuthenticator::OnOldEncryptionDetected(
     bool has_incomplete_migration) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   if (consumer_) {
     consumer_->OnOldEncryptionDetected(current_state_->user_context,
                                        has_incomplete_migration);
   }
 }
 
 void CryptohomeAuthenticator::OnAuthFailure(const AuthFailure& error) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
 
   // OnAuthFailure will be called again with the same |error|
   // after the cryptohome has been removed.
   if (remove_user_data_on_failure_) {
     delayed_login_failure_ = &error;
     RemoveEncryptedData();
     return;
   }
   chromeos::LoginEventRecorder::Get()->RecordAuthenticationFailure();
   LOGIN_LOG(ERROR) << "Login failed: " << error.GetErrorString();
@@ skipping 53 matching lines @@
 void CryptohomeAuthenticator::OnUnmount(DBusMethodCallStatus call_status,
                                         bool success) {
   if (call_status != DBUS_METHOD_CALL_SUCCESS || !success) {
     // Maybe we should reboot immediately here?
     LOGIN_LOG(ERROR) << "Couldn't unmount users home!";
   }
   OnAuthFailure(AuthFailure(AuthFailure::OWNER_REQUIRED));
 }
 
 void CryptohomeAuthenticator::Resolve() {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   bool create_if_nonexistent = false;
   CryptohomeAuthenticator::AuthState state = ResolveState();
   VLOG(1) << "Resolved state to: " << state;
   switch (state) {
     case CONTINUE:
     case POSSIBLE_PW_CHANGE:
     case NO_MOUNT:
       // These are intermediate states; we need more info from a request that
       // is still pending.
       break;
@@ skipping 122 matching lines @@
     default:
       NOTREACHED();
       break;
   }
 }
 
 CryptohomeAuthenticator::~CryptohomeAuthenticator() {
 }
 
 CryptohomeAuthenticator::AuthState CryptohomeAuthenticator::ResolveState() {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   // If we haven't mounted the user's home dir yet or
   // haven't got sanitized username value, we can't be done.
   // We never get past here if any of these two cryptohome ops is still pending.
   // This is an important invariant.
   if (!current_state_->cryptohome_complete() ||
       !current_state_->username_hash_obtained()) {
     return CONTINUE;
   }
 
   AuthState state = CONTINUE;
@@ skipping 25 matching lines @@
       return ResolveOnlineSuccessState(state);
     }
     NOTREACHED() << "Using obsolete ClientLogin code path.";
   }
   // if online isn't complete yet, just return the offline result.
   return state;
 }
 
 CryptohomeAuthenticator::AuthState
 CryptohomeAuthenticator::ResolveCryptohomeFailureState() {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   if (remove_attempted_ || resync_attempted_)
     return FAILED_REMOVE;
   if (ephemeral_mount_attempted_)
     return FAILED_TMPFS;
   if (migrate_attempted_)
     return NEED_OLD_PW;
   if (check_key_attempted_)
     return LOGIN_FAILED;
 
   if (current_state_->cryptohome_code() ==
@@ skipping 31 matching lines @@
   }
 
   if (!current_state_->username_hash_valid())
     return FAILED_USERNAME_HASH;
 
   return FAILED_MOUNT;
 }
 
 CryptohomeAuthenticator::AuthState
 CryptohomeAuthenticator::ResolveCryptohomeSuccessState() {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   if (resync_attempted_)
     return CREATE_NEW;
   if (remove_attempted_)
     return REMOVED_DATA_AFTER_FAILURE;
   if (migrate_attempted_)
     return RECOVER_MOUNT;
   if (check_key_attempted_)
     return UNLOCK;
 
   const user_manager::UserType user_type =
       current_state_->user_context.GetUserType();
   if (user_type == user_manager::USER_TYPE_GUEST)
     return GUEST_LOGIN;
   if (user_type == user_manager::USER_TYPE_PUBLIC_ACCOUNT)
     return PUBLIC_ACCOUNT_LOGIN;
   if (user_type == user_manager::USER_TYPE_KIOSK_APP)
     return KIOSK_ACCOUNT_LOGIN;
   if (user_type == user_manager::USER_TYPE_SUPERVISED)
     return SUPERVISED_USER_LOGIN;
 
   if (!VerifyOwner())
     return CONTINUE;
   return user_can_login_ ? OFFLINE_LOGIN : OWNER_REQUIRED;
 }
 
 CryptohomeAuthenticator::AuthState
 CryptohomeAuthenticator::ResolveOnlineSuccessState(
     CryptohomeAuthenticator::AuthState offline_state) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   switch (offline_state) {
     case POSSIBLE_PW_CHANGE:
       return NEED_OLD_PW;
     case NO_MOUNT:
       return CREATE_NEW;
     case OFFLINE_LOGIN:
       return ONLINE_LOGIN;
     default:
       NOTREACHED();
       return offline_state;
   }
 }
 
 void CryptohomeAuthenticator::ResolveLoginCompletionStatus() {
   // Shortcut online state resolution process.
   current_state_->RecordOnlineLoginStatus(AuthFailure::AuthFailureNone());
   Resolve();
 }
 
 void CryptohomeAuthenticator::SetOwnerState(bool owner_check_finished,
                                             bool check_result) {
   owner_is_verified_ = owner_check_finished;
   user_can_login_ = check_result;
 }
 
 }  // namespace chromeos