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";
+
+// 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() {
+  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);
+    CallJS("setIsResuming", should_resume_);
+  } else {
+    if (should_resume_) {
+      // TODO(fukino): Check the battery level.
+      StartMigration();
+    } else {
+      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