[refactor] Remove WebArrayBuffer from unittests, since now using std::vector.

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>
 
 #include "base/basictypes.h"
 #include "base/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "content/child/webcrypto/crypto_data.h"
 #include "content/child/webcrypto/status.h"
 #include "content/child/webcrypto/webcrypto_util.h"
 #include "content/public/common/content_paths.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "third_party/WebKit/public/platform/WebArrayBuffer.h"
 #include "third_party/WebKit/public/platform/WebCryptoAlgorithm.h"
 #include "third_party/WebKit/public/platform/WebCryptoAlgorithmParams.h"
 #include "third_party/WebKit/public/platform/WebCryptoKey.h"
 #include "third_party/WebKit/public/platform/WebCryptoKeyAlgorithm.h"
 #include "third_party/re2/re2/re2.h"
 
 // The OpenSSL implementation of WebCrypto is less complete, so don't run all of
 // the tests: http://crbug.com/267888
 #if defined(USE_OPENSSL)
 #define MAYBE(test_name) DISABLED_##test_name
 #else
 #define MAYBE(test_name) test_name
 #endif
 
+#define EXPECT_BYTES_EQ(expected, actual) \
+  EXPECT_EQ(CryptoData(expected), CryptoData(actual))
+
+#define EXPECT_BYTES_EQ_HEX(expected_hex, actual_bytes) \
+  EXPECT_BYTES_EQ(HexStringToBytes(expected_hex), actual_bytes)
+
 namespace content {
 
 namespace webcrypto {
 
+// These functions are used by GTEST to support EXPECT_EQ() for
+// webcrypto::Status and webcrypto::CryptoData
+
 void PrintTo(const Status& status, ::std::ostream* os) {
   if (status.IsSuccess())
     *os << "Success";
   else
     *os << "Error type: " << status.error_type()
         << " Error details: " << status.error_details();
 }
 
 bool operator==(const content::webcrypto::Status& a,
                 const content::webcrypto::Status& b) {
   if (a.IsSuccess() != b.IsSuccess())
     return false;
   if (a.IsSuccess())
     return true;
   return a.error_type() == b.error_type() &&
          a.error_details() == b.error_details();
 }
 
 bool operator!=(const content::webcrypto::Status& a,
                 const content::webcrypto::Status& b) {
   return !(a == b);
 }
 
+void PrintTo(const CryptoData& data, ::std::ostream* os) {
+  *os << "[" << base::HexEncode(data.bytes(), data.byte_length()) << "]";
+}
+
+bool operator==(const content::webcrypto::CryptoData& a,
+                const content::webcrypto::CryptoData& b) {
+  return a.byte_length() == b.byte_length() &&
+         memcmp(a.bytes(), b.bytes(), a.byte_length()) == 0;
+}
+
 namespace {
 
 // -----------------------------------------------------------------------------
-// TODO(eroman): Remove these helpers and convert all of the tests to using the
-//               std::vector<> flavor of functions directly.
-// -----------------------------------------------------------------------------
 
-blink::WebArrayBuffer CreateArrayBuffer(const uint8* data,
-                                        unsigned int data_size) {
-  blink::WebArrayBuffer buffer = blink::WebArrayBuffer::create(data_size, 1);
-  DCHECK(!buffer.isNull());
-  if (data_size)  // data_size == 0 might mean the data pointer is invalid
-    memcpy(buffer.data(), data, data_size);
-  return buffer;
-}
-
-void AssignWebArrayBuffer(const std::vector<uint8>& in,
-                          blink::WebArrayBuffer* out) {
-  *out = CreateArrayBuffer(Uint8VectorStart(in), in.size());
-}
-
-Status Encrypt(const blink::WebCryptoAlgorithm& algorithm,
-               const blink::WebCryptoKey& key,
-               const CryptoData& data,
-               blink::WebArrayBuffer* web_buffer) {
-  std::vector<uint8> buffer;
-  Status status = Encrypt(algorithm, key, data, &buffer);
-  AssignWebArrayBuffer(buffer, web_buffer);
-  return status;
-}
-
-Status Decrypt(const blink::WebCryptoAlgorithm& algorithm,
-               const blink::WebCryptoKey& key,
-               const CryptoData& data,
-               blink::WebArrayBuffer* web_buffer) {
-  std::vector<uint8> buffer;
-  Status status = Decrypt(algorithm, key, data, &buffer);
-  AssignWebArrayBuffer(buffer, web_buffer);
-  return status;
-}
-
-Status Digest(const blink::WebCryptoAlgorithm& algorithm,
-              const CryptoData& data,
-              blink::WebArrayBuffer* web_buffer) {
-  std::vector<uint8> buffer;
-  Status status = Digest(algorithm, data, &buffer);
-  AssignWebArrayBuffer(buffer, web_buffer);
-  return status;
-}
-
-Status ExportKey(blink::WebCryptoKeyFormat format,
-                 const blink::WebCryptoKey& key,
-                 blink::WebArrayBuffer* web_buffer) {
-  std::vector<uint8> buffer;
-  Status status = webcrypto::ExportKey(format, key, &buffer);
-  AssignWebArrayBuffer(buffer, web_buffer);
-  return status;
-}
-
-Status Sign(const blink::WebCryptoAlgorithm& algorithm,
-            const blink::WebCryptoKey& key,
-            const CryptoData& data,
-            blink::WebArrayBuffer* web_buffer) {
-  std::vector<uint8> buffer;
-
-  Status status = Sign(algorithm, key, data, &buffer);
-  AssignWebArrayBuffer(buffer, web_buffer);
-  return status;
-}
-
-Status WrapKey(blink::WebCryptoKeyFormat format,
-               const blink::WebCryptoKey& wrapping_key,
-               const blink::WebCryptoKey& key_to_wrap,
-               const blink::WebCryptoAlgorithm& wrapping_algorithm,
-               blink::WebArrayBuffer* web_buffer) {
-  std::vector<uint8> buffer;
-
-  Status status = webcrypto::WrapKey(
-      format, wrapping_key, key_to_wrap, wrapping_algorithm, &buffer);
-  AssignWebArrayBuffer(buffer, web_buffer);
-  return status;
-}
-
-// -----------------------------------------------------------------------------
-
 // TODO(eroman): For Linux builds using system NSS, AES-GCM support is a
 // runtime dependency. Test it by trying to import a key.
 // TODO(padolph): Consider caching the result of the import key test.
 bool SupportsAesGcm() {
   std::vector<uint8> key_raw(16, 0);
 
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
   Status status = ImportKey(blink::WebCryptoKeyFormatRaw,
                             CryptoData(key_raw),
                             CreateAlgorithm(blink::WebCryptoAlgorithmIdAesGcm),
@@ skipping 85 matching lines @@
   corrupted_data[corrupted_data.size() / 2] ^= 0x01;
   return corrupted_data;
 }
 
 std::vector<uint8> HexStringToBytes(const std::string& hex) {
   std::vector<uint8> bytes;
   base::HexStringToBytes(hex, &bytes);
   return bytes;
 }
 
-::testing::AssertionResult ArrayBufferMatches(
-    const std::vector<uint8>& expected,
-    const blink::WebArrayBuffer& actual) {
-  if (base::HexEncode(webcrypto::Uint8VectorStart(expected), expected.size()) ==
-      base::HexEncode(actual.data(), actual.byteLength()))
-    return ::testing::AssertionSuccess();
-  return ::testing::AssertionFailure();
-}
-
-void ExpectCryptoDataMatchesHex(const std::string& expected_hex,
-                                const CryptoData& actual) {
-  EXPECT_STRCASEEQ(
-      expected_hex.c_str(),
-      base::HexEncode(actual.bytes(), actual.byte_length()).c_str());
-}
-
-void ExpectArrayBufferMatchesHex(const std::string& expected_hex,
-                                 const blink::WebArrayBuffer& array_buffer) {
-  ExpectCryptoDataMatchesHex(expected_hex, CryptoData(array_buffer));
-}
-
-void ExpectVectorMatches(const std::vector<uint8>& expected,
-                         const std::vector<uint8>& actual) {
-  EXPECT_EQ(
-      base::HexEncode(webcrypto::Uint8VectorStart(expected), expected.size()),
-      base::HexEncode(webcrypto::Uint8VectorStart(actual), actual.size()));
-}
-
 std::vector<uint8> MakeJsonVector(const std::string& json_string) {
   return std::vector<uint8>(json_string.begin(), json_string.end());
 }
 
 std::vector<uint8> MakeJsonVector(const base::DictionaryValue& dict) {
   std::string json;
   base::JSONWriter::Write(&dict, &json);
   return MakeJsonVector(json);
 }
 
@@ skipping 75 matching lines @@
                                              const char* property_name) {
   std::string algorithm_name;
   if (!dict->GetString(property_name, &algorithm_name)) {
     EXPECT_TRUE(false) << "Couldn't get string property: " << property_name;
     return blink::WebCryptoAlgorithm::createNull();
   }
 
   struct {
     const char* name;
     blink::WebCryptoAlgorithmId id;
-  } kDigestNameToId[] = {{"sha-1", blink::WebCryptoAlgorithmIdSha1},
-                         {"sha-256", blink::WebCryptoAlgorithmIdSha256},
-                         {"sha-384", blink::WebCryptoAlgorithmIdSha384},
-                         {"sha-512", blink::WebCryptoAlgorithmIdSha512}, };
+  } kDigestNameToId[] = {
+        {"sha-1", blink::WebCryptoAlgorithmIdSha1},
+        {"sha-256", blink::WebCryptoAlgorithmIdSha256},
+        {"sha-384", blink::WebCryptoAlgorithmIdSha384},
+        {"sha-512", blink::WebCryptoAlgorithmIdSha512},
+    };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kDigestNameToId); ++i) {
     if (kDigestNameToId[i].name == algorithm_name)
       return CreateAlgorithm(kDigestNameToId[i].id);
   }
 
   return blink::WebCryptoAlgorithm::createNull();
 }
 
 // Helper for ImportJwkFailures and ImportJwkOctFailures. Restores the JWK JSON
