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 "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",
+               IDS_ENCRYPTION_MIGRATION_READY_DESCRIPTION);
+  builder->Add("migrationMigratingTitle",
+               IDS_ENCRYPTION_MIGRATION_MIGRATING_TITLE);
+  builder->Add("migrationMigratingDescription",
+               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",
+               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",
+               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);

[xiyuan, 2017/04/13 20:33:09]

IDS_ENCRYPTION_MIGRATION_BUTTON_SIGNIN seems not used ?

[fukino, 2017/04/13 21:33:41]

Sorry I should have mentioned this.
I add leave SIGNIN string intentionally.
At this moment we do Restart for safety, but I guess we might be requested to do
Sign in without restarting the device in the future and merge it to M59.
For such situation, I'd like to keep this string just in case, since we can't
add the string after the string freeze.

+}
 
 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_FULL);
 
   // 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

[fukino, 2017/04/13 19:35:23]

According to the privacy review, we should not sign in automatically, since the
user may be away from the device when the migration finished.

According to dspaid@, "Restart" is preferable than just going back to sign-in
screen, as it can clear all intermediate state in cryptohome.

[xiyuan, 2017/04/13 20:33:08]

Acknowledged.

-  // 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