Add support for the Pkcs11GetTpmTokenInfoForUser cryptohome call.

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 "base/bind.h"
 #include "base/location.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 312 matching lines @@
                                  cryptohome::kCryptohomePkcs11GetTpmTokenInfo);
     proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(
             &CryptohomeClientImpl::OnPkcs11GetTpmTokenInfo,
             weak_ptr_factory_.GetWeakPtr(),
             callback));
   }
 
   // CryptohomeClient override.
+  virtual void Pkcs11GetTpmTokenInfoForUser(
+      const std::string& user_email,
+      const Pkcs11GetTpmTokenInfoCallback& callback) OVERRIDE {
+    dbus::MethodCall method_call(
+        cryptohome::kCryptohomeInterface,
+        cryptohome::kCryptohomePkcs11GetTpmTokenInfoForUser);
+    dbus::MessageWriter writer(&method_call);
+    writer.AppendString(user_email);
+    proxy_->CallMethod(
+        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+        base::Bind(
+            &CryptohomeClientImpl::OnPkcs11GetTpmTokenInfoForUser,
+            weak_ptr_factory_.GetWeakPtr(),
+            callback));
+  }
+
+  // CryptohomeClient override.
   virtual bool InstallAttributesGet(const std::string& name,
                                     std::vector<uint8>* value,
                                     bool* successful) OVERRIDE {
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  cryptohome::kCryptohomeInstallAttributesGet);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(name);
     scoped_ptr<dbus::Response> response(
         blocking_method_caller_->CallMethodAndBlock(&method_call));
     if (!response.get())
@@ skipping 379 matching lines @@
   void OnBoolMethod(const BoolDBusMethodCallback& callback,
                     dbus::Response* response) {
     if (!response) {
       callback.Run(DBUS_METHOD_CALL_FAILURE, false);
       return;
     }
     dbus::MessageReader reader(response);
     bool result = false;
     if (!reader.PopBool(&result)) {
       callback.Run(DBUS_METHOD_CALL_FAILURE, false);
+      LOG(ERROR) << "Invalid response: " << response->ToString();
       return;
     }
     callback.Run(DBUS_METHOD_CALL_SUCCESS, result);
   }
 
   // Handles responses for methods with a string value result.
   void OnStringMethod(const StringDBusMethodCallback& callback,
                       dbus::Response* response) {
     if (!response) {
       callback.Run(DBUS_METHOD_CALL_FAILURE, std::string());
@@ skipping 21 matching lines @@
     bool result = false;
     if (!reader.PopArrayOfBytes(&data_buffer, &data_length) ||
         !reader.PopBool(&result)) {
       callback.Run(DBUS_METHOD_CALL_FAILURE, false, std::string());
       return;
     }
     std::string data(reinterpret_cast<char*>(data_buffer), data_length);
     callback.Run(DBUS_METHOD_CALL_SUCCESS, result, data);
   }
 
-  // Handles responses for Pkcs11GetTpmtTokenInfo.
+  // Handles responses for Pkcs11GetTpmTokenInfo.
   void OnPkcs11GetTpmTokenInfo(const Pkcs11GetTpmTokenInfoCallback& callback,
                                dbus::Response* response) {
     if (!response) {
-      callback.Run(DBUS_METHOD_CALL_FAILURE, std::string(), std::string());
+      callback.Run(DBUS_METHOD_CALL_FAILURE, std::string(), std::string(), -1);
       return;
     }
     dbus::MessageReader reader(response);
     std::string label;
     std::string user_pin;
     if (!reader.PopString(&label) || !reader.PopString(&user_pin)) {
-      callback.Run(DBUS_METHOD_CALL_FAILURE, std::string(), std::string());
+      callback.Run(DBUS_METHOD_CALL_FAILURE, std::string(), std::string(), -1);
+      LOG(ERROR) << "Invalid response: " << response->ToString();
       return;
     }
-    callback.Run(DBUS_METHOD_CALL_SUCCESS, label, user_pin);
+    const int kDefaultSlot = 0;
+    callback.Run(DBUS_METHOD_CALL_SUCCESS, label, user_pin, kDefaultSlot);
+  }
+
+  // Handles responses for Pkcs11GetTpmTokenInfoForUser.
+  void OnPkcs11GetTpmTokenInfoForUser(
+      const Pkcs11GetTpmTokenInfoCallback& callback,
+      dbus::Response* response) {
+    if (!response) {
+      callback.Run(DBUS_METHOD_CALL_FAILURE, std::string(), std::string(), -1);
+      return;
+    }
+    dbus::MessageReader reader(response);
+    std::string label;
+    std::string user_pin;
+    int slot = 0;
+    if (!reader.PopString(&label) || !reader.PopString(&user_pin) ||
+        !reader.PopInt32(&slot)) {
+      callback.Run(DBUS_METHOD_CALL_FAILURE, std::string(), std::string(), -1);
+      LOG(ERROR) << "Invalid response: " << response->ToString();
+      return;
+    }
+    callback.Run(DBUS_METHOD_CALL_SUCCESS, label, user_pin, slot);
   }
 
   // Handles AsyncCallStatus signal.
   void OnAsyncCallStatus(dbus::Signal* signal) {
     dbus::MessageReader reader(signal);
     int async_id = 0;
     bool return_status = false;
     int return_code = 0;
     if (!reader.PopInt32(&async_id) ||
         !reader.PopBool(&return_status) ||
@@ skipping 62 matching lines @@
   return new FakeCryptohomeClient();
 }
 
 // static
 std::string CryptohomeClient::GetStubSanitizedUsername(
     const std::string& username) {
   return username + kUserIdStubHashSuffix;
 }
 
 }  // namespace chromeos