Added multi-profile support for attestation on chromeos.

chrome/browser/chromeos/attestation/attestation_policy_observer.cc

 // Copyright (c) 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 "chrome/browser/chromeos/attestation/attestation_policy_observer.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 154 matching lines @@
 
   // Start a dbus call to check if an Enterprise Machine Key already exists.
   base::Closure on_does_exist =
       base::Bind(&AttestationPolicyObserver::GetExistingCertificate,
                  weak_factory_.GetWeakPtr());
   base::Closure on_does_not_exist =
       base::Bind(&AttestationPolicyObserver::GetNewCertificate,
                  weak_factory_.GetWeakPtr());
   cryptohome_client_->TpmAttestationDoesKeyExist(
       KEY_DEVICE,
+      std::string(),  // Not used.
       kEnterpriseMachineKey,
       base::Bind(DBusBoolRedirectCallback,
                  on_does_exist,
                  on_does_not_exist,
                  base::Bind(&AttestationPolicyObserver::Reschedule,
                             weak_factory_.GetWeakPtr()),
                  FROM_HERE));
 }
 
 void AttestationPolicyObserver::GetNewCertificate() {
   // We can reuse the dbus callback handler logic.
   attestation_flow_->GetCertificate(
       PROFILE_ENTERPRISE_MACHINE_CERTIFICATE,
       std::string(),  // Not used.
       std::string(),  // Not used.
       true,  // Force a new key to be generated.
       base::Bind(DBusStringCallback,
                  base::Bind(&AttestationPolicyObserver::UploadCertificate,
                             weak_factory_.GetWeakPtr()),
                  base::Bind(&AttestationPolicyObserver::Reschedule,
                             weak_factory_.GetWeakPtr()),
                  FROM_HERE,
                  DBUS_METHOD_CALL_SUCCESS));
 }
 
 void AttestationPolicyObserver::GetExistingCertificate() {
   cryptohome_client_->TpmAttestationGetCertificate(
       KEY_DEVICE,
+      std::string(),  // Not used.
       kEnterpriseMachineKey,
       base::Bind(DBusStringCallback,
                  base::Bind(&AttestationPolicyObserver::CheckCertificateExpiry,
                             weak_factory_.GetWeakPtr()),
                  base::Bind(&AttestationPolicyObserver::Reschedule,
                             weak_factory_.GetWeakPtr()),
                  FROM_HERE));
 }
 
 void AttestationPolicyObserver::CheckCertificateExpiry(
@@ skipping 37 matching lines @@
     // Already uploaded... nothing more to do.
     return;
   }
   UploadCertificate(certificate);
 }
 
 void AttestationPolicyObserver::GetKeyPayload(
     base::Callback<void(const std::string&)> callback) {
   cryptohome_client_->TpmAttestationGetKeyPayload(
       KEY_DEVICE,
+      std::string(),  // Not used.
       kEnterpriseMachineKey,
       base::Bind(DBusStringCallback,
                  callback,
                  base::Bind(&AttestationPolicyObserver::Reschedule,
                             weak_factory_.GetWeakPtr()),
                  FROM_HERE));
 }
 
 void AttestationPolicyObserver::OnUploadComplete(bool status) {
   if (!status)
     return;
   LOG(INFO) << "Enterprise Machine Certificate uploaded to DMServer.";
   GetKeyPayload(base::Bind(&AttestationPolicyObserver::MarkAsUploaded,
                            weak_factory_.GetWeakPtr()));
 }
 
 void AttestationPolicyObserver::MarkAsUploaded(const std::string& key_payload) {
   AttestationKeyPayload payload_pb;
   if (!key_payload.empty())
     payload_pb.ParseFromString(key_payload);
   payload_pb.set_is_certificate_uploaded(true);
   std::string new_payload;
   if (!payload_pb.SerializeToString(&new_payload)) {
     LOG(WARNING) << "Failed to serialize key payload.";
     return;
   }
   cryptohome_client_->TpmAttestationSetKeyPayload(
       KEY_DEVICE,
+      std::string(),  // Not used.
       kEnterpriseMachineKey,
       new_payload,
       base::Bind(DBusBoolRedirectCallback,
                  base::Closure(),
                  base::Closure(),
                  base::Closure(),
                  FROM_HERE));
 }
 
 void AttestationPolicyObserver::Reschedule() {
   if (++num_retries_ < kRetryLimit) {
     content::BrowserThread::PostDelayedTask(
         content::BrowserThread::UI, FROM_HERE,
         base::Bind(&AttestationPolicyObserver::Start,
                    weak_factory_.GetWeakPtr()),
         base::TimeDelta::FromSeconds(retry_delay_));
   } else {
     LOG(WARNING) << "AttestationPolicyObserver: Retry limit exceeded.";
   }
 }
 
 }  // namespace attestation
 }  // namespace chromeos