cros: Enable Ext4 migration in ARC kiosk mode.

chrome/browser/ui/webui/chromeos/login/encryption_migration_screen_handler.cc

 // Copyright 2017 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/ui/webui/chromeos/login/encryption_migration_screen_handler.h"
 
 #include <cmath>
 #include <string>
 #include <utility>
 
@@ skipping 53 matching lines @@
     "Cryptohome.MigrationUI.ConsumedBatteryPercent";
 constexpr char kUmaNameVisibleScreen[] = "Cryptohome.MigrationUI.VisibleScreen";
 
 // This enum must match the numbering for MigrationUIFirstScreen in
 // histograms/enums.xml. Do not reorder or remove items, only add new items
 // before FIRST_SCREEN_COUNT.
 enum class FirstScreen {
   FIRST_SCREEN_READY = 0,
   FIRST_SCREEN_RESUME = 1,
   FIRST_SCREEN_LOW_STORAGE = 2,
+  FIRST_SCREEN_ARC_KIOSK = 3,
   FIRST_SCREEN_COUNT
 };
 
 // This enum must match the numbering for MigrationUIUserChoice in
 // histograms/enums.xml. Do not reorder or remove items, only add new items
 // before USER_CHOICE_COUNT.
 enum class UserChoice {
   USER_CHOICE_UPDATE = 0,
   USER_CHOICE_SKIP = 1,
   USER_CHOICE_RESTART_ON_FAILURE = 2,
   USER_CHOICE_RESTART_ON_LOW_STORAGE = 3,
   USER_CHOICE_REPORT_AN_ISSUE = 4,
   USER_CHOICE_COUNT
 };
 
 // This enum must match the numbering for MigrationUIMigrationResult in
 // histograms/enums.xml. Do not reorder or remove items, only add new items
 // before COUNT.
 enum class MigrationResult {
   SUCCESS_IN_NEW_MIGRATION = 0,
   SUCCESS_IN_RESUMED_MIGRATION = 1,
   GENERAL_FAILURE_IN_NEW_MIGRATION = 2,
   GENERAL_FAILURE_IN_RESUMED_MIGRATION = 3,
   REQUEST_FAILURE_IN_NEW_MIGRATION = 4,
   REQUEST_FAILURE_IN_RESUMED_MIGRATION = 5,
   MOUNT_FAILURE_IN_NEW_MIGRATION = 6,
   MOUNT_FAILURE_IN_RESUMED_MIGRATION = 7,
+  SUCCESS_IN_ARC_KIOSK_MIGRATION = 8,
+  GENERAL_FAILURE_IN_ARC_KIOSK_MIGRATION = 9,
+  REQUEST_FAILURE_IN_ARC_KIOSK_MIGRATION = 10,
+  MOUNT_FAILURE_IN_ARC_KIOSK_MIGRATION = 11,
   COUNT
 };
 
 // This enum must match the numbering for MigrationUIRemoveCryptohomeResult in
 // histograms/enums.xml. Do not reorder or remove items, only add new items
 // before COUNT.
 enum class RemoveCryptohomeResult {
   SUCCESS_IN_NEW_MIGRATION = 0,
   SUCCESS_IN_RESUMED_MIGRATION = 1,
   FAILURE_IN_NEW_MIGRATION = 2,
   FAILURE_IN_RESUMED_MIGRATION = 3,
+  SUCCESS_IN_ARC_KIOSK_MIGRATION = 4,
+  FAILURE_IN_ARC_KIOSK_MIGRATION = 5,
   COUNT
 };
 
 bool IsTestingUI() {
   return base::CommandLine::ForCurrentProcess()->HasSwitch(
       chromeos::switches::kTestEncryptionMigrationUI);
 }
 
 // Wrapper functions for histogram macros to avoid duplication of expanded code.
 void RecordFirstScreen(FirstScreen first_screen) {
   UMA_HISTOGRAM_ENUMERATION(kUmaNameFirstScreen, first_screen,
                             FirstScreen::FIRST_SCREEN_COUNT);
 }
 
 void RecordUserChoice(UserChoice user_choice) {
   UMA_HISTOGRAM_ENUMERATION(kUmaNameUserChoice, user_choice,
                             UserChoice::USER_CHOICE_COUNT);
 }
 
 void RecordMigrationResult(MigrationResult migration_result) {
   UMA_HISTOGRAM_ENUMERATION(kUmaNameMigrationResult, migration_result,
                             MigrationResult::COUNT);
 }
 
