cros: Update design of encryption migration UI for ext4 dircrypto.

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 <string>
 #include <utility>
 
+#include "ash/system/devicetype_utils.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/sys_info.h"
 #include "base/task_scheduler/post_task.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
+#include "chrome/grit/generated_resources.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/cryptohome/homedir_methods.h"
 #include "chromeos/dbus/cryptohome_client.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/power_manager/power_supply_properties.pb.h"
 #include "chromeos/dbus/power_manager_client.h"
+#include "components/login/localized_values_builder.h"
+#include "ui/base/text/bytes_formatting.h"
 
 namespace {
 
 constexpr char kJsScreenPath[] = "login.EncryptionMigrationScreen";
 
 // Path to the mount point to check the available space.
 constexpr char kCheckStoragePath[] = "/home";
 
 // The minimum size of available space to start the migration.
 constexpr int64_t kMinimumAvailableStorage = 10LL * 1024 * 1024;  // 10MB
@@ skipping 57 matching lines @@
 void EncryptionMigrationScreenHandler::SetContinueLoginCallback(
     ContinueLoginCallback callback) {
   continue_login_callback_ = std::move(callback);
 }
 
 void EncryptionMigrationScreenHandler::SetupInitialView() {
   CheckAvailableStorage();
 }
 
 void EncryptionMigrationScreenHandler::DeclareLocalizedValues(
-    ::login::LocalizedValuesBuilder* builder) {}
+    ::login::LocalizedValuesBuilder* builder) {
+  builder->Add("migrationReadyTitle", IDS_ENCRYPTION_MIGRATION_READY_TITLE);
+  builder->Add("migrationReadyDescription",
+               ash::SubstituteChromeOSDeviceType(
+                   IDS_ENCRYPTION_MIGRATION_READY_DESCRIPTION));
+  builder->Add("migrationMigratingTitle",
+               IDS_ENCRYPTION_MIGRATION_MIGRATING_TITLE);
+  builder->Add("migrationMigratingDescription",
+               ash::SubstituteChromeOSDeviceType(
+                   IDS_ENCRYPTION_MIGRATION_MIGRATING_DESCRIPTION));
+  builder->Add("migrationProgressLabel",
+               IDS_ENCRYPTION_MIGRATION_PROGRESS_LABEL);
+  builder->Add("migrationBatteryWarningLabel",
+               IDS_ENCRYPTION_MIGRATION_BATTERY_WARNING_LABEL);
+  builder->Add("migrationAskChargeMessage",
+               ash::SubstituteChromeOSDeviceType(
+                   IDS_ENCRYPTION_MIGRATION_ASK_CHARGE_MESSAGE));
+  builder->Add("migrationNecessaryBatteryLevelLabel",
+               IDS_ENCRYPTION_MIGRATION_NECESSARY_BATTERY_LEVEL_MESSAGE);
+  builder->Add("migrationChargingLabel",
+               IDS_ENCRYPTION_MIGRATION_CHARGING_LABEL);
+  builder->Add("migrationFailedTitle", IDS_ENCRYPTION_MIGRATION_FAILED_TITLE);
+  builder->Add("migrationFailedSubtitle",
+               IDS_ENCRYPTION_MIGRATION_FAILED_SUBTITLE);
+  builder->Add("migrationFailedMessage",
+               ash::SubstituteChromeOSDeviceType(
+                   IDS_ENCRYPTION_MIGRATION_FAILED_MESSAGE));
+  builder->Add("migrationNospaceWarningLabel",
+               IDS_ENCRYPTION_MIGRATION_NOSPACE_WARNING_LABEL);
+  builder->Add("migrationAskFreeSpaceMessage",
+               IDS_ENCRYPTION_MIGRATION_ASK_FREE_SPACE_MESSAGE);
+  builder->Add("migrationAvailableSpaceLabel",
+               IDS_ENCRYPTION_MIGRATION_AVAILABLE_SPACE_LABEL);
+  builder->Add("migrationNecessarySpaceLabel",
+               IDS_ENCRYPTION_MIGRATION_NECESSARY_SPACE_LABEL);
+  builder->Add("migrationButtonUpdate", IDS_ENCRYPTION_MIGRATION_BUTTON_UPDATE);
+  builder->Add("migrationButtonSkip", IDS_ENCRYPTION_MIGRATION_BUTTON_SKIP);
+  builder->Add("migrationButtonRestart",
+               IDS_ENCRYPTION_MIGRATION_BUTTON_RESTART);
+  builder->Add("migrationButtonContinue",
+               IDS_ENCRYPTION_MIGRATION_BUTTON_CONTINUE);
+  builder->Add("migrationButtonSignIn", IDS_ENCRYPTION_MIGRATION_BUTTON_SIGNIN);
+}
 
 void EncryptionMigrationScreenHandler::Initialize() {
   if (!page_is_ready() || !delegate_)
     return;
 
   DBusThreadManager::Get()->GetPowerManagerClient()->AddObserver(this);
 
   if (show_on_init_) {
     Show();
     show_on_init_ = false;
   }
 }
 
 void EncryptionMigrationScreenHandler::RegisterMessages() {
   AddCallback(kJsApiStartMigration,
               &EncryptionMigrationScreenHandler::HandleStartMigration);
   AddCallback(kJsApiSkipMigration,
               &EncryptionMigrationScreenHandler::HandleSkipMigration);
   AddCallback(kJsApiRequestRestart,
               &EncryptionMigrationScreenHandler::HandleRequestRestart);
 }
 
 void EncryptionMigrationScreenHandler::PowerChanged(
     const power_manager::PowerSupplyProperties& proto) {
   current_battery_percent_ = proto.battery_percent();
-  CallJS("setBatteryPercent", current_battery_percent_,
-         current_battery_percent_ >= kMinimumBatteryPercent);
+  CallJS("setBatteryState", current_battery_percent_,
+         current_battery_percent_ >= kMinimumBatteryPercent,
+         proto.battery_state() ==
+             power_manager::PowerSupplyProperties_BatteryState_CHARGING);
 
   // If the migration was already requested and the bettery level is enough now,
   // The migration should start immediately.
   if (current_battery_percent_ >= kMinimumBatteryPercent &&
       should_migrate_on_enough_battery_) {
     should_migrate_on_enough_battery_ = false;
     StartMigration();
   }
 }
 
 void EncryptionMigrationScreenHandler::HandleStartMigration() {
   WaitBatteryAndMigrate();
 }
 
 void EncryptionMigrationScreenHandler::HandleSkipMigration() {
   // If the user skips migration, we mount the cryptohome without performing the
   // migration by reusing UserContext and LoginPerformer which were used in the
   // previous attempt and dropping |is_forcing_dircrypto| flag in UserContext.
   // In this case, the user can not launch ARC apps in the session, and will be
   // asked to do the migration again in the next log-in attempt.
   if (!continue_login_callback_.is_null()) {
     user_context_.SetIsForcingDircrypto(false);
     std::move(continue_login_callback_).Run(user_context_);
   }
 }
 
 void EncryptionMigrationScreenHandler::HandleRequestRestart() {
-  // TODO(fukino): If the migration finished successfully, we don't need to
-  // restart the device. Let's sign in to the desktop using the already-provided
-  // user credential.
   chrome::AttemptRestart();
 }
 
 void EncryptionMigrationScreenHandler::UpdateUIState(UIState state) {
   if (state == current_ui_state_)
     return;
 
   current_ui_state_ = state;
   CallJS("setUIState", static_cast<int>(state));
 
@@ skipping 15 matching lines @@
 }
 
 void EncryptionMigrationScreenHandler::OnGetAvailableStorage(int64_t size) {
   if (size >= kMinimumAvailableStorage || IsTestingUI()) {
     if (should_resume_) {
       WaitBatteryAndMigrate();
     } else {
       UpdateUIState(UIState::READY);
     }
   } else {
+    CallJS("setAvailableSpaceInString", ui::FormatBytes(size));
+    CallJS("setNecessarySpaceInString",
+           ui::FormatBytes(kMinimumAvailableStorage));
     UpdateUIState(UIState::NOT_ENOUGH_STORAGE);
   }
 }
 
 void EncryptionMigrationScreenHandler::WaitBatteryAndMigrate() {
   if (current_battery_percent_ >= kMinimumBatteryPercent) {
     StartMigration();
     return;
   }
   UpdateUIState(UIState::READY);
@@ skipping 36 matching lines @@
     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:
+      // Restart immediately after successful migration.
+      chrome::AttemptRestart();
+      break;
     case cryptohome::DIRCRYPTO_MIGRATION_FAILED:
-      UpdateUIState(status == cryptohome::DIRCRYPTO_MIGRATION_SUCCESS
-                        ? UIState::MIGRATION_SUCCEEDED
-                        : UIState::MIGRATION_FAILED);
+      UpdateUIState(UIState::MIGRATION_FAILED);
       // Stop listening to the progress updates.
       DBusThreadManager::Get()
           ->GetCryptohomeClient()
           ->SetDircryptoMigrationProgressHandler(
               CryptohomeClient::DircryptoMigrationProgessHandler());
       break;
     default:
       break;
   }
 }
 
 void EncryptionMigrationScreenHandler::OnMigrationRequested(bool success) {
   // This function is called when MigrateToDircrypto is correctly requested.
   // It does not mean that the migration is completed. We should know the
   // completion by DircryptoMigrationProgressHandler. success == false means a
   // failure in DBus communication.
   // TODO(fukino): Handle this case. Should we retry or restart?
   DCHECK(success);
 }
 
 }  // namespace chromeos