Check the available storage size before starting encryption migration.

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/files/file_path.h"
+#include "base/sys_info.h"
+#include "base/task_scheduler/post_task.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chromeos/cryptohome/homedir_methods.h"
 #include "chromeos/dbus/cryptohome_client.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 
 namespace {
 
 constexpr char kJsScreenPath[] = "login.EncryptionMigrationScreen";
 
+// Path to the mount point to check the available space.
+constexpr char kCheckStoragePath[] = "/home";

[fukino, 2017/04/10 12:08:50]

I'd like to call statvfs to a path on the stateful partition.
I assume that "/home" is mounted on the partition, but it should not be
guaranteed. (To me, it's hard to imagine that it will change in the future,
though)

More robust alternative should be adding cryptohome API to ask the remaining
space, but not sure if this use case justifies adding a new API.

WDYT?

[xiyuan, 2017/04/10 17:24:55]

I am fine with using hard-coded "/home". I am not an expert of the mount though.
You might want to double check with Gwendal to make sure this is the correct one
for checking space needed for migration.

[fukino, 2017/04/10 23:04:58]

I call statvfs on "/home" to check the available space in the stateful partition
before sign in.
I assume that we can expect that "/home" is mounted on the stateful partition.
Do you have any concerns on this approach? Should I add cryptohome API to check
the available space?

+
+// The minimum size of available space to start the migration.
+constexpr int64_t kMinimumAvailableStorage = 10LL * 1024 * 1024;  // 10MB
+
 // JS API callbacks names.
 constexpr char kJsApiStartMigration[] = "startMigration";
 constexpr char kJsApiSkipMigration[] = "skipMigration";
 constexpr char kJsApiRequestRestart[] = "requestRestart";
 
 }  // namespace
 
 namespace chromeos {
 
 EncryptionMigrationScreenHandler::EncryptionMigrationScreenHandler()
@@ skipping 23 matching lines @@
   if (page_is_ready())
     Initialize();
 }
 
 void EncryptionMigrationScreenHandler::SetUserContext(
     const UserContext& user_context) {
   user_context_ = user_context;
 }
 
 void EncryptionMigrationScreenHandler::SetShouldResume(bool should_resume) {
-  if (current_ui_state_ == INITIAL && should_resume) {
-    // TODO(fukino): Wait until the battery gets enough level.
-    StartMigration();
-  }
+  should_resume_ = should_resume;
 }
 
 void EncryptionMigrationScreenHandler::SetContinueLoginCallback(
     ContinueLoginCallback callback) {
   continue_login_callback_ = std::move(callback);
 }
 
+void EncryptionMigrationScreenHandler::SetupInitialView() {
+  if (should_resume_) {
+    // TODO(fukino): Handle the following case.

[xiyuan, 2017/04/10 17:24:55]

Why not always start with CheckAvailableStorage() and move the |should_resume_|
check to call StartMigration() in OnGetAvailableStorage() ?

[fukino, 2017/04/12 01:43:05]

You are right.
It is much simpler to always start with CheckAvailableStorage().
I updated the code to do so, and in |should_resume_| situation, I replaced
"Skip" button with "Restart" button since we can not sign in to the current
user's session.
(Showing sign-in screen instead of Restart should be better, but I chose
"Restart" for now for simplicity for a very rare situation.)

+    //
+    // 1) User A starts migration, but shuts down the device during migration.
+    // 2) User B signs in to the device and fills the storage.
+    // 3) User A signs in. The user needs resume the migration, but no space.
+    //
+    // If we don't handle this case, the user A's profile can be wiped due to
+    // the failure of migration in step 3. (or B's profile can be wiped by
+    // periodical disk cleanup.)
+    // By providing "Sign out" option for this situation, we might be able to
+    // avoid profile removal.
+    StartMigration();
+  } else {
+    CheckAvailableStorage();
+  }
+}
+
 void EncryptionMigrationScreenHandler::DeclareLocalizedValues(
     ::login::LocalizedValuesBuilder* builder) {}
 
 void EncryptionMigrationScreenHandler::Initialize() {
   if (!page_is_ready() || !delegate_)
     return;
 
   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::HandleStartMigration() {
-  // TODO(fukino): Wait until the battery gets enough level.
   StartMigration();
 }
 
 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()) {
@@ skipping 10 matching lines @@
 }
 
 void EncryptionMigrationScreenHandler::UpdateUIState(UIState state) {
   if (state == current_ui_state_)
     return;
 
   current_ui_state_ = state;
   CallJS("setUIState", static_cast<int>(state));
 }
 
+void EncryptionMigrationScreenHandler::CheckAvailableStorage() {
+  base::PostTaskWithTraitsAndReplyWithResult(
+      FROM_HERE,
+      base::TaskTraits().MayBlock().WithPriority(
+          base::TaskPriority::USER_VISIBLE),
+      base::Bind(&base::SysInfo::AmountOfFreeDiskSpace,
+                 base::FilePath(kCheckStoragePath)),
+      base::Bind(&EncryptionMigrationScreenHandler::OnGetAvailableStorage,
+                 weak_ptr_factory_.GetWeakPtr()));
+}
+
+void EncryptionMigrationScreenHandler::OnGetAvailableStorage(int64_t size) {
+  if (size < kMinimumAvailableStorage) {
+    UpdateUIState(NOT_ENOUGH_STORAGE);
+  } else {
+    // TODO(fukino): Check the battery level.
+    UpdateUIState(READY);
+  }
+}
+
 void EncryptionMigrationScreenHandler::StartMigration() {
   DBusThreadManager::Get()
       ->GetCryptohomeClient()
       ->SetDircryptoMigrationProgressHandler(
           base::Bind(&EncryptionMigrationScreenHandler::OnMigrationProgress,
                      weak_ptr_factory_.GetWeakPtr()));
 
   // |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
@@ skipping 45 matching lines @@
 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