-void RecordRemoveCryptohomeResult(bool success, bool is_resumed_migration) {
-  RemoveCryptohomeResult result =
-      success ? (is_resumed_migration
-                     ? RemoveCryptohomeResult::SUCCESS_IN_RESUMED_MIGRATION
-                     : RemoveCryptohomeResult::SUCCESS_IN_NEW_MIGRATION)
-              : (is_resumed_migration
-                     ? RemoveCryptohomeResult::FAILURE_IN_RESUMED_MIGRATION
-                     : RemoveCryptohomeResult::FAILURE_IN_NEW_MIGRATION);
+void RecordMigrationResultSuccess(bool resume, bool arc_kiosk) {
+  if (arc_kiosk)
+    RecordMigrationResult(MigrationResult::SUCCESS_IN_ARC_KIOSK_MIGRATION);
+  else if (resume)
+    RecordMigrationResult(MigrationResult::SUCCESS_IN_RESUMED_MIGRATION);
+  else
+    RecordMigrationResult(MigrationResult::SUCCESS_IN_NEW_MIGRATION);
+}
+
+void RecordMigrationResultGeneralFailure(bool resume, bool arc_kiosk) {
+  if (arc_kiosk) {
+    RecordMigrationResult(
+        MigrationResult::GENERAL_FAILURE_IN_ARC_KIOSK_MIGRATION);
+  } else if (resume) {
+    RecordMigrationResult(
+        MigrationResult::GENERAL_FAILURE_IN_RESUMED_MIGRATION);
+  } else {
+    RecordMigrationResult(MigrationResult::GENERAL_FAILURE_IN_NEW_MIGRATION);
+  }
+}
+
+void RecordMigrationResultRequestFailure(bool resume, bool arc_kiosk) {
+  if (arc_kiosk) {
+    RecordMigrationResult(
+        MigrationResult::REQUEST_FAILURE_IN_ARC_KIOSK_MIGRATION);
+  } else if (resume) {
+    RecordMigrationResult(
+        MigrationResult::REQUEST_FAILURE_IN_RESUMED_MIGRATION);
+  } else {
+    RecordMigrationResult(MigrationResult::REQUEST_FAILURE_IN_NEW_MIGRATION);
+  }
+}
+
+void RecordMigrationResultMountFailure(bool resume, bool arc_kiosk) {
+  if (arc_kiosk) {
+    RecordMigrationResult(
+        MigrationResult::MOUNT_FAILURE_IN_ARC_KIOSK_MIGRATION);
+  } else if (resume) {
+    RecordMigrationResult(MigrationResult::MOUNT_FAILURE_IN_RESUMED_MIGRATION);
+  } else {
+    RecordMigrationResult(MigrationResult::MOUNT_FAILURE_IN_NEW_MIGRATION);
+  }
+}
+
+void RecordRemoveCryptohomeResult(RemoveCryptohomeResult result) {
   UMA_HISTOGRAM_ENUMERATION(kUmaNameRemoveCryptohomeResult, result,
                             RemoveCryptohomeResult::COUNT);
 }
 
+void RecordRemoveCryptohomeResultSuccess(bool resume, bool arc_kiosk) {
+  if (arc_kiosk) {
+    RecordRemoveCryptohomeResult(
+        RemoveCryptohomeResult::SUCCESS_IN_ARC_KIOSK_MIGRATION);
+  } else if (resume) {
+    RecordRemoveCryptohomeResult(
+        RemoveCryptohomeResult::SUCCESS_IN_RESUMED_MIGRATION);
+  } else {
+    RecordRemoveCryptohomeResult(
+        RemoveCryptohomeResult::SUCCESS_IN_NEW_MIGRATION);
+  }
+}
+
+void RecordRemoveCryptohomeResultFailure(bool resume, bool arc_kiosk) {
+  if (arc_kiosk) {
+    RecordRemoveCryptohomeResult(
+        RemoveCryptohomeResult::FAILURE_IN_ARC_KIOSK_MIGRATION);
+  } else if (resume) {
+    RecordRemoveCryptohomeResult(
+        RemoveCryptohomeResult::FAILURE_IN_RESUMED_MIGRATION);
+  } else {
+    RecordRemoveCryptohomeResult(
+        RemoveCryptohomeResult::FAILURE_IN_NEW_MIGRATION);
+  }
+}
+
 }  // namespace
 
 namespace chromeos {
 
 EncryptionMigrationScreenHandler::EncryptionMigrationScreenHandler()
     : BaseScreenHandler(kScreenId), weak_ptr_factory_(this) {
   set_call_js_prefix(kJsScreenPath);
 }
 
 EncryptionMigrationScreenHandler::~EncryptionMigrationScreenHandler() {
@@ skipping 29 matching lines @@
   should_resume_ = should_resume;
   CallJS("setIsResuming", should_resume_);
 }
 
 void EncryptionMigrationScreenHandler::SetContinueLoginCallback(
     ContinueLoginCallback callback) {
   continue_login_callback_ = std::move(callback);
 }
 
 void EncryptionMigrationScreenHandler::SetupInitialView() {
+  // If old encryption is detected in ARC kiosk mode, skip all checks (user
+  // confirmation, battery level, and remaining space) and start migration
+  // immediately.
+  if (IsArcKiosk()) {
+    RecordFirstScreen(FirstScreen::FIRST_SCREEN_ARC_KIOSK);
+    StartMigration();
+    return;
+  }
   DBusThreadManager::Get()->GetPowerManagerClient()->AddObserver(this);
   CheckAvailableStorage();
 }
 
 void EncryptionMigrationScreenHandler::DeclareLocalizedValues(
     ::login::LocalizedValuesBuilder* builder) {
   builder->Add("migrationReadyTitle", IDS_ENCRYPTION_MIGRATION_READY_TITLE);
   builder->Add("migrationReadyDescription",
                ash::SubstituteChromeOSDeviceType(
                    IDS_ENCRYPTION_MIGRATION_READY_DESCRIPTION));
@@ skipping 200 matching lines @@
   DBusThreadManager::Get()->GetPowerManagerClient()->RequestStatusUpdate();
 }
 
 void EncryptionMigrationScreenHandler::StartMigration() {
   UpdateUIState(UIState::MIGRATING);
   initial_battery_percent_ = *current_battery_percent_;
 
   // Mount the existing eCryptfs vault to a temporary location for migration.
   cryptohome::MountParameters mount(false);
   mount.to_migrate_from_ecryptfs = true;
-  cryptohome::HomedirMethods::GetInstance()->MountEx(
-      cryptohome::Identification(user_context_.GetAccountId()),
-      cryptohome::Authorization(GetAuthKey()), mount,
-      base::Bind(&EncryptionMigrationScreenHandler::OnMountExistingVault,
-                 weak_ptr_factory_.GetWeakPtr()));
+  if (IsArcKiosk()) {
+    mount.public_mount = true;
+    cryptohome::HomedirMethods::GetInstance()->MountEx(
+        cryptohome::Identification(user_context_.GetAccountId()),
+        cryptohome::Authorization(cryptohome::KeyDefinition()), mount,
+        base::Bind(&EncryptionMigrationScreenHandler::OnMountExistingVault,
+                   weak_ptr_factory_.GetWeakPtr()));
+
+  } else {
+    cryptohome::HomedirMethods::GetInstance()->MountEx(
+        cryptohome::Identification(user_context_.GetAccountId()),
+        cryptohome::Authorization(GetAuthKey()), mount,
+        base::Bind(&EncryptionMigrationScreenHandler::OnMountExistingVault,
+                   weak_ptr_factory_.GetWeakPtr()));
+  }
 }
 
 void EncryptionMigrationScreenHandler::OnMountExistingVault(
     bool success,
     cryptohome::MountError return_code,
     const std::string& mount_hash) {
   if (!success || return_code != cryptohome::MOUNT_ERROR_NONE) {
-    RecordMigrationResult(
-        should_resume_ ? MigrationResult::MOUNT_FAILURE_IN_RESUMED_MIGRATION
-                       : MigrationResult::MOUNT_FAILURE_IN_NEW_MIGRATION);
+    RecordMigrationResultMountFailure(should_resume_, IsArcKiosk());
     UpdateUIState(UIState::MIGRATION_FAILED);
     return;
   }
 
   DBusThreadManager::Get()
       ->GetCryptohomeClient()
       ->SetDircryptoMigrationProgressHandler(
           base::Bind(&EncryptionMigrationScreenHandler::OnMigrationProgress,
                      weak_ptr_factory_.GetWeakPtr()));
   cryptohome::HomedirMethods::GetInstance()->MigrateToDircrypto(
@@ skipping 31 matching lines @@
       cryptohome::Identification(user_context_.GetAccountId()),
       base::Bind(&EncryptionMigrationScreenHandler::OnRemoveCryptohome,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void EncryptionMigrationScreenHandler::OnRemoveCryptohome(
     bool success,
     cryptohome::MountError return_code) {
   LOG_IF(ERROR, !success) << "Removing cryptohome failed. return code: "
                           << return_code;
-  RecordRemoveCryptohomeResult(success, should_resume_);
+  if (success)
+    RecordRemoveCryptohomeResultSuccess(should_resume_, IsArcKiosk());
+  else
+    RecordRemoveCryptohomeResultFailure(should_resume_, IsArcKiosk());
+
   UpdateUIState(UIState::MIGRATION_FAILED);
 }
 
 cryptohome::KeyDefinition EncryptionMigrationScreenHandler::GetAuthKey() {
   // |auth_key| is created in the same manner as CryptohomeAuthenticator.
   const Key* key = user_context_.GetKey();
   // If the |key| is a plain text password, crash rather than attempting to
   // mount the cryptohome with a plain text password.
   CHECK_NE(Key::KEY_TYPE_PASSWORD_PLAIN, key->GetKeyType());
   // Set the authentication's key label to an empty string, which is a wildcard
   // allowing any key to match. This is necessary because cryptohomes created by
   // Chrome OS M38 and older will have a legacy key with no label while those
   // created by Chrome OS M39 and newer will have a key with the label
   // kCryptohomeGAIAKeyLabel.
   return cryptohome::KeyDefinition(key->GetSecret(), std::string(),
                                    cryptohome::PRIV_DEFAULT);
 }
 
+bool EncryptionMigrationScreenHandler::IsArcKiosk() const {
+  return user_context_.GetUserType() == user_manager::USER_TYPE_ARC_KIOSK_APP;
+}
+
 void EncryptionMigrationScreenHandler::OnMigrationProgress(
     cryptohome::DircryptoMigrationStatus status,
     uint64_t current,
     uint64_t total) {
   switch (status) {
     case cryptohome::DIRCRYPTO_MIGRATION_INITIALIZING:
       UpdateUIState(UIState::MIGRATING);
       break;
     case cryptohome::DIRCRYPTO_MIGRATION_IN_PROGRESS:
       UpdateUIState(UIState::MIGRATING);
       CallJS("setMigrationProgress", static_cast<double>(current) / total);
       break;
     case cryptohome::DIRCRYPTO_MIGRATION_SUCCESS:
-      RecordMigrationResult(should_resume_
-                                ? MigrationResult::SUCCESS_IN_RESUMED_MIGRATION
-                                : MigrationResult::SUCCESS_IN_NEW_MIGRATION);
+      RecordMigrationResultSuccess(should_resume_, IsArcKiosk());
       // If the battery level decreased during migration, record the consumed
       // battery level.
       if (*current_battery_percent_ < initial_battery_percent_) {
         UMA_HISTOGRAM_PERCENTAGE(
             kUmaNameConsumedBatteryPercent,
             static_cast<int>(std::round(initial_battery_percent_ -
                                         *current_battery_percent_)));
       }
       // Restart immediately after successful migration.
       DBusThreadManager::Get()->GetPowerManagerClient()->RequestRestart();
       break;
     case cryptohome::DIRCRYPTO_MIGRATION_FAILED:
-      RecordMigrationResult(
-          should_resume_ ? MigrationResult::GENERAL_FAILURE_IN_RESUMED_MIGRATION
-                         : MigrationResult::GENERAL_FAILURE_IN_NEW_MIGRATION);
+      RecordMigrationResultGeneralFailure(should_resume_, IsArcKiosk());
       // Stop listening to the progress updates.
       DBusThreadManager::Get()
           ->GetCryptohomeClient()
           ->SetDircryptoMigrationProgressHandler(
               CryptohomeClient::DircryptoMigrationProgessHandler());
       // Shows error screen after removing user directory is completed.
       RemoveCryptohome();
       break;
     default:
       break;
   }
 }
 
 void EncryptionMigrationScreenHandler::OnMigrationRequested(bool success) {
   if (!success) {
     LOG(ERROR) << "Requesting MigrateToDircrypto failed.";
-    RecordMigrationResult(
-        should_resume_ ? MigrationResult::REQUEST_FAILURE_IN_RESUMED_MIGRATION
-                       : MigrationResult::REQUEST_FAILURE_IN_NEW_MIGRATION);
+    RecordMigrationResultRequestFailure(should_resume_, IsArcKiosk());
     UpdateUIState(UIState::MIGRATION_FAILED);
   }
 }
 
 void EncryptionMigrationScreenHandler::OnDelayedRecordVisibleScreen(
     UIState ui_state) {
   if (current_ui_state_ != ui_state)
     return;
 
   // If |current_ui_state_| is not changed for a second, record the current
   // screen as a "visible" screen.
   UMA_HISTOGRAM_ENUMERATION(kUmaNameVisibleScreen, ui_state, UIState::COUNT);
 }
 
 }  // namespace chromeos