Enhanced and refactored the AttestationFlow interface.

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/message_loop.h"
 #include "chromeos/cryptohome/async_method_caller.h"
 #include "chromeos/dbus/blocking_method_caller.h"
@@ skipping 394 matching lines @@
   }
 
   // CryptohomeClient override.
   virtual void AsyncTpmAttestationCreateCertRequest(
       int options,
       const AsyncMethodCallback& callback) OVERRIDE {
     dbus::MethodCall method_call(
         cryptohome::kCryptohomeInterface,
         cryptohome::kCryptohomeAsyncTpmAttestationCreateCertRequest);
     dbus::MessageWriter writer(&method_call);
-    bool include_stable_id = (options & INCLUDE_STABLE_ID);
+    bool include_stable_id = (options & attestation::INCLUDE_STABLE_ID);
     writer.AppendBool(include_stable_id);
-    bool include_device_state = (options & INCLUDE_DEVICE_STATE);
+    bool include_device_state = (options & attestation::INCLUDE_DEVICE_STATE);
     writer.AppendBool(include_device_state);
     proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                        base::Bind(&CryptohomeClientImpl::OnAsyncMethodCall,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // CryptohomeClient override.
   virtual void AsyncTpmAttestationFinishCertRequest(
       const std::string& pca_response,
-      AttestationKeyType key_type,
+      attestation::AttestationKeyType key_type,
       const std::string& key_name,
       const AsyncMethodCallback& callback) OVERRIDE {
     dbus::MethodCall method_call(
         cryptohome::kCryptohomeInterface,
         cryptohome::kCryptohomeAsyncTpmAttestationFinishCertRequest);
     dbus::MessageWriter writer(&method_call);
     writer.AppendArrayOfBytes(
         reinterpret_cast<const uint8*>(pca_response.data()),
         pca_response.size());
-    bool is_user_specific = (key_type == USER_KEY);
+    bool is_user_specific = (key_type == attestation::USER_KEY);
     writer.AppendBool(is_user_specific);
     writer.AppendString(key_name);
     proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                        base::Bind(&CryptohomeClientImpl::OnAsyncMethodCall,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // CryptohomeClient override.
   virtual void TpmAttestationDoesKeyExist(
-      AttestationKeyType key_type,
+      attestation::AttestationKeyType key_type,
       const std::string& key_name,
       const BoolDBusMethodCallback& callback) OVERRIDE {
     dbus::MethodCall method_call(
         cryptohome::kCryptohomeInterface,
         cryptohome::kCryptohomeTpmAttestationDoesKeyExist);
     dbus::MessageWriter writer(&method_call);
-    bool is_user_specific = (key_type == USER_KEY);
+    bool is_user_specific = (key_type == attestation::USER_KEY);
     writer.AppendBool(is_user_specific);
     writer.AppendString(key_name);
     CallBoolMethod(&method_call, callback);
   }
 
   // CryptohomeClient override.
   virtual void TpmAttestationGetCertificate(
-      AttestationKeyType key_type,
+      attestation::AttestationKeyType key_type,
       const std::string& key_name,
       const DataMethodCallback& callback) OVERRIDE {
     dbus::MethodCall method_call(
         cryptohome::kCryptohomeInterface,
         cryptohome::kCryptohomeTpmAttestationGetCertificate);
     dbus::MessageWriter writer(&method_call);
-    bool is_user_specific = (key_type == USER_KEY);
+    bool is_user_specific = (key_type == attestation::USER_KEY);
     writer.AppendBool(is_user_specific);
     writer.AppendString(key_name);
     proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                        base::Bind(&CryptohomeClientImpl::OnDataMethod,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // CryptohomeClient override.
   virtual void TpmAttestationGetPublicKey(
-      AttestationKeyType key_type,
+      attestation::AttestationKeyType key_type,
       const std::string& key_name,
       const DataMethodCallback& callback) OVERRIDE {
     dbus::MethodCall method_call(
         cryptohome::kCryptohomeInterface,
         cryptohome::kCryptohomeTpmAttestationGetPublicKey);
     dbus::MessageWriter writer(&method_call);
-    bool is_user_specific = (key_type == USER_KEY);
+    bool is_user_specific = (key_type == attestation::USER_KEY);
     writer.AppendBool(is_user_specific);
     writer.AppendString(key_name);
     proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                        base::Bind(&CryptohomeClientImpl::OnDataMethod,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // CryptohomeClient override.
   virtual void TpmAttestationRegisterKey(
-      AttestationKeyType key_type,
+      attestation::AttestationKeyType key_type,
       const std::string& key_name,
       const AsyncMethodCallback& callback) OVERRIDE {
     dbus::MethodCall method_call(
         cryptohome::kCryptohomeInterface,
         cryptohome::kCryptohomeTpmAttestationRegisterKey);
     dbus::MessageWriter writer(&method_call);
-    bool is_user_specific = (key_type == USER_KEY);
+    bool is_user_specific = (key_type == attestation::USER_KEY);
     writer.AppendBool(is_user_specific);
     writer.AppendString(key_name);
     proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                        base::Bind(&CryptohomeClientImpl::OnAsyncMethodCall,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // CryptohomeClient override.
   virtual void TpmAttestationSignEnterpriseChallenge(
-      AttestationKeyType key_type,
+      attestation::AttestationKeyType key_type,
       const std::string& key_name,
       const std::string& domain,
       const std::string& device_id,
-      AttestationChallengeOptions options,
+      attestation::AttestationChallengeOptions options,
       const std::string& challenge,
       const AsyncMethodCallback& callback) OVERRIDE {
     dbus::MethodCall method_call(
         cryptohome::kCryptohomeInterface,
         cryptohome::kCryptohomeTpmAttestationSignEnterpriseChallenge);
     dbus::MessageWriter writer(&method_call);
-    bool is_user_specific = (key_type == USER_KEY);
+    bool is_user_specific = (key_type == attestation::USER_KEY);
     writer.AppendBool(is_user_specific);
     writer.AppendString(key_name);
     writer.AppendString(domain);
     writer.AppendArrayOfBytes(reinterpret_cast<const uint8*>(device_id.data()),
                               device_id.size());
-    bool include_signed_public_key = (options & INCLUDE_SIGNED_PUBLIC_KEY);
+    bool include_signed_public_key =
+        (options & attestation::INCLUDE_SIGNED_PUBLIC_KEY);
     writer.AppendBool(include_signed_public_key);
     writer.AppendArrayOfBytes(reinterpret_cast<const uint8*>(challenge.data()),
                               challenge.size());
     proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                        base::Bind(&CryptohomeClientImpl::OnAsyncMethodCall,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // CryptohomeClient override.
   virtual void TpmAttestationSignSimpleChallenge(
-      AttestationKeyType key_type,
+      attestation::AttestationKeyType key_type,
       const std::string& key_name,
       const std::string& challenge,
       const AsyncMethodCallback& callback) OVERRIDE {
     dbus::MethodCall method_call(
         cryptohome::kCryptohomeInterface,
         cryptohome::kCryptohomeTpmAttestationSignEnterpriseChallenge);
     dbus::MessageWriter writer(&method_call);
-    bool is_user_specific = (key_type == USER_KEY);
+    bool is_user_specific = (key_type == attestation::USER_KEY);
     writer.AppendBool(is_user_specific);
     writer.AppendString(key_name);
     writer.AppendArrayOfBytes(reinterpret_cast<const uint8*>(challenge.data()),
                               challenge.size());
     proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                        base::Bind(&CryptohomeClientImpl::OnAsyncMethodCall,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // CryptohomeClient override.
   virtual void TpmAttestationGetKeyPayload(
-      AttestationKeyType key_type,
+      attestation::AttestationKeyType key_type,
       const std::string& key_name,
       const DataMethodCallback& callback) OVERRIDE {
     dbus::MethodCall method_call(
         cryptohome::kCryptohomeInterface,
         cryptohome::kCryptohomeTpmAttestationGetKeyPayload);
     dbus::MessageWriter writer(&method_call);
-    bool is_user_specific = (key_type == USER_KEY);
+    bool is_user_specific = (key_type == attestation::USER_KEY);
     writer.AppendBool(is_user_specific);
     writer.AppendString(key_name);
     proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                        base::Bind(&CryptohomeClientImpl::OnDataMethod,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // CryptohomeClient override.
   virtual void TpmAttestationSetKeyPayload(
-      AttestationKeyType key_type,
+      attestation::AttestationKeyType key_type,
       const std::string& key_name,
       const std::string& payload,
       const BoolDBusMethodCallback& callback) OVERRIDE {
     dbus::MethodCall method_call(
         cryptohome::kCryptohomeInterface,
         cryptohome::kCryptohomeTpmAttestationSetKeyPayload);
     dbus::MessageWriter writer(&method_call);
-    bool is_user_specific = (key_type == USER_KEY);
+    bool is_user_specific = (key_type == attestation::USER_KEY);
     writer.AppendBool(is_user_specific);
     writer.AppendString(key_name);
     writer.AppendArrayOfBytes(reinterpret_cast<const uint8*>(payload.data()),
                               payload.size());
     CallBoolMethod(&method_call, callback);
   }
 
  private:
   // Handles the result of AsyncXXX methods.
   void OnAsyncMethodCall(const AsyncMethodCallback& callback,
@@ skipping 431 matching lines @@
   // CryptohomeClient override.
   virtual void AsyncTpmAttestationCreateCertRequest(
       int options,
       const AsyncMethodCallback& callback) OVERRIDE {
     ReturnAsyncMethodResult(callback, true);
   }
 
   // CryptohomeClient override.
   virtual void AsyncTpmAttestationFinishCertRequest(
       const std::string& pca_response,
-      AttestationKeyType key_type,
+      attestation::AttestationKeyType key_type,
       const std::string& key_name,
       const AsyncMethodCallback& callback) OVERRIDE {
     ReturnAsyncMethodResult(callback, true);
   }
 
   // CryptohomeClient override.
   virtual void TpmAttestationDoesKeyExist(
-      AttestationKeyType key_type,
+      attestation::AttestationKeyType key_type,
       const std::string& key_name,
       const BoolDBusMethodCallback& callback) OVERRIDE {
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, false));
   }
 
   // CryptohomeClient override.
   virtual void TpmAttestationGetCertificate(
-      AttestationKeyType key_type,
+      attestation::AttestationKeyType key_type,
       const std::string& key_name,
       const DataMethodCallback& callback) OVERRIDE {
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, false, std::string()));
   }
 
   // CryptohomeClient override.
   virtual void TpmAttestationGetPublicKey(
-      AttestationKeyType key_type,
+      attestation::AttestationKeyType key_type,
       const std::string& key_name,
       const DataMethodCallback& callback) OVERRIDE {
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, false, std::string()));
   }
 
   // CryptohomeClient override.
   virtual void TpmAttestationRegisterKey(
-      AttestationKeyType key_type,
+      attestation::AttestationKeyType key_type,
       const std::string& key_name,
       const AsyncMethodCallback& callback) OVERRIDE {
     ReturnAsyncMethodResult(callback, true);
   }
 
   // CryptohomeClient override.
   virtual void TpmAttestationSignEnterpriseChallenge(
-      AttestationKeyType key_type,
+      attestation::AttestationKeyType key_type,
       const std::string& key_name,
       const std::string& domain,
       const std::string& device_id,
-      AttestationChallengeOptions options,
+      attestation::AttestationChallengeOptions options,
       const std::string& challenge,
       const AsyncMethodCallback& callback) OVERRIDE {
     ReturnAsyncMethodResult(callback, true);
   }
 
   // CryptohomeClient override.
   virtual void TpmAttestationSignSimpleChallenge(
-      AttestationKeyType key_type,
+      attestation::AttestationKeyType key_type,
       const std::string& key_name,
       const std::string& challenge,
       const AsyncMethodCallback& callback) OVERRIDE {
     ReturnAsyncMethodResult(callback, true);
   }
 
   virtual void TpmAttestationGetKeyPayload(
-      AttestationKeyType key_type,
+      attestation::AttestationKeyType key_type,
       const std::string& key_name,
       const DataMethodCallback& callback) OVERRIDE {
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, false, std::string()));
   }
 
   virtual void TpmAttestationSetKeyPayload(
-      AttestationKeyType key_type,
+      attestation::AttestationKeyType key_type,
       const std::string& key_name,
       const std::string& payload,
       const BoolDBusMethodCallback& callback) OVERRIDE {
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, false));
   }
 
 
  private:
@@ skipping 53 matching lines @@
 // static
 CryptohomeClient* CryptohomeClient::Create(DBusClientImplementationType type,
                                            dbus::Bus* bus) {
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
     return new CryptohomeClientImpl(bus);
   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
   return new CryptohomeClientStubImpl();
 }
 
 }  // namespace chromeos