Added multi-profile support for attestation on chromeos.

chromeos/attestation/attestation_flow_unittest.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 "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "chromeos/attestation/mock_attestation_flow.h"
 #include "chromeos/cryptohome/mock_async_method_caller.h"
 #include "chromeos/dbus/mock_cryptohome_client.h"
@@ skipping 97 matching lines @@
       cryptohome::MockAsyncMethodCaller::kFakeAttestationCertRequest,
       _)).Times(1)
          .InSequence(flow_order);
 
   std::string fake_cert_response =
       cryptohome::MockAsyncMethodCaller::kFakeAttestationCertRequest;
   fake_cert_response += "_response";
   EXPECT_CALL(async_caller,
               AsyncTpmAttestationFinishCertRequest(fake_cert_response,
                                                    KEY_USER,
+                                                   "fake_email",

[bartfab (slow), 2013/10/13 16:31:35]

Could you use something with an @ symbol in it? This particular code may not
care but we had so many cases where an e-mail ended up getting canonicalized
somewhere, causing a crash because of the missing @. It is best not to create
bad precedents. Something like user@example.com would be safe.

[Darren Krahn, 2013/10/15 16:49:06]

Done.

                                                    kEnterpriseUserKey,
                                                    _))
       .Times(1)
       .InSequence(flow_order);
 
   StrictMock<MockObserver> observer;
   EXPECT_CALL(observer, MockCertificateCallback(
       true,
       cryptohome::MockAsyncMethodCaller::kFakeAttestationCert))
       .Times(1)
@@ skipping 106 matching lines @@
   EXPECT_CALL(async_caller,
               AsyncTpmAttestationCreateCertRequest(
                   PROFILE_ENTERPRISE_MACHINE_CERTIFICATE, "", "", _))
       .Times(1);
   std::string fake_cert_response =
       cryptohome::MockAsyncMethodCaller::kFakeAttestationCertRequest;
   fake_cert_response += "_response";
   EXPECT_CALL(async_caller,
               AsyncTpmAttestationFinishCertRequest(fake_cert_response,
                                                    KEY_DEVICE,
+                                                   "",
                                                    kEnterpriseMachineKey,
                                                    _))
       .Times(1);
 
   chromeos::MockCryptohomeClient client;
   EXPECT_CALL(client, TpmAttestationIsEnrolled(_))
       .WillRepeatedly(Invoke(DBusCallbackTrue));
 
   scoped_ptr<MockServerProxy> proxy(new StrictMock<MockServerProxy>());
   proxy->DeferToFake(true);
@@ skipping 105 matching lines @@
   EXPECT_CALL(async_caller,
               AsyncTpmAttestationCreateCertRequest(
                   PROFILE_ENTERPRISE_USER_CERTIFICATE, "", "", _))
       .Times(1);
   std::string fake_cert_response =
       cryptohome::MockAsyncMethodCaller::kFakeAttestationCertRequest;
   fake_cert_response += "_response";
   EXPECT_CALL(async_caller,
               AsyncTpmAttestationFinishCertRequest(fake_cert_response,
                                                    KEY_USER,
+                                                   "",
                                                    kEnterpriseUserKey,
                                                    _))
       .Times(1);
 
   chromeos::MockCryptohomeClient client;
   EXPECT_CALL(client, TpmAttestationIsEnrolled(_))
       .WillRepeatedly(Invoke(DBusCallbackTrue));
   EXPECT_CALL(client,
-              TpmAttestationDoesKeyExist(KEY_USER, kEnterpriseUserKey, _))
-      .WillRepeatedly(WithArgs<2>(Invoke(DBusCallbackFalse)));
+              TpmAttestationDoesKeyExist(KEY_USER, "", kEnterpriseUserKey, _))
+      .WillRepeatedly(WithArgs<3>(Invoke(DBusCallbackFalse)));
 
   scoped_ptr<MockServerProxy> proxy(new StrictMock<MockServerProxy>());
   proxy->DeferToFake(true);
   EXPECT_CALL(*proxy, SendCertificateRequest(
       cryptohome::MockAsyncMethodCaller::kFakeAttestationCertRequest,
       _)).Times(1);
 
   StrictMock<MockObserver> observer;
   EXPECT_CALL(observer, MockCertificateCallback(
       true,
@@ skipping 10 matching lines @@
 }
 
 TEST_F(AttestationFlowTest, GetCertificate_AlreadyExists) {
   // We're not expecting any async calls in this case; StrictMock will verify.
   StrictMock<cryptohome::MockAsyncMethodCaller> async_caller;
 
   chromeos::MockCryptohomeClient client;
   EXPECT_CALL(client, TpmAttestationIsEnrolled(_))
       .WillRepeatedly(Invoke(DBusCallbackTrue));
   EXPECT_CALL(client,
-              TpmAttestationDoesKeyExist(KEY_USER, kEnterpriseUserKey, _))
-      .WillRepeatedly(WithArgs<2>(Invoke(DBusCallbackTrue)));
+              TpmAttestationDoesKeyExist(KEY_USER, "", kEnterpriseUserKey, _))
+      .WillRepeatedly(WithArgs<3>(Invoke(DBusCallbackTrue)));
   EXPECT_CALL(client,
-              TpmAttestationGetCertificate(KEY_USER, kEnterpriseUserKey, _))
-      .WillRepeatedly(WithArgs<2>(Invoke(FakeDBusData("fake_cert"))));
+              TpmAttestationGetCertificate(KEY_USER, "", kEnterpriseUserKey, _))
+      .WillRepeatedly(WithArgs<3>(Invoke(FakeDBusData("fake_cert"))));
 
   // We're not expecting any server calls in this case; StrictMock will verify.
   scoped_ptr<MockServerProxy> proxy(new StrictMock<MockServerProxy>());
 
   StrictMock<MockObserver> observer;
   EXPECT_CALL(observer, MockCertificateCallback(true, "fake_cert")).Times(1);
   AttestationFlow::CertificateCallback mock_callback = base::Bind(
       &MockObserver::MockCertificateCallback,
       base::Unretained(&observer));
 
   scoped_ptr<ServerProxy> proxy_interface(proxy.release());
   AttestationFlow flow(&async_caller, &client, proxy_interface.Pass());
   flow.GetCertificate(PROFILE_ENTERPRISE_USER_CERTIFICATE, "", "", false,
                       mock_callback);
   Run();
 }
 
 }  // namespace attestation
 }  // namespace chromeos