@@ skipping 16 matching lines @@
   dict->SetString("use", "enc");
   dict->SetBoolean("ext", false);
   dict->SetString(
       "n",
       "qLOyhK-OtQs4cDSoYPFGxJGfMYdjzWxVmMiuSBGh4KvEx-CwgtaTpef87Wdc9GaFEncsDLxk"
       "p0LGxjD1M8jMcvYq6DPEC_JYQumEu3i9v5fAEH1VvbZi9cTg-rmEXLUUjvc5LdOq_5OuHmtm"
       "e7PUJHYW1PW6ENTP0ibeiNOfFvs");
   dict->SetString("e", "AQAB");
 }
 
-// Determines if two ArrayBuffers have identical content.
-bool ArrayBuffersEqual(const blink::WebArrayBuffer& a,
-                       const blink::WebArrayBuffer& b) {
-  return a.byteLength() == b.byteLength() &&
-         memcmp(a.data(), b.data(), a.byteLength()) == 0;
-}
-
-// Given a vector of WebArrayBuffers, determines if there are any copies.
-bool CopiesExist(std::vector<blink::WebArrayBuffer> bufs) {
+// Returns true if any of the vectors in the input list have identical content.
+// Dumb O(n^2) implementation but should be fast enough for the input sizes that
+// are used.
+bool CopiesExist(const std::vector<std::vector<uint8> >& bufs) {
   for (size_t i = 0; i < bufs.size(); ++i) {
     for (size_t j = i + 1; j < bufs.size(); ++j) {
-      if (ArrayBuffersEqual(bufs[i], bufs[j]))
+      if (CryptoData(bufs[i]) == CryptoData(bufs[j]))
         return true;
     }
   }
   return false;
 }
 
 blink::WebCryptoAlgorithm CreateAesKeyGenAlgorithm(
     blink::WebCryptoAlgorithmId aes_alg_id,
     unsigned short length) {
   return blink::WebCryptoAlgorithm::adoptParamsAndCreate(
@@ skipping 123 matching lines @@
                      const std::vector<uint8>& iv,
                      const std::vector<uint8>& additional_data,
                      unsigned int tag_length_bits,
                      const std::vector<uint8>& plain_text,
                      std::vector<uint8>* cipher_text,
                      std::vector<uint8>* authentication_tag) {
   EXPECT_TRUE(SupportsAesGcm());
   blink::WebCryptoAlgorithm algorithm =
       CreateAesGcmAlgorithm(iv, additional_data, tag_length_bits);
 
-  blink::WebArrayBuffer output;
+  std::vector<uint8> output;
   Status status = Encrypt(algorithm, key, CryptoData(plain_text), &output);
   if (status.IsError())
     return status;
 
-  if (output.byteLength() * 8 < tag_length_bits) {
-    EXPECT_TRUE(false);
+  if ((tag_length_bits % 8) != 0) {
+    EXPECT_TRUE(false) << "Encrypt should have failed.";
+    return Status::OperationError();
+  }
+
+  size_t tag_length_bytes = tag_length_bits / 8;
+
+  if (tag_length_bytes > output.size()) {
+    EXPECT_TRUE(false) << "tag length is larger than output";
     return Status::OperationError();
   }
 
   // The encryption result is cipher text with authentication tag appended.
-  cipher_text->assign(static_cast<uint8*>(output.data()),
-                      static_cast<uint8*>(output.data()) +
-                          (output.byteLength() - tag_length_bits / 8));
-  authentication_tag->assign(
-      static_cast<uint8*>(output.data()) + cipher_text->size(),
-      static_cast<uint8*>(output.data()) + output.byteLength());
+  cipher_text->assign(output.begin(),
+                      output.begin() + (output.size() - tag_length_bytes));
+  authentication_tag->assign(output.begin() + cipher_text->size(),
+                             output.end());
 
   return Status::Success();
 }
 
 Status AesGcmDecrypt(const blink::WebCryptoKey& key,
                      const std::vector<uint8>& iv,
                      const std::vector<uint8>& additional_data,
                      unsigned int tag_length_bits,
                      const std::vector<uint8>& cipher_text,
                      const std::vector<uint8>& authentication_tag,
-                     blink::WebArrayBuffer* plain_text) {
+                     std::vector<uint8>* plain_text) {
   EXPECT_TRUE(SupportsAesGcm());
   blink::WebCryptoAlgorithm algorithm =
       CreateAesGcmAlgorithm(iv, additional_data, tag_length_bits);
 
   // Join cipher text and authentication tag.
   std::vector<uint8> cipher_text_with_tag;
   cipher_text_with_tag.reserve(cipher_text.size() + authentication_tag.size());
   cipher_text_with_tag.insert(
       cipher_text_with_tag.end(), cipher_text.begin(), cipher_text.end());
   cipher_text_with_tag.insert(cipher_text_with_tag.end(),
@@ skipping 21 matching lines @@
                             bool extractable,
                             blink::WebCryptoKeyUsageMask usage_mask,
                             blink::WebCryptoKey* key) {
   return ImportKeyJwk(CryptoData(MakeJsonVector(dict)),
                       algorithm,
                       extractable,
                       usage_mask,
                       key);
 }
 
-// Parses an ArrayBuffer of JSON into a dictionary.
+// Parses a vector of JSON into a dictionary.
 scoped_ptr<base::DictionaryValue> GetJwkDictionary(
-    const blink::WebArrayBuffer& json) {
-  base::StringPiece json_string(reinterpret_cast<const char*>(json.data()),
-                                json.byteLength());
+    const std::vector<uint8>& json) {
+  base::StringPiece json_string(
+      reinterpret_cast<const char*>(Uint8VectorStart(json)), json.size());
   base::Value* value = base::JSONReader::Read(json_string);
   EXPECT_TRUE(value);
   base::DictionaryValue* dict_value = NULL;
   value->GetAsDictionary(&dict_value);
   return scoped_ptr<base::DictionaryValue>(dict_value);
 }
 
 // Verifies the input dictionary contains the expected values. Exact matches are
 // required on the fields examined.
 ::testing::AssertionResult VerifyJwk(
@@ skipping 36 matching lines @@
   if (status.IsError())
     return ::testing::AssertionFailure() << "Failure extracting 'key_ops'";
   if (key_ops_mask != use_mask_expected)
     return ::testing::AssertionFailure()
            << "Expected 'key_ops' mask to be " << use_mask_expected
            << " but found " << key_ops_mask << " (" << value_string << ")";
 
   return ::testing::AssertionSuccess();
 }
 
-// Verifies that the JSON in the input ArrayBuffer contains the provided
+// Verifies that the JSON in the input vector contains the provided
 // expected values. Exact matches are required on the fields examined.
 ::testing::AssertionResult VerifySecretJwk(
-    const blink::WebArrayBuffer& json,
+    const std::vector<uint8>& json,
     const std::string& alg_expected,
     const std::string& k_expected_hex,
     blink::WebCryptoKeyUsageMask use_mask_expected) {
   scoped_ptr<base::DictionaryValue> dict = GetJwkDictionary(json);
   if (!dict.get() || dict->empty())
     return ::testing::AssertionFailure() << "JSON parsing failed";
 
   // ---- k
   std::string value_string;
   if (!dict->GetString("k", &value_string))
     return ::testing::AssertionFailure() << "Missing 'k'";
   std::string k_value;
   if (!webcrypto::Base64DecodeUrlSafe(value_string, &k_value))
     return ::testing::AssertionFailure() << "Base64DecodeUrlSafe(k) failed";
   if (!LowerCaseEqualsASCII(base::HexEncode(k_value.data(), k_value.size()),
                             k_expected_hex.c_str())) {
     return ::testing::AssertionFailure() << "Expected 'k' to be "
                                          << k_expected_hex
                                          << " but found something different";
   }
 
   return VerifyJwk(dict, "oct", alg_expected, use_mask_expected);
 }
 
-// Verifies that the JSON in the input ArrayBuffer contains the provided
+// Verifies that the JSON in the input vector contains the provided
 // expected values. Exact matches are required on the fields examined.
 ::testing::AssertionResult VerifyPublicJwk(
-    const blink::WebArrayBuffer& json,
+    const std::vector<uint8>& json,
     const std::string& alg_expected,
     const std::string& n_expected_hex,
     const std::string& e_expected_hex,
     blink::WebCryptoKeyUsageMask use_mask_expected) {
   scoped_ptr<base::DictionaryValue> dict = GetJwkDictionary(json);
   if (!dict.get() || dict->empty())
     return ::testing::AssertionFailure() << "JSON parsing failed";
 
   // ---- n
   std::string value_string;
@@ skipping 94 matching lines @@
   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");
 
-    blink::WebArrayBuffer output;
+    std::vector<uint8> output;
     ASSERT_EQ(Status::Success(),
               Digest(test_algorithm, CryptoData(test_input), &output));
-    EXPECT_TRUE(ArrayBufferMatches(test_output, output));
+    EXPECT_BYTES_EQ(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;
@@ skipping 16 matching lines @@
     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);
       ASSERT_TRUE(chunk.size() > 0);
       EXPECT_TRUE(digestor->consume(&chunk.front(), 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));
+    EXPECT_BYTES_EQ(test_output, CryptoData(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;
@@ skipping 13 matching lines @@
 
     blink::WebCryptoKey key = ImportSecretKeyFromRaw(
         test_key,
         importAlgorithm,
         blink::WebCryptoKeyUsageSign | blink::WebCryptoKeyUsageVerify);
 
     EXPECT_EQ(test_hash.id(), key.algorithm().hmacParams()->hash().id());
     EXPECT_EQ(test_key.size() * 8, key.algorithm().hmacParams()->lengthBits());
 
     // Verify exported raw key is identical to the imported data
-    blink::WebArrayBuffer raw_key;
+    std::vector<uint8> raw_key;
     EXPECT_EQ(Status::Success(),
               ExportKey(blink::WebCryptoKeyFormatRaw, key, &raw_key));
-    EXPECT_TRUE(ArrayBufferMatches(test_key, raw_key));
+    EXPECT_BYTES_EQ(test_key, raw_key);
 
-    blink::WebArrayBuffer output;
+    std::vector<uint8> output;
 
     ASSERT_EQ(Status::Success(),
               Sign(algorithm, key, CryptoData(test_message), &output));
 
-    EXPECT_TRUE(ArrayBufferMatches(test_mac, output));
+    EXPECT_BYTES_EQ(test_mac, output);
 
     bool signature_match = false;
     EXPECT_EQ(Status::Success(),
               VerifySignature(algorithm,
                               key,
                               CryptoData(output),
                               CryptoData(test_message),
                               &signature_match));
     EXPECT_TRUE(signature_match);
 
     // Ensure truncated signature does not verify by passing one less byte.
-    EXPECT_EQ(Status::Success(),
-              VerifySignature(
-                  algorithm,
-                  key,
-                  CryptoData(static_cast<const unsigned char*>(output.data()),
-                             output.byteLength() - 1),
-                  CryptoData(test_message),
-                  &signature_match));
+    EXPECT_EQ(
+        Status::Success(),
+        VerifySignature(algorithm,
+                        key,
+                        CryptoData(Uint8VectorStart(output), output.size() - 1),
+                        CryptoData(test_message),
+                        &signature_match));
     EXPECT_FALSE(signature_match);
 
     // Ensure truncated signature does not verify by passing no bytes.
     EXPECT_EQ(Status::Success(),
               VerifySignature(algorithm,
                               key,
                               CryptoData(),
                               CryptoData(test_message),
                               &signature_match));
     EXPECT_FALSE(signature_match);
@@ skipping 12 matching lines @@
 }
 
 TEST_F(SharedCryptoTest, AesCbcFailures) {
   const std::string key_hex = "2b7e151628aed2a6abf7158809cf4f3c";
   blink::WebCryptoKey key = ImportSecretKeyFromRaw(
       HexStringToBytes(key_hex),
       CreateAlgorithm(blink::WebCryptoAlgorithmIdAesCbc),
       blink::WebCryptoKeyUsageEncrypt | blink::WebCryptoKeyUsageDecrypt);
 
   // Verify exported raw key is identical to the imported data
-  blink::WebArrayBuffer raw_key;
+  std::vector<uint8> raw_key;
   EXPECT_EQ(Status::Success(),
             ExportKey(blink::WebCryptoKeyFormatRaw, key, &raw_key));
-  ExpectArrayBufferMatchesHex(key_hex, raw_key);
+  EXPECT_BYTES_EQ_HEX(key_hex, raw_key);
 
-  blink::WebArrayBuffer output;
+  std::vector<uint8> output;
 
   // Use an invalid |iv| (fewer than 16 bytes)
   {
     std::vector<uint8> input(32);
     std::vector<uint8> iv;
     EXPECT_EQ(Status::ErrorIncorrectSizeAesCbcIv(),
               Encrypt(webcrypto::CreateAesCbcAlgorithm(iv),
                       key,
                       CryptoData(input),
                       &output));
@@ skipping 76 matching lines @@
         GetBytesFromHexString(test, "cipher_text");
 
     blink::WebCryptoKey key = ImportSecretKeyFromRaw(
         test_key,
         CreateAlgorithm(blink::WebCryptoAlgorithmIdAesCbc),
         blink::WebCryptoKeyUsageEncrypt | blink::WebCryptoKeyUsageDecrypt);
 
     EXPECT_EQ(test_key.size() * 8, key.algorithm().aesParams()->lengthBits());
 
     // Verify exported raw key is identical to the imported data
-    blink::WebArrayBuffer raw_key;
+    std::vector<uint8> raw_key;
     EXPECT_EQ(Status::Success(),
               ExportKey(blink::WebCryptoKeyFormatRaw, key, &raw_key));
-    EXPECT_TRUE(ArrayBufferMatches(test_key, raw_key));
+    EXPECT_BYTES_EQ(test_key, raw_key);
 
-    blink::WebArrayBuffer output;
+    std::vector<uint8> output;
 
     // Test encryption.
     EXPECT_EQ(Status::Success(),
               Encrypt(webcrypto::CreateAesCbcAlgorithm(test_iv),
                       key,
                       CryptoData(test_plain_text),
                       &output));
-    EXPECT_TRUE(ArrayBufferMatches(test_cipher_text, output));
+    EXPECT_BYTES_EQ(test_cipher_text, output);
 
     // Test decryption.
     EXPECT_EQ(Status::Success(),
               Decrypt(webcrypto::CreateAesCbcAlgorithm(test_iv),
                       key,
                       CryptoData(test_cipher_text),
                       &output));
-    EXPECT_TRUE(ArrayBufferMatches(test_plain_text, output));
+    EXPECT_BYTES_EQ(test_plain_text, output);
 
     const unsigned int kAesCbcBlockSize = 16;
 
     // Decrypt with a padding error by stripping the last block. This also ends
     // up testing decryption over empty cipher text.
     if (test_cipher_text.size() >= kAesCbcBlockSize) {
       EXPECT_EQ(Status::OperationError(),
                 Decrypt(CreateAesCbcAlgorithm(test_iv),
                         key,
                         CryptoData(&test_cipher_text[0],
@@ skipping 19 matching lines @@
   // allowed key length.
   std::vector<blink::WebCryptoAlgorithm> algorithm;
   const unsigned short kKeyLength[] = {128, 192, 256};
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kKeyLength); ++i) {
     algorithm.push_back(CreateAesCbcKeyGenAlgorithm(kKeyLength[i]));
     algorithm.push_back(CreateAesKwKeyGenAlgorithm(kKeyLength[i]));
     if (SupportsAesGcm())
       algorithm.push_back(CreateAesGcmKeyGenAlgorithm(kKeyLength[i]));
   }
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
-  std::vector<blink::WebArrayBuffer> keys;
-  blink::WebArrayBuffer key_bytes;
+  std::vector<std::vector<uint8> > keys;
+  std::vector<uint8> key_bytes;
   for (size_t i = 0; i < algorithm.size(); ++i) {
     SCOPED_TRACE(i);
     // Generate a small sample of keys.
     keys.clear();
     for (int j = 0; j < 16; ++j) {
       ASSERT_EQ(Status::Success(),
                 GenerateSecretKey(algorithm[i], true, 0, &key));
       EXPECT_TRUE(key.handle());
       EXPECT_EQ(blink::WebCryptoKeyTypeSecret, key.type());
       ASSERT_EQ(Status::Success(),
                 ExportKey(blink::WebCryptoKeyFormatRaw, key, &key_bytes));
-      EXPECT_EQ(key_bytes.byteLength() * 8,
+      EXPECT_EQ(key_bytes.size() * 8,
                 key.algorithm().aesParams()->lengthBits());
       keys.push_back(key_bytes);
     }
     // Ensure all entries in the key sample set are unique. This is a simplistic
     // estimate of whether the generated keys appear random.
     EXPECT_FALSE(CopiesExist(keys));
   }
 }
 
 TEST_F(SharedCryptoTest, MAYBE(GenerateKeyAesBadLength)) {
@@ skipping 10 matching lines @@
     if (SupportsAesGcm()) {
       EXPECT_EQ(Status::ErrorGenerateKeyLength(),
                 GenerateSecretKey(
                     CreateAesGcmKeyGenAlgorithm(kKeyLen[i]), true, 0, &key));
     }
   }
 }
 
 TEST_F(SharedCryptoTest, MAYBE(GenerateKeyHmac)) {
   // Generate a small sample of HMAC keys.
-  std::vector<blink::WebArrayBuffer> keys;
+  std::vector<std::vector<uint8> > keys;
   for (int i = 0; i < 16; ++i) {
-    blink::WebArrayBuffer key_bytes;
+    std::vector<uint8> key_bytes;
     blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
     blink::WebCryptoAlgorithm algorithm =
         CreateHmacKeyGenAlgorithm(blink::WebCryptoAlgorithmIdSha1, 512);
     ASSERT_EQ(Status::Success(), GenerateSecretKey(algorithm, true, 0, &key));
     EXPECT_FALSE(key.isNull());
     EXPECT_TRUE(key.handle());
     EXPECT_EQ(blink::WebCryptoKeyTypeSecret, key.type());
     EXPECT_EQ(blink::WebCryptoAlgorithmIdHmac, key.algorithm().id());
     EXPECT_EQ(blink::WebCryptoAlgorithmIdSha1,
               key.algorithm().hmacParams()->hash().id());
     EXPECT_EQ(512u, key.algorithm().hmacParams()->lengthBits());
 
-    blink::WebArrayBuffer raw_key;
+    std::vector<uint8> raw_key;
     ASSERT_EQ(Status::Success(),
               ExportKey(blink::WebCryptoKeyFormatRaw, key, &raw_key));
-    EXPECT_EQ(64U, raw_key.byteLength());
+    EXPECT_EQ(64U, raw_key.size());
     keys.push_back(raw_key);
   }
   // Ensure all entries in the key sample set are unique. This is a simplistic
   // estimate of whether the generated keys appear random.
   EXPECT_FALSE(CopiesExist(keys));
 }
 
 // If the key length is not provided, then the block size is used.
 TEST_F(SharedCryptoTest, MAYBE(GenerateKeyHmacNoLength)) {
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
   blink::WebCryptoAlgorithm algorithm =
       CreateHmacKeyGenAlgorithm(blink::WebCryptoAlgorithmIdSha1, 0);
   ASSERT_EQ(Status::Success(), GenerateSecretKey(algorithm, true, 0, &key));
   EXPECT_TRUE(key.handle());
   EXPECT_EQ(blink::WebCryptoKeyTypeSecret, key.type());
   EXPECT_EQ(blink::WebCryptoAlgorithmIdHmac, key.algorithm().id());
   EXPECT_EQ(blink::WebCryptoAlgorithmIdSha1,
             key.algorithm().hmacParams()->hash().id());
   EXPECT_EQ(512u, key.algorithm().hmacParams()->lengthBits());
-  blink::WebArrayBuffer raw_key;
+  std::vector<uint8> raw_key;
   ASSERT_EQ(Status::Success(),
             ExportKey(blink::WebCryptoKeyFormatRaw, key, &raw_key));
-  EXPECT_EQ(64U, raw_key.byteLength());
+  EXPECT_EQ(64U, raw_key.size());
 
   // The block size for HMAC SHA-512 is larger.
   algorithm = CreateHmacKeyGenAlgorithm(blink::WebCryptoAlgorithmIdSha512, 0);
   ASSERT_EQ(Status::Success(), GenerateSecretKey(algorithm, true, 0, &key));
   EXPECT_EQ(blink::WebCryptoAlgorithmIdHmac, key.algorithm().id());
   EXPECT_EQ(blink::WebCryptoAlgorithmIdSha512,
             key.algorithm().hmacParams()->hash().id());
   EXPECT_EQ(1024u, key.algorithm().hmacParams()->lengthBits());
   ASSERT_EQ(Status::Success(),
             ExportKey(blink::WebCryptoKeyFormatRaw, key, &raw_key));
-  EXPECT_EQ(128U, raw_key.byteLength());
+  EXPECT_EQ(128U, raw_key.size());
 }
 
 TEST_F(SharedCryptoTest, ImportJwkKeyUsage) {
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
   base::DictionaryValue dict;
   dict.SetString("kty", "oct");
   dict.SetBoolean("ext", false);
   dict.SetString("k", "GADWrMRHwQfoNaXU5fZvTg==");
   const blink::WebCryptoAlgorithm aes_cbc_algorithm =
       webcrypto::CreateAlgorithm(blink::WebCryptoAlgorithmIdAesCbc);
@@ skipping 320 matching lines @@
     blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
     ASSERT_EQ(Status::Success(),
               ImportKey(blink::WebCryptoKeyFormatSpki,
                         CryptoData(HexStringToBytes(kPublicKeySpkiDerHex)),
                         test.algorithm,
                         true,
                         test.usage,
                         &public_key));
 
     // Export the public key as JWK and verify its contents
-    blink::WebArrayBuffer jwk;
+    std::vector<uint8> jwk;
     ASSERT_EQ(Status::Success(),
               ExportKey(blink::WebCryptoKeyFormatJwk, public_key, &jwk));
     EXPECT_TRUE(VerifyPublicJwk(jwk, test.jwk_alg, n_hex, e_hex, test.usage));
 
     // Import the JWK back in to create a new key
     blink::WebCryptoKey public_key2 = blink::WebCryptoKey::createNull();
     EXPECT_EQ(
         Status::Success(),
         ImportKeyJwk(
             CryptoData(jwk), test.algorithm, true, test.usage, &public_key2));
     EXPECT_TRUE(public_key2.handle());
     EXPECT_EQ(blink::WebCryptoKeyTypePublic, public_key2.type());
     EXPECT_EQ(true, public_key2.extractable());
     EXPECT_EQ(test.algorithm.id(), public_key2.algorithm().id());
 
     // Export the new key as spki and compare to the original.
-    blink::WebArrayBuffer spki;
+    std::vector<uint8> spki;
     ASSERT_EQ(Status::Success(),
               ExportKey(blink::WebCryptoKeyFormatSpki, public_key2, &spki));
-    ExpectCryptoDataMatchesHex(kPublicKeySpkiDerHex, CryptoData(spki));
+    EXPECT_BYTES_EQ_HEX(kPublicKeySpkiDerHex, CryptoData(spki));
   }
 }
 
 TEST_F(SharedCryptoTest, MAYBE(ImportJwkRsaFailures)) {
   base::DictionaryValue dict;
   RestoreJwkRsaDictionary(&dict);
   blink::WebCryptoAlgorithm algorithm =
       CreateAlgorithm(blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5);
   blink::WebCryptoKeyUsageMask usage_mask = blink::WebCryptoKeyUsageEncrypt;
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
@@ skipping 191 matching lines @@
 
   EXPECT_EQ(blink::WebCryptoAlgorithmIdSha256,
             key.algorithm().hmacParams()->hash().id());
 
   const std::vector<uint8> message_raw = HexStringToBytes(
       "b1689c2591eaf3c9e66070f8a77954ffb81749f1b00346f9dfe0b2ee905dcc288baf4a"
       "92de3f4001dd9f44c468c3d07d6c6ee82faceafc97c2fc0fc0601719d2dcd0aa2aec92"
       "d1b0ae933c65eb06a03c9c935c2bad0459810241347ab87e9f11adb30415424c6c7f5f"
       "22a003b8ab8de54f6ded0e3ab9245fa79568451dfa258e");
 
-  blink::WebArrayBuffer output;
+  std::vector<uint8> output;
 
   ASSERT_EQ(Status::Success(),
             Sign(CreateAlgorithm(blink::WebCryptoAlgorithmIdHmac),
                  key,
                  CryptoData(message_raw),
                  &output));
 
   const std::string mac_raw =
       "769f00d3e6a6cc1fb426a14a4f76c6462e6149726e0dee0ec0cf97a16605ac8b";
 
-  ExpectArrayBufferMatchesHex(mac_raw, output);
+  EXPECT_BYTES_EQ_HEX(mac_raw, output);
 
   // TODO(padolph): Import an RSA public key JWK and use it
 }
 
 TEST_F(SharedCryptoTest, MAYBE(ImportExportJwkSymmetricKey)) {
   // Raw keys are generated by openssl:
   // % openssl rand -hex <key length bytes>
   const char* const key_hex_128 = "3f1e7cd4f6f8543f6b1e16002e688623";
   const char* const key_hex_192 =
       "ed91f916dc034eba68a0f9e7f34ddd48b98bd2848109e243";
@@ skipping 69 matching lines @@
        blink::WebCryptoKeyUsageEncrypt | blink::WebCryptoKeyUsageDecrypt |
            blink::WebCryptoKeyUsageWrapKey | blink::WebCryptoKeyUsageUnwrapKey,
        "A256CBC"},
       // Zero usage value
       {key_hex_512, hmac_sha_512_alg, 0, "HS512"},
   };
 
   // Round-trip import/export each key.
 
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
-  blink::WebArrayBuffer json;
+  std::vector<uint8> json;
   for (size_t test_index = 0; test_index < ARRAYSIZE_UNSAFE(kTests);
        ++test_index) {
     SCOPED_TRACE(test_index);
     const TestCase& test = kTests[test_index];
 
     // Skip AES-GCM tests where not supported.
     if (test.algorithm.id() == blink::WebCryptoAlgorithmIdAesGcm &&
         !SupportsAesGcm()) {
       continue;
     }
@@ skipping 11 matching lines @@
     ASSERT_EQ(
         Status::Success(),
         ImportKeyJwk(CryptoData(json), test.algorithm, true, test.usage, &key));
     EXPECT_TRUE(key.handle());
     EXPECT_EQ(blink::WebCryptoKeyTypeSecret, key.type());
     EXPECT_EQ(test.algorithm.id(), key.algorithm().id());
     EXPECT_EQ(true, key.extractable());
     EXPECT_EQ(test.usage, key.usages());
 
     // Export the key in raw format and compare to the original.
-    blink::WebArrayBuffer key_raw_out;
+    std::vector<uint8> key_raw_out;
     ASSERT_EQ(Status::Success(),
               ExportKey(blink::WebCryptoKeyFormatRaw, key, &key_raw_out));
-    ExpectArrayBufferMatchesHex(test.key_hex, key_raw_out);
+    EXPECT_BYTES_EQ_HEX(test.key_hex, key_raw_out);
   }
 }
 
 TEST_F(SharedCryptoTest, MAYBE(ExportJwkEmptySymmetricKey)) {
   const blink::WebCryptoAlgorithm import_algorithm =
       webcrypto::CreateHmacImportAlgorithm(blink::WebCryptoAlgorithmIdSha1);
 
   blink::WebCryptoKeyUsageMask usages = blink::WebCryptoKeyUsageSign;
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
 
   // Import a zero-byte HMAC key.
   const char key_data_hex[] = "";
   key = ImportSecretKeyFromRaw(
       HexStringToBytes(key_data_hex), import_algorithm, usages);
   EXPECT_EQ(0u, key.algorithm().hmacParams()->lengthBits());
 
   // Export the key in JWK format and validate.
-  blink::WebArrayBuffer json;
+  std::vector<uint8> json;
   ASSERT_EQ(Status::Success(),
             ExportKey(blink::WebCryptoKeyFormatJwk, key, &json));
   EXPECT_TRUE(VerifySecretJwk(json, "HS1", key_data_hex, usages));
 
   // Now try re-importing the JWK key.
   key = blink::WebCryptoKey::createNull();
   EXPECT_EQ(Status::Success(),
             ImportKey(blink::WebCryptoKeyFormatJwk,
                       CryptoData(json),
                       import_algorithm,
                       true,
                       usages,
                       &key));
 
   EXPECT_EQ(blink::WebCryptoKeyTypeSecret, key.type());
   EXPECT_EQ(0u, key.algorithm().hmacParams()->lengthBits());
 
-  blink::WebArrayBuffer exported_key_data;
+  std::vector<uint8> exported_key_data;
   EXPECT_EQ(Status::Success(),
             ExportKey(blink::WebCryptoKeyFormatRaw, key, &exported_key_data));
 
-  EXPECT_EQ(0u, exported_key_data.byteLength());
+  EXPECT_EQ(0u, exported_key_data.size());
 }
 
 TEST_F(SharedCryptoTest, MAYBE(ImportExportSpki)) {
   // Passing case: Import a valid RSA key in SPKI format.
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
   ASSERT_EQ(
       Status::Success(),
       ImportKey(blink::WebCryptoKeyFormatSpki,
                 CryptoData(HexStringToBytes(kPublicKeySpkiDerHex)),
                 CreateAlgorithm(blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5),
                 true,
                 blink::WebCryptoKeyUsageEncrypt,
                 &key));
   EXPECT_TRUE(key.handle());
   EXPECT_EQ(blink::WebCryptoKeyTypePublic, key.type());
   EXPECT_TRUE(key.extractable());
   EXPECT_EQ(blink::WebCryptoKeyUsageEncrypt, key.usages());
   EXPECT_EQ(kModulusLengthBits,
             key.algorithm().rsaParams()->modulusLengthBits());
-  ExpectCryptoDataMatchesHex(
+  EXPECT_BYTES_EQ_HEX(
       "010001", CryptoData(key.algorithm().rsaParams()->publicExponent()));
 
   // Failing case: Empty SPKI data
   EXPECT_EQ(
       Status::ErrorImportEmptyKeyData(),
       ImportKey(blink::WebCryptoKeyFormatSpki,
                 CryptoData(std::vector<uint8>()),
                 CreateAlgorithm(blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5),
                 true,
                 blink::WebCryptoKeyUsageEncrypt,
@@ skipping 13 matching lines @@
   EXPECT_EQ(Status::DataError(),
             ImportKey(blink::WebCryptoKeyFormatSpki,
                       CryptoData(HexStringToBytes(kPublicKeySpkiDerHex)),
                       CreateAlgorithm(blink::WebCryptoAlgorithmIdAesCbc),
                       true,
                       blink::WebCryptoKeyUsageEncrypt,
                       &key));
 
   // Passing case: Export a previously imported RSA public key in SPKI format
   // and compare to original data.
-  blink::WebArrayBuffer output;
+  std::vector<uint8> output;
   ASSERT_EQ(Status::Success(),
             ExportKey(blink::WebCryptoKeyFormatSpki, key, &output));
-  ExpectArrayBufferMatchesHex(kPublicKeySpkiDerHex, output);
+  EXPECT_BYTES_EQ_HEX(kPublicKeySpkiDerHex, output);
 
   // Failing case: Try to export a previously imported RSA public key in raw
   // format (not allowed for a public key).
   EXPECT_EQ(Status::ErrorUnexpectedKeyType(),
             ExportKey(blink::WebCryptoKeyFormatRaw, key, &output));
 
   // Failing case: Try to export a non-extractable key
   ASSERT_EQ(
       Status::Success(),
       ImportKey(blink::WebCryptoKeyFormatSpki,
@@ skipping 21 matching lines @@
                       blink::WebCryptoKeyUsageSign,
                       &key));
   EXPECT_TRUE(key.handle());
   EXPECT_EQ(blink::WebCryptoKeyTypePrivate, key.type());
   EXPECT_TRUE(key.extractable());
   EXPECT_EQ(blink::WebCryptoKeyUsageSign, key.usages());
   EXPECT_EQ(blink::WebCryptoAlgorithmIdSha1,
             key.algorithm().rsaHashedParams()->hash().id());
   EXPECT_EQ(kModulusLengthBits,
             key.algorithm().rsaHashedParams()->modulusLengthBits());
-  ExpectCryptoDataMatchesHex(
+  EXPECT_BYTES_EQ_HEX(
       "010001",
       CryptoData(key.algorithm().rsaHashedParams()->publicExponent()));
 
-  blink::WebArrayBuffer exported_key;
+  std::vector<uint8> exported_key;
   ASSERT_EQ(Status::Success(),
             ExportKey(blink::WebCryptoKeyFormatPkcs8, key, &exported_key));
-  ExpectArrayBufferMatchesHex(kPrivateKeyPkcs8DerHex, exported_key);
+  EXPECT_BYTES_EQ_HEX(kPrivateKeyPkcs8DerHex, exported_key);
 
   // Failing case: Empty PKCS#8 data
   EXPECT_EQ(Status::ErrorImportEmptyKeyData(),
             ImportKey(blink::WebCryptoKeyFormatPkcs8,
                       CryptoData(std::vector<uint8>()),
                       CreateRsaHashedImportAlgorithm(
                           blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                           blink::WebCryptoAlgorithmIdSha1),
                       true,
                       blink::WebCryptoKeyUsageSign,
@@ skipping 40 matching lines @@
   EXPECT_FALSE(private_key.isNull());
   EXPECT_EQ(blink::WebCryptoKeyTypePublic, public_key.type());
   EXPECT_EQ(blink::WebCryptoKeyTypePrivate, private_key.type());
   EXPECT_TRUE(public_key.extractable());
   EXPECT_EQ(extractable, private_key.extractable());
   EXPECT_EQ(usage_mask, public_key.usages());
   EXPECT_EQ(usage_mask, private_key.usages());
 
   // Try exporting the generated key pair, and then re-importing to verify that
   // the exported data was valid.
-  blink::WebArrayBuffer public_key_spki;
+  std::vector<uint8> public_key_spki;
   EXPECT_EQ(
       Status::Success(),
       ExportKey(blink::WebCryptoKeyFormatSpki, public_key, &public_key_spki));
   public_key = blink::WebCryptoKey::createNull();
   EXPECT_EQ(
       Status::Success(),
       ImportKey(blink::WebCryptoKeyFormatSpki,
                 CryptoData(public_key_spki),
                 CreateAlgorithm(blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5),
                 true,
                 usage_mask,
                 &public_key));
   EXPECT_EQ(modulus_length,
             public_key.algorithm().rsaParams()->modulusLengthBits());
 
-  blink::WebArrayBuffer private_key_pkcs8;
+  std::vector<uint8> private_key_pkcs8;
   EXPECT_EQ(
       Status::Success(),
       ExportKey(
           blink::WebCryptoKeyFormatPkcs8, private_key, &private_key_pkcs8));
   private_key = blink::WebCryptoKey::createNull();
   EXPECT_EQ(
       Status::Success(),
       ImportKey(blink::WebCryptoKeyFormatPkcs8,
                 CryptoData(private_key_pkcs8),
                 CreateAlgorithm(blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5),
@@ skipping 108 matching lines @@
             private_key.algorithm().rsaHashedParams()->hash().id());
   // Even though "extractable" was set to false, the public key remains
   // extractable.
   EXPECT_TRUE(public_key.extractable());
   EXPECT_FALSE(private_key.extractable());
   EXPECT_EQ(usage_mask, public_key.usages());
   EXPECT_EQ(usage_mask, private_key.usages());
 
   // Exporting a private key as SPKI format doesn't make sense. However this
   // will first fail because the key is not extractable.
-  blink::WebArrayBuffer output;
+  std::vector<uint8> output;
   EXPECT_EQ(Status::ErrorKeyNotExtractable(),
             ExportKey(blink::WebCryptoKeyFormatSpki, private_key, &output));
 
   // Re-generate an extractable private_key and try to export it as SPKI format.
   // This should fail since spki is for public keys.
   EXPECT_EQ(
       Status::Success(),
       GenerateKeyPair(algorithm, true, usage_mask, &public_key, &private_key));
   EXPECT_EQ(Status::ErrorUnexpectedKeyType(),
             ExportKey(blink::WebCryptoKeyFormatSpki, private_key, &output));
@@ skipping 21 matching lines @@
   const unsigned int kMsgHexSize = kMaxMsgSizeBytes * 2;
   char max_data_hex[kMsgHexSize + 1];
   std::fill(&max_data_hex[0], &max_data_hex[0] + kMsgHexSize, 'a');
   max_data_hex[kMsgHexSize] = '\0';
 
   // Verify encrypt / decrypt round trip on a few messages. Note that RSA
   // encryption does not support empty input.
   algorithm = CreateAlgorithm(blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5);
   const char* const kTestDataHex[] = {"ff", "0102030405060708090a0b0c0d0e0f",
                                       max_data_hex};
-  blink::WebArrayBuffer encrypted_data;
-  blink::WebArrayBuffer decrypted_data;
+  std::vector<uint8> encrypted_data;
+  std::vector<uint8> decrypted_data;
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestDataHex); ++i) {
     SCOPED_TRACE(i);
     EXPECT_EQ(Status::Success(),
               Encrypt(algorithm,
                       public_key,
                       CryptoData(HexStringToBytes(kTestDataHex[i])),
                       &encrypted_data));
-    EXPECT_EQ(kModulusLengthBits / 8, encrypted_data.byteLength());
+    EXPECT_EQ(kModulusLengthBits / 8, encrypted_data.size());
     ASSERT_EQ(Status::Success(),
               Decrypt(algorithm,
                       private_key,
                       CryptoData(encrypted_data),
                       &decrypted_data));
-    ExpectArrayBufferMatchesHex(kTestDataHex[i], decrypted_data);
+    EXPECT_BYTES_EQ_HEX(kTestDataHex[i], decrypted_data);
   }
 }
 
 TEST_F(SharedCryptoTest, MAYBE(RsaEsKnownAnswer)) {
   scoped_ptr<base::Value> json;
   ASSERT_TRUE(ReadJsonTestFile("rsa_es.json", &json));
   base::DictionaryValue* test = NULL;
   ASSERT_TRUE(json->GetAsDictionary(&test));
 
   // Because the random data in PKCS1.5 padding makes the encryption output non-
@@ skipping 20 matching lines @@
       rsa_spki_der,
       rsa_pkcs8_der,
       algorithm,
       false,
       blink::WebCryptoKeyUsageEncrypt | blink::WebCryptoKeyUsageDecrypt,
       &public_key,
       &private_key);
 
   // Decrypt the known-good ciphertext with the private key. As a check we must
   // get the known original cleartext.
-  blink::WebArrayBuffer decrypted_data;
+  std::vector<uint8> decrypted_data;
   ASSERT_EQ(
       Status::Success(),
       Decrypt(algorithm, private_key, CryptoData(ciphertext), &decrypted_data));
-  EXPECT_FALSE(decrypted_data.isNull());
-  EXPECT_TRUE(ArrayBufferMatches(cleartext, decrypted_data));
+  EXPECT_BYTES_EQ(cleartext, decrypted_data);
 
   // Encrypt this decrypted data with the public key.
-  blink::WebArrayBuffer encrypted_data;
+  std::vector<uint8> encrypted_data;
   ASSERT_EQ(
       Status::Success(),
       Encrypt(
           algorithm, public_key, CryptoData(decrypted_data), &encrypted_data));
-  EXPECT_EQ(128u, encrypted_data.byteLength());
+  EXPECT_EQ(128u, encrypted_data.size());
 
   // Finally, decrypt the newly encrypted result with the private key, and
   // compare to the known original cleartext.
-  decrypted_data.reset();
+  decrypted_data.clear();
   ASSERT_EQ(
       Status::Success(),
       Decrypt(
           algorithm, private_key, CryptoData(encrypted_data), &decrypted_data));
-  EXPECT_FALSE(decrypted_data.isNull());
-  EXPECT_TRUE(ArrayBufferMatches(cleartext, decrypted_data));
+  EXPECT_EQ(cleartext, decrypted_data);
 }
 
 TEST_F(SharedCryptoTest, MAYBE(RsaEsFailures)) {
   // Import a key pair.
   blink::WebCryptoAlgorithm algorithm =
       CreateAlgorithm(blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5);
   blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
   blink::WebCryptoKey private_key = blink::WebCryptoKey::createNull();
   ImportRsaKeyPair(
       HexStringToBytes(kPublicKeySpkiDerHex),
       HexStringToBytes(kPrivateKeyPkcs8DerHex),
       algorithm,
       false,
       blink::WebCryptoKeyUsageEncrypt | blink::WebCryptoKeyUsageDecrypt,
       &public_key,
       &private_key);
 
   // Fail encrypt with a private key.
-  blink::WebArrayBuffer encrypted_data;
+  std::vector<uint8> encrypted_data;
   const std::string message_hex_str("0102030405060708090a0b0c0d0e0f");
   const std::vector<uint8> message_hex(HexStringToBytes(message_hex_str));
   EXPECT_EQ(
       Status::ErrorUnexpectedKeyType(),
       Encrypt(
           algorithm, private_key, CryptoData(message_hex), &encrypted_data));
 
   // Fail encrypt with empty message.
   EXPECT_EQ(Status::ErrorDataTooSmall(),
             Encrypt(algorithm,
                     public_key,
                     CryptoData(std::vector<uint8>()),
                     &encrypted_data));
 
   // Fail encrypt with message too large. RSAES can operate on messages up to
   // length of k - 11 bytes, where k is the octet length of the RSA modulus.
   const unsigned int kMaxMsgSizeBytes = kModulusLengthBits / 8 - 11;
   EXPECT_EQ(Status::ErrorDataTooLarge(),
             Encrypt(algorithm,
                     public_key,
                     CryptoData(std::vector<uint8>(kMaxMsgSizeBytes + 1, '0')),
                     &encrypted_data));
 
   // Generate encrypted data.
   EXPECT_EQ(
       Status::Success(),
       Encrypt(algorithm, public_key, CryptoData(message_hex), &encrypted_data));
 
   // Fail decrypt with a public key.
-  blink::WebArrayBuffer decrypted_data;
+  std::vector<uint8> decrypted_data;
   EXPECT_EQ(
       Status::ErrorUnexpectedKeyType(),
       Decrypt(
           algorithm, public_key, CryptoData(encrypted_data), &decrypted_data));
 
   // Corrupt encrypted data; ensure decrypt fails because padding was disrupted.
-  std::vector<uint8> corrupted_data(
-      static_cast<uint8*>(encrypted_data.data()),
-      static_cast<uint8*>(encrypted_data.data()) + encrypted_data.byteLength());
-  corrupted_data[corrupted_data.size() / 2] ^= 0x01;
-  EXPECT_EQ(
-      Status::OperationError(),
-      Decrypt(
-          algorithm, private_key, CryptoData(corrupted_data), &decrypted_data));
+  EXPECT_EQ(Status::OperationError(),
+            Decrypt(algorithm,
+                    private_key,
+                    CryptoData(Corrupted(encrypted_data)),
+                    &decrypted_data));
 
   // TODO(padolph): Are there other specific data corruption scenarios to
   // consider?
 
   // Do a successful decrypt with good data just for confirmation.
   EXPECT_EQ(
       Status::Success(),
       Decrypt(
           algorithm, private_key, CryptoData(encrypted_data), &decrypted_data));
-  ExpectArrayBufferMatchesHex(message_hex_str, decrypted_data);
+  EXPECT_BYTES_EQ_HEX(message_hex_str, decrypted_data);
 }
 
 TEST_F(SharedCryptoTest, MAYBE(RsaSsaSignVerifyFailures)) {
   // Import a key pair.
   blink::WebCryptoKeyUsageMask usage_mask =
       blink::WebCryptoKeyUsageSign | blink::WebCryptoKeyUsageVerify;
   blink::WebCryptoAlgorithm importAlgorithm =
       CreateRsaHashedImportAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                                      blink::WebCryptoAlgorithmIdSha1);
   blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
   blink::WebCryptoKey private_key = blink::WebCryptoKey::createNull();
   ImportRsaKeyPair(HexStringToBytes(kPublicKeySpkiDerHex),
                    HexStringToBytes(kPrivateKeyPkcs8DerHex),
                    importAlgorithm,
                    false,
                    usage_mask,
                    &public_key,
                    &private_key);
 
   blink::WebCryptoAlgorithm algorithm =
       CreateAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5);
 
-  blink::WebArrayBuffer signature;
+  std::vector<uint8> signature;
   bool signature_match;
 
   // Compute a signature.
   const std::vector<uint8> data = HexStringToBytes("010203040506070809");
   ASSERT_EQ(Status::Success(),
             Sign(algorithm, private_key, CryptoData(data), &signature));
 
   // Ensure truncated signature does not verify by passing one less byte.
-  EXPECT_EQ(
-      Status::Success(),
-      VerifySignature(
-          algorithm,
-          public_key,
-          CryptoData(reinterpret_cast<const unsigned char*>(signature.data()),
-                     signature.byteLength() - 1),
-          CryptoData(data),
-          &signature_match));
+  EXPECT_EQ(Status::Success(),
+            VerifySignature(
+                algorithm,
+                public_key,
+                CryptoData(Uint8VectorStart(signature), signature.size() - 1),
+                CryptoData(data),
+                &signature_match));
   EXPECT_FALSE(signature_match);
 
   // Ensure truncated signature does not verify by passing no bytes.
   EXPECT_EQ(Status::Success(),
             VerifySignature(algorithm,
                             public_key,
                             CryptoData(),
                             CryptoData(data),
                             &signature_match));
   EXPECT_FALSE(signature_match);
 
   // Ensure corrupted signature does not verify.
-  std::vector<uint8> corrupt_sig(
-      static_cast<uint8*>(signature.data()),
-      static_cast<uint8*>(signature.data()) + signature.byteLength());
+  std::vector<uint8> corrupt_sig = signature;
   corrupt_sig[corrupt_sig.size() / 2] ^= 0x1;
   EXPECT_EQ(Status::Success(),
             VerifySignature(algorithm,
                             public_key,
                             CryptoData(corrupt_sig),
                             CryptoData(data),
                             &signature_match));
   EXPECT_FALSE(signature_match);
 
   // Ensure signatures that are greater than the modulus size fail.
@@ skipping 96 matching lines @@
       importAlgorithm,
       false,
       blink::WebCryptoKeyUsageSign | blink::WebCryptoKeyUsageVerify,
       &public_key,
       &private_key);
 
   blink::WebCryptoAlgorithm algorithm =
       CreateAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5);
 
   // Validate the signatures are computed and verified as expected.
-  blink::WebArrayBuffer signature;
+  std::vector<uint8> signature;
   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));
 
     std::vector<uint8> test_message =
         GetBytesFromHexString(test, "message_hex");
     std::vector<uint8> test_signature =
         GetBytesFromHexString(test, "signature_hex");
 
-    signature.reset();
+    signature.clear();
     ASSERT_EQ(
         Status::Success(),
         Sign(algorithm, private_key, CryptoData(test_message), &signature));
-    EXPECT_TRUE(ArrayBufferMatches(test_signature, signature));
+    EXPECT_BYTES_EQ(test_signature, signature);
 
     bool is_match = false;
     ASSERT_EQ(Status::Success(),
               VerifySignature(algorithm,
                               public_key,
                               CryptoData(test_signature),
                               CryptoData(test_message),
                               &is_match));
     EXPECT_TRUE(is_match);
   }
 }
 
 TEST_F(SharedCryptoTest, MAYBE(AesKwKeyImport)) {
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
   blink::WebCryptoAlgorithm algorithm =
       CreateAlgorithm(blink::WebCryptoAlgorithmIdAesKw);
 
   // Import a 128-bit Key Encryption Key (KEK)
   std::string key_raw_hex_in = "025a8cf3f08b4f6c5f33bbc76a471939";
   ASSERT_EQ(Status::Success(),
             ImportKey(blink::WebCryptoKeyFormatRaw,
                       CryptoData(HexStringToBytes(key_raw_hex_in)),
                       algorithm,
                       true,
                       blink::WebCryptoKeyUsageWrapKey,
                       &key));
-  blink::WebArrayBuffer key_raw_out;
+  std::vector<uint8> key_raw_out;
   EXPECT_EQ(Status::Success(),
             ExportKey(blink::WebCryptoKeyFormatRaw, key, &key_raw_out));
-  ExpectArrayBufferMatchesHex(key_raw_hex_in, key_raw_out);
+  EXPECT_BYTES_EQ_HEX(key_raw_hex_in, key_raw_out);
 
   // Import a 192-bit KEK
   key_raw_hex_in = "c0192c6466b2370decbb62b2cfef4384544ffeb4d2fbc103";
   ASSERT_EQ(Status::Success(),
             ImportKey(blink::WebCryptoKeyFormatRaw,
                       CryptoData(HexStringToBytes(key_raw_hex_in)),
                       algorithm,
                       true,
                       blink::WebCryptoKeyUsageWrapKey,
                       &key));
   EXPECT_EQ(Status::Success(),
             ExportKey(blink::WebCryptoKeyFormatRaw, key, &key_raw_out));
-  ExpectArrayBufferMatchesHex(key_raw_hex_in, key_raw_out);
+  EXPECT_BYTES_EQ_HEX(key_raw_hex_in, key_raw_out);
 
   // Import a 256-bit Key Encryption Key (KEK)
   key_raw_hex_in =
       "e11fe66380d90fa9ebefb74e0478e78f95664d0c67ca20ce4a0b5842863ac46f";
   ASSERT_EQ(Status::Success(),
             ImportKey(blink::WebCryptoKeyFormatRaw,
                       CryptoData(HexStringToBytes(key_raw_hex_in)),
                       algorithm,
                       true,
                       blink::WebCryptoKeyUsageWrapKey,
                       &key));
   EXPECT_EQ(Status::Success(),
             ExportKey(blink::WebCryptoKeyFormatRaw, key, &key_raw_out));
-  ExpectArrayBufferMatchesHex(key_raw_hex_in, key_raw_out);
+  EXPECT_BYTES_EQ_HEX(key_raw_hex_in, key_raw_out);
 
   // Fail import of 0 length key
   EXPECT_EQ(Status::ErrorImportAesKeyLength(),
             ImportKey(blink::WebCryptoKeyFormatRaw,
                       CryptoData(HexStringToBytes("")),
                       algorithm,
                       true,
                       blink::WebCryptoKeyUsageWrapKey,
                       &key));
 
@@ skipping 95 matching lines @@
         wrapping_algorithm,
         blink::WebCryptoKeyUsageWrapKey | blink::WebCryptoKeyUsageUnwrapKey);
 
     // Import the key to be wrapped.
     blink::WebCryptoKey key = ImportSecretKeyFromRaw(
         test_key,
         webcrypto::CreateAlgorithm(blink::WebCryptoAlgorithmIdAesCbc),
         blink::WebCryptoKeyUsageEncrypt);
 
     // Wrap the key and verify the ciphertext result against the known answer.
-    blink::WebArrayBuffer wrapped_key;
+    std::vector<uint8> wrapped_key;
     ASSERT_EQ(Status::Success(),
               WrapKey(blink::WebCryptoKeyFormatRaw,
                       wrapping_key,
                       key,
                       wrapping_algorithm,
                       &wrapped_key));
-    EXPECT_TRUE(ArrayBufferMatches(test_ciphertext, wrapped_key));
+    EXPECT_BYTES_EQ(test_ciphertext, wrapped_key);
 
     // Unwrap the known ciphertext to get a new test_key.
     blink::WebCryptoKey unwrapped_key = blink::WebCryptoKey::createNull();
     ASSERT_EQ(
         Status::Success(),
         UnwrapKey(blink::WebCryptoKeyFormatRaw,
                   CryptoData(test_ciphertext),
                   wrapping_key,
                   wrapping_algorithm,
                   webcrypto::CreateAlgorithm(blink::WebCryptoAlgorithmIdAesCbc),
                   true,
                   blink::WebCryptoKeyUsageEncrypt,
                   &unwrapped_key));
     EXPECT_FALSE(key.isNull());
     EXPECT_TRUE(key.handle());
     EXPECT_EQ(blink::WebCryptoKeyTypeSecret, key.type());
     EXPECT_EQ(
         webcrypto::CreateAlgorithm(blink::WebCryptoAlgorithmIdAesCbc).id(),
         key.algorithm().id());
     EXPECT_EQ(true, key.extractable());
     EXPECT_EQ(blink::WebCryptoKeyUsageEncrypt, key.usages());
 
     // Export the new key and compare its raw bytes with the original known key.
-    blink::WebArrayBuffer raw_key;
+    std::vector<uint8> raw_key;
     EXPECT_EQ(Status::Success(),
               ExportKey(blink::WebCryptoKeyFormatRaw, unwrapped_key, &raw_key));
-    EXPECT_TRUE(ArrayBufferMatches(test_key, raw_key));
+    EXPECT_BYTES_EQ(test_key, raw_key);
   }
 }
 
 TEST_F(SharedCryptoTest, MAYBE(AesKwRawSymkeyWrapUnwrapErrors)) {
   scoped_ptr<base::ListValue> tests;
   ASSERT_TRUE(ReadJsonTestFileToList("aes_kw.json", &tests));
   base::DictionaryValue* test;
   // Use 256 bits of data with a 256-bit KEK
   ASSERT_TRUE(tests->GetDictionary(5, &test));
   const std::vector<uint8> test_kek = GetBytesFromHexString(test, "kek");
@@ skipping 119 matching lines @@
   EXPECT_TRUE(unwrapped_key.handle());
   EXPECT_EQ(blink::WebCryptoKeyTypeSecret, unwrapped_key.type());
   EXPECT_EQ(blink::WebCryptoAlgorithmIdHmac, unwrapped_key.algorithm().id());
   EXPECT_EQ(blink::WebCryptoAlgorithmIdSha256,
             unwrapped_key.algorithm().hmacParams()->hash().id());
   EXPECT_EQ(256u, unwrapped_key.algorithm().hmacParams()->lengthBits());
   EXPECT_EQ(true, unwrapped_key.extractable());
   EXPECT_EQ(blink::WebCryptoKeyUsageVerify, unwrapped_key.usages());
 
   // Export the new key's raw data and compare to the known original.
-  blink::WebArrayBuffer raw_key;
+  std::vector<uint8> raw_key;
   EXPECT_EQ(Status::Success(),
             ExportKey(blink::WebCryptoKeyFormatRaw, unwrapped_key, &raw_key));
-  EXPECT_TRUE(ArrayBufferMatches(key_data, raw_key));
+  EXPECT_BYTES_EQ(key_data, raw_key);
 }
 
 // TODO(eroman):
 //   * Test decryption when the tag length exceeds input size
 //   * Test decryption with empty input
 //   * Test decryption with tag length of 0.
 TEST_F(SharedCryptoTest, MAYBE(AesGcmSampleSets)) {
   // Some Linux test runners may not have a new enough version of NSS.
   if (!SupportsAesGcm()) {
     LOG(WARNING) << "AES GCM not supported, skipping tests";
@@ skipping 20 matching lines @@
     const unsigned int test_tag_size_bits = test_authentication_tag.size() * 8;
     const std::vector<uint8> test_cipher_text =
         GetBytesFromHexString(test, "cipher_text");
 
     blink::WebCryptoKey key = ImportSecretKeyFromRaw(
         test_key,
         CreateAlgorithm(blink::WebCryptoAlgorithmIdAesGcm),
         blink::WebCryptoKeyUsageEncrypt | blink::WebCryptoKeyUsageDecrypt);
 
     // Verify exported raw key is identical to the imported data
-    blink::WebArrayBuffer raw_key;
+    std::vector<uint8> raw_key;
     EXPECT_EQ(Status::Success(),
               ExportKey(blink::WebCryptoKeyFormatRaw, key, &raw_key));
 
-    EXPECT_TRUE(ArrayBufferMatches(test_key, raw_key));
+    EXPECT_BYTES_EQ(test_key, raw_key);
 
     // Test encryption.
     std::vector<uint8> cipher_text;
     std::vector<uint8> authentication_tag;
     EXPECT_EQ(Status::Success(),
               AesGcmEncrypt(key,
                             test_iv,
                             test_additional_data,
                             test_tag_size_bits,
                             test_plain_text,
                             &cipher_text,
                             &authentication_tag));
 
-    ExpectVectorMatches(test_cipher_text, cipher_text);
-    ExpectVectorMatches(test_authentication_tag, authentication_tag);
+    EXPECT_BYTES_EQ(test_cipher_text, cipher_text);
+    EXPECT_BYTES_EQ(test_authentication_tag, authentication_tag);
 
     // Test decryption.
-    blink::WebArrayBuffer plain_text;
+    std::vector<uint8> plain_text;
     EXPECT_EQ(Status::Success(),
               AesGcmDecrypt(key,
                             test_iv,
                             test_additional_data,
                             test_tag_size_bits,
                             test_cipher_text,
                             test_authentication_tag,
                             &plain_text));
-    EXPECT_TRUE(ArrayBufferMatches(test_plain_text, plain_text));
+    EXPECT_BYTES_EQ(test_plain_text, plain_text);
 
     // Decryption should fail if any of the inputs are tampered with.
     EXPECT_EQ(Status::OperationError(),
               AesGcmDecrypt(key,
                             Corrupted(test_iv),
                             test_additional_data,
                             test_tag_size_bits,
                             test_cipher_text,
                             test_authentication_tag,
                             &plain_text));
@@ skipping 73 matching lines @@
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
   ASSERT_EQ(Status::Success(),
             ImportKey(blink::WebCryptoKeyFormatRaw,
                       CryptoData(cleartext),
                       key_algorithm,
                       true,
                       blink::WebCryptoKeyUsageSign,
                       &key));
 
   // Wrap the symmetric key with raw format.
-  blink::WebArrayBuffer wrapped_key;
+  std::vector<uint8> wrapped_key;
   ASSERT_EQ(Status::Success(),
             WrapKey(blink::WebCryptoKeyFormatRaw,
                     public_key,
                     key,
                     algorithm,
                     &wrapped_key));
 
   // Unwrap the wrapped key.
   blink::WebCryptoKey unwrapped_key = blink::WebCryptoKey::createNull();
   ASSERT_EQ(Status::Success(),
             UnwrapKey(blink::WebCryptoKeyFormatRaw,
                       CryptoData(wrapped_key),
                       private_key,
                       algorithm,
                       key_algorithm,
                       true,
                       blink::WebCryptoKeyUsageSign,
                       &unwrapped_key));
   EXPECT_FALSE(key.isNull());
   EXPECT_TRUE(key.handle());
   EXPECT_EQ(blink::WebCryptoKeyTypeSecret, key.type());
   EXPECT_EQ(key_algorithm.id(), key.algorithm().id());
   EXPECT_EQ(true, key.extractable());
   EXPECT_EQ(blink::WebCryptoKeyUsageSign, key.usages());
 
   // Export the new key and compare its raw bytes with the original known data.
-  blink::WebArrayBuffer raw_key;
+  std::vector<uint8> raw_key;
   EXPECT_EQ(Status::Success(),
             ExportKey(blink::WebCryptoKeyFormatRaw, unwrapped_key, &raw_key));
-  EXPECT_TRUE(ArrayBufferMatches(cleartext, raw_key));
+  EXPECT_BYTES_EQ(cleartext, raw_key);
 
   // Unwrap the known wrapped key and compare to the known cleartext.
   ASSERT_EQ(Status::Success(),
             UnwrapKey(blink::WebCryptoKeyFormatRaw,
                       CryptoData(ciphertext),
                       private_key,
                       algorithm,
                       key_algorithm,
                       true,
                       blink::WebCryptoKeyUsageSign,
                       &unwrapped_key));
   EXPECT_EQ(Status::Success(),
             ExportKey(blink::WebCryptoKeyFormatRaw, unwrapped_key, &raw_key));
-  EXPECT_TRUE(ArrayBufferMatches(cleartext, raw_key));
+  EXPECT_BYTES_EQ(cleartext, raw_key);
 }
 
 TEST_F(SharedCryptoTest, MAYBE(RsaEsRawSymkeyWrapUnwrapErrors)) {
   const std::vector<uint8> data(64, 0);
   blink::WebCryptoAlgorithm key_algorithm =
       CreateHmacImportAlgorithm(blink::WebCryptoAlgorithmIdSha256);
 
   // Import the RSA key pair.
   blink::WebCryptoAlgorithm wrapping_algorithm =
       CreateAlgorithm(blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5);
@@ skipping 12 matching lines @@
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
   ASSERT_EQ(Status::Success(),
             ImportKey(blink::WebCryptoKeyFormatRaw,
                       CryptoData(data),
                       key_algorithm,
                       true,
                       blink::WebCryptoKeyUsageSign,
                       &key));
 
   // Wrapping with a private key should fail.
-  blink::WebArrayBuffer wrapped_key;
+  std::vector<uint8> wrapped_key;
   EXPECT_EQ(Status::ErrorUnexpectedKeyType(),
             WrapKey(blink::WebCryptoKeyFormatRaw,
                     private_key,
                     key,
                     wrapping_algorithm,
                     &wrapped_key));
 
   // Wrapping a key whose raw keying material is too large for the wrapping key
   // should fail.
   // RSAES can encrypt data up to length of k - 11 bytes, where k is the octet
@@ skipping 91 matching lines @@
                       blink::WebCryptoKeyUsageEncrypt,
                       &unwrapped_key));
   EXPECT_FALSE(unwrapped_key.isNull());
   EXPECT_TRUE(unwrapped_key.handle());
   EXPECT_EQ(blink::WebCryptoKeyTypeSecret, unwrapped_key.type());
   EXPECT_EQ(blink::WebCryptoAlgorithmIdAesCbc, unwrapped_key.algorithm().id());
   EXPECT_EQ(true, unwrapped_key.extractable());
   EXPECT_EQ(blink::WebCryptoKeyUsageEncrypt, unwrapped_key.usages());
 
   // Export the unwrapped key and compare to the original.
-  blink::WebArrayBuffer raw_key;
+  std::vector<uint8> raw_key;
   EXPECT_EQ(Status::Success(),
             ExportKey(blink::WebCryptoKeyFormatRaw, unwrapped_key, &raw_key));
-  EXPECT_TRUE(ArrayBufferMatches(key_data, raw_key));
+  EXPECT_BYTES_EQ(key_data, raw_key);
 }
 
 TEST_F(SharedCryptoTest, MAYBE(RsaEsJwkSymkeyWrapUnwrapRoundTrip)) {
   // Generate the symkey to be wrapped (256-bit AES-CBC key).
   const blink::WebCryptoAlgorithm gen_algorithm =
       CreateAesCbcKeyGenAlgorithm(256);
   blink::WebCryptoKey key_to_wrap = blink::WebCryptoKey::createNull();
   ASSERT_EQ(
       Status::Success(),
       GenerateSecretKey(
           gen_algorithm, true, blink::WebCryptoKeyUsageEncrypt, &key_to_wrap));
 
   // Import the wrapping key pair.
   const blink::WebCryptoAlgorithm wrapping_algorithm =
       CreateAlgorithm(blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5);
   blink::WebCryptoKey public_wrapping_key = blink::WebCryptoKey::createNull();
   blink::WebCryptoKey private_wrapping_key = blink::WebCryptoKey::createNull();
   ImportRsaKeyPair(
       HexStringToBytes(kPublicKeySpkiDerHex),
       HexStringToBytes(kPrivateKeyPkcs8DerHex),
       wrapping_algorithm,
       false,
       blink::WebCryptoKeyUsageWrapKey | blink::WebCryptoKeyUsageUnwrapKey,
       &public_wrapping_key,
       &private_wrapping_key);
 
   // Wrap the symkey in JWK format, using the public wrapping key.
-  blink::WebArrayBuffer wrapped_data;
+  std::vector<uint8> wrapped_data;
   ASSERT_EQ(Status::Success(),
             WrapKey(blink::WebCryptoKeyFormatJwk,
                     public_wrapping_key,
                     key_to_wrap,
                     wrapping_algorithm,
                     &wrapped_data));
 
   // Unwrap the key using the private wrapping key.
   blink::WebCryptoKey unwrapped_key = blink::WebCryptoKey::createNull();
   ASSERT_EQ(Status::Success(),
             UnwrapKey(blink::WebCryptoKeyFormatJwk,
                       CryptoData(wrapped_data),
                       private_wrapping_key,
                       wrapping_algorithm,
                       CreateAlgorithm(blink::WebCryptoAlgorithmIdAesCbc),
                       true,
                       blink::WebCryptoKeyUsageEncrypt,
                       &unwrapped_key));
 
   // Export the original symkey and the unwrapped key and compare.
-  blink::WebArrayBuffer raw_key1, raw_key2;
+  std::vector<uint8> raw_key1, raw_key2;
   EXPECT_EQ(Status::Success(),
             ExportKey(blink::WebCryptoKeyFormatRaw, key_to_wrap, &raw_key1));
   EXPECT_EQ(Status::Success(),
             ExportKey(blink::WebCryptoKeyFormatRaw, unwrapped_key, &raw_key2));
-  EXPECT_TRUE(ArrayBuffersEqual(raw_key1, raw_key2));
+  EXPECT_BYTES_EQ(raw_key1, raw_key2);
 }
 
 TEST_F(SharedCryptoTest, MAYBE(RsaEsJwkSymkeyWrapUnwrapErrors)) {
   // Unwrap JWK-formatted data that can be successfully decrypted, but contains
   // an error in the plaintext JWK so it cannot be subsequently imported, and
   // ensure that a generic error is returned instead of some other more specific
   // error. This shows that information about the plaintext JWK inside the
   // encrypted data is not leaked.
   // Note that it is sufficient to consider just one JWK import failure mode
   // here; others are validated in the ImportJwkFailures Test. The specific
@@ skipping 18 matching lines @@
   ASSERT_EQ(Status::Success(),
             ImportKey(blink::WebCryptoKeyFormatPkcs8,
                       CryptoData(HexStringToBytes(kPrivateKeyPkcs8DerHex)),
                       algorithm,
                       false,
                       blink::WebCryptoKeyUsageDecrypt,
                       &private_decryption_key));
 
   // Decrypt the ciphertext and validate the result, to prove that decryption is
   // successful.
-  blink::WebArrayBuffer decrypted_data;
+  std::vector<uint8> decrypted_data;
   ASSERT_EQ(Status::Success(),
             Decrypt(algorithm,
                     private_decryption_key,
                     CryptoData(ciphertext),
                     &decrypted_data));
-  const std::string decrypted(static_cast<const char*>(decrypted_data.data()),
-                              decrypted_data.byteLength());
-  EXPECT_EQ(cleartext, decrypted);
+  EXPECT_BYTES_EQ(cleartext, decrypted_data);
 
   // Import the private wrapping key. Note this is the same underlying keying
   // material used for private_decryption_key above. The only difference is that
   // it has unwrap rather than decrypt usage.
   blink::WebCryptoKey private_wrapping_key = blink::WebCryptoKey::createNull();
   ASSERT_EQ(Status::Success(),
             ImportKey(blink::WebCryptoKeyFormatPkcs8,
                       CryptoData(HexStringToBytes(kPrivateKeyPkcs8DerHex)),
                       algorithm,
                       false,
@@ skipping 10 matching lines @@
                       algorithm,
                       CreateAesCbcAlgorithm(std::vector<uint8>(0, 16)),
                       true,
                       blink::WebCryptoKeyUsageEncrypt,
                       &unwrapped_key));
 }
 
 }  // namespace webcrypto
 
 }  // namespace content