Convert the encryption header parsers to be iterator-based.

components/gcm_driver/crypto/gcm_encryption_provider.cc

 // Copyright 2015 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 "components/gcm_driver/crypto/gcm_encryption_provider.h"
 
 #include <vector>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 67 matching lines @@
     const DecryptionFailedCallback& failure_callback) {
   DCHECK(key_store_);
 
   const auto& encryption_header = message.data.find(kEncryptionProperty);
   const auto& crypto_key_header = message.data.find(kCryptoKeyProperty);
 
   // Callers are expected to call IsEncryptedMessage() prior to this method.
   DCHECK(encryption_header != message.data.end());
   DCHECK(crypto_key_header != message.data.end());
 
-  std::vector<EncryptionHeaderValues> encryption_header_values;
-  if (!ParseEncryptionHeader(encryption_header->second,
-                             &encryption_header_values)) {
+  EncryptionHeaderIterator encryption_header_iterator(
+      encryption_header->second.begin(), encryption_header->second.end());
+  if (!encryption_header_iterator.GetNext()) {
     DLOG(ERROR) << "Unable to parse the value of the Encryption header";
     failure_callback.Run(DECRYPTION_FAILURE_INVALID_ENCRYPTION_HEADER);
     return;
   }
 
-  if (encryption_header_values.size() != 1u ||
-      encryption_header_values[0].salt.size() !=
+  if (encryption_header_iterator.salt().size() !=
           GCMMessageCryptographer::kSaltSize) {
     DLOG(ERROR) << "Invalid values supplied in the Encryption header";
     failure_callback.Run(DECRYPTION_FAILURE_INVALID_ENCRYPTION_HEADER);
     return;
   }
 
-  std::vector<CryptoKeyHeaderValues> crypto_key_header_values;
-  if (!ParseCryptoKeyHeader(crypto_key_header->second,
-                            &crypto_key_header_values)) {
+  CryptoKeyHeaderIterator crypto_key_header_iterator(
+      crypto_key_header->second.begin(), crypto_key_header->second.end());
+  if (!crypto_key_header_iterator.GetNext()) {
     DLOG(ERROR) << "Unable to parse the value of the Crypto-Key header";
     failure_callback.Run(DECRYPTION_FAILURE_INVALID_CRYPTO_KEY_HEADER);
     return;
   }
 
-  if (crypto_key_header_values.size() != 1u ||
-      !crypto_key_header_values[0].dh.size()) {
+  if (!crypto_key_header_iterator.dh().size()) {

[Ryan Sleevi, 2015/12/08 00:22:00]

Use .empty(), not .size(), to test for empty STL containers.

[Peter Beverloo, 2015/12/16 21:09:57]

Done.

     DLOG(ERROR) << "Invalid values supplied in the Crypto-Key header";
     failure_callback.Run(DECRYPTION_FAILURE_INVALID_CRYPTO_KEY_HEADER);
     return;
   }
 
   key_store_->GetKeys(
       app_id, base::Bind(&GCMEncryptionProvider::DecryptMessageWithKey,
                          weak_ptr_factory_.GetWeakPtr(), message,
                          success_callback, failure_callback,
-                         encryption_header_values[0].salt,
-                         crypto_key_header_values[0].dh,
-                         encryption_header_values[0].rs));
+                         encryption_header_iterator.salt(),
+                         crypto_key_header_iterator.dh(),
+                         encryption_header_iterator.rs()));
 }
 
 void GCMEncryptionProvider::DidGetPublicKey(const std::string& app_id,
                                             const PublicKeyCallback& callback,
                                             const KeyPair& pair,
                                             const std::string& auth_secret) {
   if (!pair.IsInitialized()) {
     key_store_->CreateKeys(
         app_id, base::Bind(&GCMEncryptionProvider::DidCreatePublicKey,
                            weak_ptr_factory_.GetWeakPtr(), callback));
@@ skipping 61 matching lines @@
   decrypted_message.decrypted = true;
 
   // There must be no data associated with the decrypted message at this point,
   // to make sure that we don't end up in an infinite decryption loop.
   DCHECK_EQ(0u, decrypted_message.data.size());
 
   success_callback.Run(decrypted_message);
 }
 
 }  // namespace gcm