// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/ash/crosapi/browser_data_migrator.h"
#include <string>
#include <utility>
#include "ash/constants/ash_features.h"
#include "ash/constants/ash_switches.h"
#include "base/command_line.h"
#include "base/debug/dump_without_crashing.h"
#include "base/feature_list.h"
#include "base/functional/callback_helpers.h"
#include "base/memory/scoped_refptr.h"
#include "base/path_service.h"
#include "base/task/task_traits.h"
#include "base/task/thread_pool.h"
#include "base/threading/thread_restrictions.h"
#include "base/values.h"
#include "base/version.h"
#include "chrome/browser/ash/crosapi/browser_util.h"
#include "chrome/browser/ash/crosapi/move_migrator.h"
#include "chrome/browser/ash/profiles/profile_helper.h"
#include "chrome/browser/lifetime/application_lifetime.h"
#include "chrome/common/chrome_paths.h"
#include "chromeos/ash/components/cryptohome/cryptohome_parameters.h"
#include "chromeos/ash/components/dbus/session_manager/session_manager_client.h"
#include "chromeos/ash/components/standalone_browser/migration_progress_tracker.h"
#include "chromeos/ash/components/standalone_browser/migrator_util.h"
#include "components/prefs/pref_registry_simple.h"
#include "components/prefs/pref_service.h"
#include "components/prefs/scoped_user_pref_update.h"
#include "components/user_manager/user_manager.h"
#include "components/version_info/version_info.h"
namespace ash {
namespace {
// Flag values for `switches::kForceBrowserDataMigrationForTesting`.
const char kBrowserDataMigrationForceSkip[] = "force-skip";
const char kBrowserDataMigrationForceMigration[] = "force-migration";
base::RepeatingClosure* g_attempt_restart = nullptr;
// Checks if the disk space is enough to run profile migration.
// Returns the bytes required to be freed. Specifically, on success
// returns 0.
uint64_t DiskCheck(const base::FilePath& profile_data_dir) {
using browser_data_migrator_util::GetTargetItems;
using browser_data_migrator_util::ItemType;
using browser_data_migrator_util::TargetItems;
TargetItems deletable_items =
GetTargetItems(profile_data_dir, ItemType::kDeletable);
const int64_t required_size =
browser_data_migrator_util::EstimatedExtraBytesCreated(profile_data_dir) -
deletable_items.total_size;
return browser_data_migrator_util::ExtraBytesRequiredToBeFreed(
required_size, profile_data_dir);
}
} // namespace
ScopedRestartAttemptForTesting::ScopedRestartAttemptForTesting(
base::RepeatingClosure callback) {
DCHECK(!g_attempt_restart);
g_attempt_restart = new base::RepeatingClosure(std::move(callback));
}
ScopedRestartAttemptForTesting::~ScopedRestartAttemptForTesting() {
DCHECK(g_attempt_restart);
delete g_attempt_restart;
g_attempt_restart = nullptr;
}
bool BrowserDataMigratorImpl::MaybeForceResumeMoveMigration(
PrefService* local_state,
const AccountId& account_id,
const std::string& user_id_hash,
ash::standalone_browser::migrator_util::PolicyInitState policy_init_state) {
if (!MoveMigrator::ResumeRequired(local_state, user_id_hash)) {
return false;
}
LOG(WARNING) << "Calling RestartToMigrate() to resume move migration.";
return RestartToMigrate(account_id, user_id_hash, local_state,
policy_init_state);
}
// static
void BrowserDataMigratorImpl::AttemptRestart() {
if (g_attempt_restart) {
g_attempt_restart->Run();
return;
}
chrome::AttemptRestart();
}
// static
bool BrowserDataMigratorImpl::MaybeRestartToMigrate(
const AccountId& account_id,
const std::string& user_id_hash,
ash::standalone_browser::migrator_util::PolicyInitState policy_init_state) {
if (!MaybeRestartToMigrateInternal(account_id, user_id_hash,
policy_init_state)) {
return false;
}
return RestartToMigrate(account_id, user_id_hash,
user_manager::UserManager::Get()->GetLocalState(),
policy_init_state);
}
void BrowserDataMigratorImpl::MaybeRestartToMigrateWithDiskCheck(
const AccountId& account_id,
const std::string& user_id_hash,
base::OnceCallback<void(bool, const std::optional<uint64_t>&)> callback) {
if (!MaybeRestartToMigrateInternal(account_id, user_id_hash,
ash::standalone_browser::migrator_util::
PolicyInitState::kAfterInit)) {
std::move(callback).Run(false, std::nullopt);
return;
}
base::FilePath user_data_dir;
if (!base::PathService::Get(chrome::DIR_USER_DATA, &user_data_dir)) {
LOG(DFATAL) << "Could not get the original user data dir path.";
std::move(callback).Run(false, std::nullopt);
return;
}
const base::FilePath profile_data_dir =
user_data_dir.Append(ProfileHelper::GetUserProfileDir(user_id_hash));
base::ThreadPool::PostTaskAndReplyWithResult(
FROM_HERE,
{base::MayBlock(), base::TaskPriority::USER_VISIBLE,
base::TaskShutdownBehavior::BLOCK_SHUTDOWN},
base::BindOnce(&DiskCheck, profile_data_dir),
base::BindOnce(&BrowserDataMigratorImpl::
MaybeRestartToMigrateWithDiskCheckAfterDiskCheck,
account_id, user_id_hash, std::move(callback)));
}
void BrowserDataMigratorImpl::MaybeRestartToMigrateWithDiskCheckAfterDiskCheck(
const AccountId& account_id,
const std::string& user_id_hash,
base::OnceCallback<void(bool, const std::optional<uint64_t>&)> callback,
uint64_t required_size) {
if (required_size > 0) {
LOG(ERROR) << "Failed due to out of disk: " << required_size;
std::move(callback).Run(false, required_size);
return;
}
bool result = RestartToMigrate(
account_id, user_id_hash,
user_manager::UserManager::Get()->GetLocalState(),
ash::standalone_browser::migrator_util::PolicyInitState::kAfterInit);
std::move(callback).Run(result, std::nullopt);
}
bool BrowserDataMigratorImpl::MaybeRestartToMigrateInternal(
const AccountId& account_id,
const std::string& user_id_hash,
ash::standalone_browser::migrator_util::PolicyInitState policy_init_state) {
auto* user_manager = user_manager::UserManager::Get();
auto* local_state = user_manager->GetLocalState();
// If `MigrationStep` is not `kCheckStep`, `MaybeRestartToMigrate()` has
// already moved on to later steps. Namely either in the middle of migration
// or migration has already run.
MigrationStep step = GetMigrationStep(local_state);
if (step != MigrationStep::kCheckStep) {
switch (step) {
case MigrationStep::kRestartCalled:
LOG(ERROR)
<< "RestartToMigrate() was called but Migrate() was not. "
"This indicates that either "
"SessionManagerClient::BlockingRequestBrowserDataMigration() "
"failed or ash crashed before reaching Migrate(). Check "
"the previous chrome log and the one before.";
break;
case MigrationStep::kStarted:
LOG(ERROR) << "Migrate() was called but "
"MigrateInternalFinishedUIThread() was not indicating "
"that ash might have crashed during the migration.";
break;
case MigrationStep::kEnded:
default:
// TODO(crbug.com/40207942): Once `BrowserDataMigrator` stabilises,
// remove this log message or reduce to VLOG(1).
if (ash::standalone_browser::migrator_util::
IsProfileMigrationCompletedForUser(local_state, user_id_hash,
true /* print_mode */)) {
LOG(WARNING) << "Migration was attempted and successfully completed.";
} else {
LOG(WARNING) << "Migration was attempted but failed or was skipped.";
}
break;
}
return false;
}
// Check if the switch for testing is present.
const std::string force_migration_switch =
base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
switches::kForceBrowserDataMigrationForTesting);
if (force_migration_switch == kBrowserDataMigrationForceSkip) {
return false;
}
if (force_migration_switch == kBrowserDataMigrationForceMigration) {
LOG(WARNING) << "`kBrowserDataMigrationForceMigration` switch is present.";
return true;
}
const user_manager::User* user =
user_manager::UserManager::Get()->FindUser(account_id);
// Check if user exists i.e. not a guest session.
if (!user) {
return false;
}
// Migration should not run for secondary users.
const auto* primary_user = user_manager::UserManager::Get()->GetPrimaryUser();
// `MaybeRestartToMigrateInternal()` either gets called before profile
// initialization or after profile initialization. In case of the former, its
// called from `PreProfileInit()` and this is only called for the primary
// profile so we can assume that the user is the primary user if `primary_user
// == nullptr`. If primary_user is not null then we check if `user !=
// primary_user`.
if (primary_user && (user != primary_user)) {
LOG(WARNING) << "Skip migration for secondary users.";
return false;
}
// Check if profile migration is enabled. If not immediately return.
if (!crosapi::browser_util::IsProfileMigrationEnabled(user,
policy_init_state)) {
if (crosapi::browser_util::IsLacrosEnabledForMigration(user,
policy_init_state) ||
base::CommandLine::ForCurrentProcess()->HasSwitch(
switches::kSafeMode)) {
// Skip clearing prefs if Lacros is enabled or Lacros is disabled due to
// safe mode. Profile migration can be disabled even if Lacros is enabled
// by enabling LacrosProfileMigrationForceOff flag. There's another case
// where Lacros is disabled due to "safe mode" being enabled after Ash
// crashes. By not clearing prefs in safe mode, we avoid the following
// scenario: Ash experiences a crash loop due to some experimental flag ->
// experimental flags get dropped including ones to enable Lacros ->
// Lacros is disabled and migration completion flags gets cleared -> on
// next login migration is run and wipes existing user data.
LOG(WARNING)
<< "Profile migration is disabled but either Lacros is enabled or "
"safe mode is enabled so skipping clearing prefs.";
return false;
}
// TODO(crbug.com/40207942): Once `BrowserDataMigrator` stabilises, remove
// this log message.
LOG(WARNING)
<< "Lacros is disabled. Call ClearMigrationAttemptCountForUser() so "
"that the migration can be attempted again once migration is "
"enabled again.";
// If Lacros is disabled clear the retry count and
// `kProfileMigrationCompletedForUserPref` so that users may retry profile
// migration when re-enabling Lacros.
ash::standalone_browser::migrator_util::ClearMigrationAttemptCountForUser(
local_state, user_id_hash);
ash::standalone_browser::migrator_util::
ClearProfileMigrationCompletedForUser(local_state, user_id_hash);
MoveMigrator::ClearResumeStepForUser(local_state, user_id_hash);
MoveMigrator::ClearResumeAttemptCountForUser(local_state, user_id_hash);
return false;
}
if (ash::standalone_browser::migrator_util::
IsMigrationAttemptLimitReachedForUser(local_state, user_id_hash)) {
LOG(ERROR) << "Skipping profile migration since maximum migration "
"attempt count has been reached.";
return false;
}
if (ash::standalone_browser::migrator_util::
IsProfileMigrationCompletedForUser(local_state, user_id_hash,
true /* print_mode */)) {
LOG(WARNING) << "Profile migration is already completed at version "
<< ash::standalone_browser::migrator_util::GetDataVer(
local_state, user_id_hash)
.GetString();
return false;
}
return true;
}
// static
bool BrowserDataMigratorImpl::RestartToMigrate(
const AccountId& account_id,
const std::string& user_id_hash,
PrefService* local_state,
ash::standalone_browser::migrator_util::PolicyInitState policy_init_state) {
SetMigrationStep(local_state, MigrationStep::kRestartCalled);
ash::standalone_browser::migrator_util::UpdateMigrationAttemptCountForUser(
local_state, user_id_hash);
ash::standalone_browser::migrator_util::ClearProfileMigrationCompletedForUser(
local_state, user_id_hash);
crosapi::browser_util::ClearProfileMigrationCompletionTimeForUser(
local_state, user_id_hash);
local_state->CommitPendingWrite();
const user_manager::User* user =
user_manager::UserManager::Get()->FindUser(account_id);
// `user` should exist by the time `RestartToMigrate()` is called.
CHECK(user) << "User could not be found for " << account_id.GetUserEmail()
<< " but RestartToMigrate() was called.";
// TODO(crbug.com/40207942): Once `BrowserDataMigrator` stabilises, remove
// this log message.
LOG(WARNING) << "Making a dbus method call to session_manager";
bool success =
SessionManagerClient::Get()->BlockingRequestBrowserDataMigration(
cryptohome::CreateAccountIdentifierFromAccountId(account_id),
browser_data_migrator_util::kMoveSwitchValue);
// TODO(crbug.com/40799062): Add an UMA.
if (!success) {
LOG(ERROR) << "SessionManagerClient::BlockingRequestBrowserDataMigration() "
"failed.";
return false;
}
AttemptRestart();
return true;
}
BrowserDataMigratorImpl::BrowserDataMigratorImpl(
const base::FilePath& original_profile_dir,
const std::string& user_id_hash,
const standalone_browser::ProgressCallback& progress_callback,
PrefService* local_state)
: original_profile_dir_(original_profile_dir),
user_id_hash_(user_id_hash),
progress_tracker_(
std::make_unique<standalone_browser::MigrationProgressTrackerImpl>(
progress_callback)),
cancel_flag_(
base::MakeRefCounted<browser_data_migrator_util::CancelFlag>()),
local_state_(local_state) {
DCHECK(local_state_);
}
BrowserDataMigratorImpl::~BrowserDataMigratorImpl() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
}
void BrowserDataMigratorImpl::Migrate(MigrateCallback callback) {
DCHECK(local_state_);
DCHECK(completion_callback_.is_null());
completion_callback_ = std::move(callback);
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
// TODO(crbug.com/40169227): Once BrowserDataMigrator stabilises, reduce the
// log level to VLOG(1).
LOG(WARNING) << "BrowserDataMigratorImpl::Migrate() is called.";
DCHECK(GetMigrationStep(local_state_) == MigrationStep::kRestartCalled);
SetMigrationStep(local_state_, MigrationStep::kStarted);
LOG(WARNING) << "Initializing MoveMigrator.";
migrator_delegate_ = std::make_unique<MoveMigrator>(
original_profile_dir_, user_id_hash_, std::move(progress_tracker_),
cancel_flag_, local_state_,
base::BindOnce(&BrowserDataMigratorImpl::MigrateInternalFinishedUIThread,
weak_factory_.GetWeakPtr()));
migrator_delegate_->Migrate();
}
void BrowserDataMigratorImpl::Cancel() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
cancel_flag_->Set();
}
void BrowserDataMigratorImpl::MigrateInternalFinishedUIThread(
MigrationResult result) {
DCHECK(local_state_);
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
DCHECK(GetMigrationStep(local_state_) == MigrationStep::kStarted);
SetMigrationStep(local_state_, MigrationStep::kEnded);
// TODO(crbug.com/40169227): Once BrowserDataMigrator stabilises, reduce the
// log level to VLOG(1).
LOG(WARNING)
<< "MigrateInternalFinishedUIThread() called with results data wipe = "
<< static_cast<int>(result.data_wipe_result) << " and migration "
<< static_cast<int>(result.data_migration_result.kind);
if (result.data_wipe_result != DataWipeResult::kFailed) {
// kSkipped means that the directory did not exist so record the current
// version as the data version.
ash::standalone_browser::migrator_util::RecordDataVer(
local_state_, user_id_hash_, version_info::GetVersion());
}
switch (result.data_migration_result.kind) {
case ResultKind::kSucceeded:
ash::standalone_browser::migrator_util::
SetProfileMigrationCompletedForUser(
local_state_, user_id_hash_,
ash::standalone_browser::migrator_util::MigrationMode::kMove);
// Profile migration is marked as completed both when the migration is
// performed (here) and for a new user without actually performing data
// migration (`ProfileImpl::OnLocaleReady`). The timestamp of completed
// migration is only recorded when the migration is actually performed.
crosapi::browser_util::SetProfileMigrationCompletionTimeForUser(
local_state_, user_id_hash_);
ash::standalone_browser::migrator_util::ClearMigrationAttemptCountForUser(
local_state_, user_id_hash_);
break;
case ResultKind::kFailed:
LOG(ERROR) << "Migration failed for some reason. Look at logs from "
"move_migrator.cc for details.";
// This should not happen often. Send a crash report for debugging.
base::debug::DumpWithoutCrashing();
break;
case ResultKind::kCancelled:
LOG(WARNING) << "Migration was cancelled by the user.";
break;
}
local_state_->CommitPendingWrite();
std::move(completion_callback_).Run(result.data_migration_result);
}
// static
void BrowserDataMigratorImpl::RegisterLocalStatePrefs(
PrefRegistrySimple* registry) {
registry->RegisterIntegerPref(kMigrationStep,
static_cast<int>(MigrationStep::kCheckStep));
// Register prefs for move migration.
MoveMigrator::RegisterLocalStatePrefs(registry);
}
// static
void BrowserDataMigratorImpl::SetMigrationStep(
PrefService* local_state,
BrowserDataMigratorImpl::MigrationStep step) {
local_state->SetInteger(kMigrationStep, static_cast<int>(step));
}
// static
void BrowserDataMigratorImpl::ClearMigrationStep(PrefService* local_state) {
local_state->ClearPref(kMigrationStep);
}
// static
bool BrowserDataMigratorImpl::IsFirstLaunchAfterMigration(
const PrefService* local_state) {
return GetMigrationStep(local_state) == MigrationStep::kEnded;
}
// static
void BrowserDataMigratorImpl::SetFirstLaunchAfterMigrationForTesting(
PrefService* local_state) {
SetMigrationStep(local_state, MigrationStep::kEnded);
}
// static
BrowserDataMigratorImpl::MigrationStep
BrowserDataMigratorImpl::GetMigrationStep(const PrefService* local_state) {
return static_cast<MigrationStep>(local_state->GetInteger(kMigrationStep));
}
} // namespace ash
Codebase Browser
chromium