Support for the new WebCrypto digest by chunks API.

content/child/webcrypto/shared_crypto_unittest.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 "content/child/webcrypto/shared_crypto.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 631 matching lines @@
     std::vector<uint8> test_input = GetBytesFromHexString(test, "input");
     std::vector<uint8> test_output = GetBytesFromHexString(test, "output");
 
     blink::WebArrayBuffer output;
     ASSERT_STATUS_SUCCESS(
         Digest(test_algorithm, CryptoData(test_input), &output));
     EXPECT_TRUE(ArrayBufferMatches(test_output, output));
   }
 }
 
+TEST_F(SharedCryptoTest, DigestSampleSetsInChunks) {
+  scoped_ptr<base::ListValue> tests;
+  ASSERT_TRUE(ReadJsonTestFileToList("digest.json", &tests));
+
+  for (size_t test_index = 0; test_index < tests->GetSize(); ++test_index) {
+    SCOPED_TRACE(test_index);
+    base::DictionaryValue* test;
+    ASSERT_TRUE(tests->GetDictionary(test_index, &test));
+
+    blink::WebCryptoAlgorithm test_algorithm =
+        GetDigestAlgorithm(test, "algorithm");
+    std::vector<uint8> test_input = GetBytesFromHexString(test, "input");
+    std::vector<uint8> test_output = GetBytesFromHexString(test, "output");
+
+    // Test the chunk version of the digest functions. Test with 129 byte chunks
+    // because the SHA-512 chunk size is 128 bytes.
+    unsigned char* output;
+    unsigned int output_length;
+    static const size_t kChunkSizeBytes = 129;
+    size_t length = test_input.size();
+    scoped_ptr<blink::WebCryptoDigestor> digestor(
+        CreateDigestor(test_algorithm.id()));
+    std::vector<uint8>::iterator begin = test_input.begin();
+    size_t chunk_index = 0;
+    while (begin != test_input.end()) {
+      size_t chunk_length = std::min(kChunkSizeBytes, length - chunk_index);
+      std::vector<uint8> chunk(begin, begin + chunk_length);

[eroman, 2014/03/26 01:43:54]

Not necessary to copy into a std::vector<>.

However I think it is actually a good idea to, because it is more likely to
catch illegal memory accesses this way.

[jww, 2014/03/26 18:49:40]

Done.

+      EXPECT_TRUE(digestor->consume(chunk.data(), chunk.size()));
+      chunk_index = chunk_index + chunk_length;
+      begin = begin + chunk_length;
+    }
+    EXPECT_TRUE(digestor->finish(output, output_length));
+    ExpectVectorMatches(test_output,
+                        std::vector<uint8>(output, output + output_length));
+  }
+}
+
 TEST_F(SharedCryptoTest, HMACSampleSets) {
   scoped_ptr<base::ListValue> tests;
   ASSERT_TRUE(ReadJsonTestFileToList("hmac.json", &tests));
   // TODO(padolph): Missing known answer tests for HMAC SHA384, and SHA512.
   for (size_t test_index = 0; test_index < tests->GetSize(); ++test_index) {
     SCOPED_TRACE(test_index);
     base::DictionaryValue* test;
     ASSERT_TRUE(tests->GetDictionary(test_index, &test));
 
     blink::WebCryptoAlgorithm test_hash = GetDigestAlgorithm(test, "hash");
@@ skipping 2385 matching lines @@
                           algorithm,
                           CreateAesCbcAlgorithm(std::vector<uint8>(0, 16)),
                           true,
                           blink::WebCryptoKeyUsageEncrypt,
                           &unwrapped_key));
 }
 
 }  // namespace webcrypto
 
 }  // namespace content