cryptohome: Add dbus method and signal name for encryption migration.

chromeos/dbus/cryptohome_client.cc

 // Copyright (c) 2012 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/cryptohome_client.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
@@ skipping 50 matching lines @@
     async_call_status_handler_.Reset();
     async_call_status_data_handler_.Reset();
   }
 
   // CryptohomeClient override.
   void SetLowDiskSpaceHandler(const LowDiskSpaceHandler& handler) override {
     low_disk_space_handler_ = handler;
   }
 
   // CryptohomeClient override.
+  void SetDircryptoMigrationProgressHandler(
+      const DircryptoMigrationProgessHandler& handler) override {
+    dircrypto_migration_progress_handler_ = handler;
+  }
+
+  // CryptohomeClient override.
   void WaitForServiceToBeAvailable(
       const WaitForServiceToBeAvailableCallback& callback) override {
     proxy_->WaitForServiceToBeAvailable(callback);
   }
 
   // CryptohomeClient override.
   void IsMounted(const BoolDBusMethodCallback& callback) override {
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  cryptohome::kCryptohomeIsMounted);
     CallBoolMethod(&method_call, callback);
@@ skipping 839 matching lines @@
     dbus::MessageWriter writer(&method_call);
     writer.AppendProtoAsArrayOfBytes(request);
 
     proxy_->CallMethod(&method_call,
                        kTpmDBusTimeoutMs ,
                        base::Bind(&CryptohomeClientImpl::OnBaseReplyMethod,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
+  void MigrateToDircrypto(const cryptohome::Identification& cryptohome_id,
+                          const cryptohome::AuthorizationRequest& auth,
+                          const VoidDBusMethodCallback& callback) override {
+    dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
+                                 cryptohome::kCryptohomeMigrateToDircrypto);
+
+    cryptohome::AccountIdentifier id_proto;
+    FillIdentificationProtobuf(cryptohome_id, &id_proto);
+
+    dbus::MessageWriter writer(&method_call);
+    writer.AppendProtoAsArrayOfBytes(id_proto);
+    writer.AppendProtoAsArrayOfBytes(auth);
+
+    // The migration progress takes unpredicatable time depending on the
+    // user file size and the number. Setting the time limit to infinite.
+    proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+                       base::Bind(&CryptohomeClientImpl::OnVoidMethod,
+                                  weak_ptr_factory_.GetWeakPtr(), callback));
+  }
+
  protected:
   void Init(dbus::Bus* bus) override {
     proxy_ = bus->GetObjectProxy(
         cryptohome::kCryptohomeServiceName,
         dbus::ObjectPath(cryptohome::kCryptohomeServicePath));
 
     blocking_method_caller_.reset(new BlockingMethodCaller(bus, proxy_));
 
     proxy_->ConnectToSignal(cryptohome::kCryptohomeInterface,
                             cryptohome::kSignalAsyncCallStatus,
                             base::Bind(&CryptohomeClientImpl::OnAsyncCallStatus,
                                        weak_ptr_factory_.GetWeakPtr()),
                             base::Bind(&CryptohomeClientImpl::OnSignalConnected,
                                        weak_ptr_factory_.GetWeakPtr()));
     proxy_->ConnectToSignal(
         cryptohome::kCryptohomeInterface,
         cryptohome::kSignalAsyncCallStatusWithData,
         base::Bind(&CryptohomeClientImpl::OnAsyncCallStatusWithData,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&CryptohomeClientImpl::OnSignalConnected,
                    weak_ptr_factory_.GetWeakPtr()));
     proxy_->ConnectToSignal(cryptohome::kCryptohomeInterface,
                             cryptohome::kSignalLowDiskSpace,
                             base::Bind(&CryptohomeClientImpl::OnLowDiskSpace,
                                        weak_ptr_factory_.GetWeakPtr()),
                             base::Bind(&CryptohomeClientImpl::OnSignalConnected,
                                        weak_ptr_factory_.GetWeakPtr()));
+    proxy_->ConnectToSignal(
+        cryptohome::kCryptohomeInterface,
+        cryptohome::kSignalDircryptoMigrationProgress,
+        base::Bind(&CryptohomeClientImpl::OnDircryptoMigrationProgress,
+                   weak_ptr_factory_.GetWeakPtr()),
+        base::Bind(&CryptohomeClientImpl::OnSignalConnected,
+                   weak_ptr_factory_.GetWeakPtr()));
   }
 
  private:
   // Handles the result of AsyncXXX methods.
   void OnAsyncMethodCall(const AsyncMethodCallback& callback,
                          dbus::Response* response) {
     if (!response) {
       callback.Run(kNotReadyAsyncId);
       return;
     }
@@ skipping 213 matching lines @@
     dbus::MessageReader reader(signal);
     uint64_t disk_free_bytes = 0;
     if (!reader.PopUint64(&disk_free_bytes)) {
       LOG(ERROR) << "Invalid signal: " << signal->ToString();
       return;
     }
     if (!low_disk_space_handler_.is_null())
       low_disk_space_handler_.Run(disk_free_bytes);
   }
 
+  // Handles DircryptoMigrationProgess signal.
+  void OnDircryptoMigrationProgress(dbus::Signal* signal) {
+    if (dircrypto_migration_progress_handler_.is_null())
+      return;
+
+    dbus::MessageReader reader(signal);
+    int status = 0;
+    uint64_t current_bytes = 0, total_bytes = 0;
+    if (!reader.PopInt32(&status) || !reader.PopUint64(&current_bytes) ||
+        !reader.PopUint64(&total_bytes)) {
+      LOG(ERROR) << "Invalid signal: " << signal->ToString();
+      return;
+    }
+    dircrypto_migration_progress_handler_.Run(
+        static_cast<cryptohome::DircryptoMigrationStatus>(status),
+        current_bytes, total_bytes);
+  }
+
   // Handles the result of signal connection setup.
   void OnSignalConnected(const std::string& interface,
                          const std::string& signal,
                          bool succeeded) {
     LOG_IF(ERROR, !succeeded) << "Connect to " << interface << " " <<
         signal << " failed.";
   }
 
   dbus::ObjectProxy* proxy_;
   std::unique_ptr<BlockingMethodCaller> blocking_method_caller_;
   AsyncCallStatusHandler async_call_status_handler_;
   AsyncCallStatusWithDataHandler async_call_status_data_handler_;
   LowDiskSpaceHandler low_disk_space_handler_;
+  DircryptoMigrationProgessHandler dircrypto_migration_progress_handler_;
 
   // Note: This should remain the last member so it'll be destroyed and
   // invalidate its weak pointers before any other members are destroyed.
   base::WeakPtrFactory<CryptohomeClientImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(CryptohomeClientImpl);
 };
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // CryptohomeClient
 
 CryptohomeClient::CryptohomeClient() {}
 
 CryptohomeClient::~CryptohomeClient() {}
 
 // static
 CryptohomeClient* CryptohomeClient::Create() {
   return new CryptohomeClientImpl();
 }
 
 // static
 std::string CryptohomeClient::GetStubSanitizedUsername(
     const cryptohome::Identification& cryptohome_id) {
   return cryptohome_id.id() + kUserIdStubHashSuffix;
 }
 
 }  // namespace chromeos