Implement a basic UI flow for cryptohome encryption migration.

chromeos/dbus/fake_cryptohome_client.cc

 // Copyright 2013 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 "chromeos/dbus/fake_cryptohome_client.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
@@ skipping 14 matching lines @@
 #include "third_party/protobuf/src/google/protobuf/io/zero_copy_stream.h"
 #include "third_party/protobuf/src/google/protobuf/io/zero_copy_stream_impl_lite.h"
 
 namespace chromeos {
 
 namespace {
 // Signature nonces are twenty bytes. This matches the attestation code.
 constexpr char kTwentyBytesNonce[] = "+addtwentybytesnonce";
 // A symbolic signature.
 constexpr char kSignature[] = "signed";
+// Interval to update the progress of MigrateToDircrypto in milliseconds.
+constexpr int kDircryptoMigrationUpdateIntervalMs = 200;
+// The number of updates the MigrateToDircrypto will send before it completes.
+constexpr uint64_t kDircryptoMigrationMaxProgress = 15;
 }  // namespace
 
 FakeCryptohomeClient::FakeCryptohomeClient()
     : service_is_available_(true),
       async_call_id_(1),
       unmount_result_(true),
       system_salt_(GetStubSystemSalt()),
       weak_ptr_factory_(this) {
   base::FilePath cache_path;
   locked_ = PathService::Get(chromeos::FILE_INSTALL_ATTRIBUTES, &cache_path) &&
@@ skipping 14 matching lines @@
 
 void FakeCryptohomeClient::ResetAsyncCallStatusHandlers() {
   async_call_status_handler_.Reset();
   async_call_status_data_handler_.Reset();
 }
 
 void FakeCryptohomeClient::SetLowDiskSpaceHandler(
     const LowDiskSpaceHandler& handler) {}
 
 void FakeCryptohomeClient::SetDircryptoMigrationProgressHandler(
-    const DircryptoMigrationProgessHandler& handler) {}
+    const DircryptoMigrationProgessHandler& handler) {
+  dircrypto_migration_progress_handler_ = handler;
+}
 
 void FakeCryptohomeClient::WaitForServiceToBeAvailable(
     const WaitForServiceToBeAvailableCallback& callback) {
   if (service_is_available_) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                   base::Bind(callback, true));
   } else {
     pending_wait_for_service_to_be_available_callbacks_.push_back(callback);
   }
 }
@@ skipping 502 matching lines @@
   cryptohome::BaseReply reply;
   ReturnProtobufMethodCallback(reply, callback);
 }
 
 void FakeCryptohomeClient::MigrateToDircrypto(
     const cryptohome::Identification& cryptohome_id,
     const cryptohome::AuthorizationRequest& auth,
     const VoidDBusMethodCallback& callback) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS));
+  dircrypto_migration_progress_ = 0;
+  dircrypto_migration_progress_timer_.Start(
+      FROM_HERE,
+      base::TimeDelta::FromMilliseconds(kDircryptoMigrationUpdateIntervalMs),
+      this, &FakeCryptohomeClient::OnDircryptoMigrationProgressUpdated);
 }
 
 void FakeCryptohomeClient::SetServiceIsAvailable(bool is_available) {
   service_is_available_ = is_available;
   if (is_available) {
     std::vector<WaitForServiceToBeAvailableCallback> callbacks;
     callbacks.swap(pending_wait_for_service_to_be_available_callbacks_);
     for (size_t i = 0; i < callbacks.size(); ++i)
       callbacks[i].Run(is_available);
   }
@@ skipping 46 matching lines @@
     const std::string& data) {
   callback.Run(async_call_id_);
   if (!async_call_status_data_handler_.is_null()) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(async_call_status_data_handler_, async_call_id_,
                               true, data));
   }
   ++async_call_id_;
 }
 
+void FakeCryptohomeClient::OnDircryptoMigrationProgressUpdated() {
+  dircrypto_migration_progress_++;
+
+  if (dircrypto_migration_progress_ >= kDircryptoMigrationMaxProgress) {
+    if (!dircrypto_migration_progress_handler_.is_null()) {
+      base::ThreadTaskRunnerHandle::Get()->PostTask(
+          FROM_HERE, base::Bind(dircrypto_migration_progress_handler_,
+                                cryptohome::DIRCRYPTO_MIGRATION_SUCCESS,
+                                dircrypto_migration_progress_,
+                                kDircryptoMigrationMaxProgress));
+    }
+    dircrypto_migration_progress_timer_.Stop();
+    return;
+  }
+  if (!dircrypto_migration_progress_handler_.is_null()) {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(dircrypto_migration_progress_handler_,
+                              cryptohome::DIRCRYPTO_MIGRATION_IN_PROGRESS,
+                              dircrypto_migration_progress_,
+                              kDircryptoMigrationMaxProgress));
+  }
+}
+
 }  // namespace chromeos