Reland: Minor cleanup in EasyUnlockClient

chrome/browser/chromeos/login/easy_unlock/easy_unlock_create_keys_operation.cc

 // Copyright 2014 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/login/easy_unlock/easy_unlock_create_keys_operation.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 135 matching lines @@
     callback_.Run(false);
     return;
   }
 
   esk_ = esk;
   GeneratePayload();
 }
 
 void EasyUnlockCreateKeysOperation::ChallengeCreator::GeneratePayload() {
   // Work around to get HeaderAndBody bytes to use as challenge payload.
+  EasyUnlockClient::CreateSecureMessageOptions options;
+  options.key = esk_;
+  // TODO(xiyuan, tbarzic): Wrap in a GenericPublicKey proto.
+  options.verification_key_id = tpm_pub_key_;
+  options.encryption_type = easy_unlock::kEncryptionTypeAES256CBC;
+  options.signature_type = easy_unlock::kSignatureTypeHMACSHA256;
+
   easy_unlock_client_->CreateSecureMessage(
       session_key_,
-      esk_,
-      std::string(),  // associated data
-      std::string(),  // public meta
-      tpm_pub_key_,   // TODO(xiyuan): Wrap in a GenericPublicKey proto.
-      std::string(),  // decryption key id
-      easy_unlock::kEncryptionTypeAES256CBC,
-      easy_unlock::kSignatureTypeHMACSHA256,
+      options,
       base::Bind(&ChallengeCreator::OnPayloadMessageGenerated,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void
 EasyUnlockCreateKeysOperation::ChallengeCreator::OnPayloadMessageGenerated(
     const std::string& payload_message) {
+  EasyUnlockClient::UnwrapSecureMessageOptions options;
+  options.key = esk_;
+  options.encryption_type = easy_unlock::kEncryptionTypeAES256CBC;
+  options.signature_type = easy_unlock::kSignatureTypeHMACSHA256;
+
   easy_unlock_client_->UnwrapSecureMessage(
       payload_message,
-      esk_,
-      std::string(),  // associated data
-      easy_unlock::kEncryptionTypeAES256CBC,
-      easy_unlock::kSignatureTypeHMACSHA256,
+      options,
       base::Bind(&ChallengeCreator::OnPayloadGenerated,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void EasyUnlockCreateKeysOperation::ChallengeCreator::OnPayloadGenerated(
     const std::string& payload) {
   if (payload.empty()) {
     LOG(ERROR) << "Easy unlock failed to generate challenge payload.";
     callback_.Run(false);
     return;
   }
 
+  EasyUnlockClient::CreateSecureMessageOptions options;
+  options.key = esk_;
+  options.decryption_key_id = ec_public_key_;
+  options.encryption_type = easy_unlock::kEncryptionTypeAES256CBC;
+  options.signature_type = easy_unlock::kSignatureTypeHMACSHA256;
+
   easy_unlock_client_->CreateSecureMessage(
       payload,
-      esk_,
-      std::string(),   // associated data
-      std::string(),   // public meta
-      std::string(),   // verification key id
-      ec_public_key_,  // decryption key id
-      easy_unlock::kEncryptionTypeAES256CBC,
-      easy_unlock::kSignatureTypeHMACSHA256,
+      options,
       base::Bind(&ChallengeCreator::OnChallengeGenerated,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void EasyUnlockCreateKeysOperation::ChallengeCreator::OnChallengeGenerated(
     const std::string& challenge) {
   if (challenge.empty()) {
     LOG(ERROR) << "Easy unlock failed to generate challenge.";
     callback_.Run(false);
     return;
@@ skipping 145 matching lines @@
     LOG(ERROR) << "Easy unlock failed to create key, code=" << return_code;
     callback_.Run(false);
     return;
   }
 
   ++key_creation_index_;
   CreateKeyForDeviceAtIndex(key_creation_index_);
 }
 
 }  // namespace chromeos