[refactor] Replace custom utility function with base's "vector_as_array()"

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 <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/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "content/child/webcrypto/algorithm_dispatch.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/WebCryptoAlgorithm.h"
@@ skipping 126 matching lines @@
     unsigned int modulus_length,
     const std::vector<uint8_t>& public_exponent) {
   DCHECK(algorithm_id == blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5 ||
          algorithm_id == blink::WebCryptoAlgorithmIdRsaOaep);
   DCHECK(blink::WebCryptoAlgorithm::isHash(hash_id));
   return blink::WebCryptoAlgorithm::adoptParamsAndCreate(
       algorithm_id,
       new blink::WebCryptoRsaHashedKeyGenParams(
           CreateAlgorithm(hash_id),
           modulus_length,
-          webcrypto::Uint8VectorStart(public_exponent),
+          vector_as_array(&public_exponent),
           public_exponent.size()));
 }
 
 // Creates an RSA-OAEP algorithm
 blink::WebCryptoAlgorithm CreateRsaOaepAlgorithm(
     const std::vector<uint8_t>& label) {
   return blink::WebCryptoAlgorithm::adoptParamsAndCreate(
       blink::WebCryptoAlgorithmIdRsaOaep,
       new blink::WebCryptoRsaOaepParams(
-          !label.empty(), Uint8VectorStart(label), label.size()));
+          !label.empty(), vector_as_array(&label), label.size()));
 }
 
 // Creates an AES-CBC algorithm.
 blink::WebCryptoAlgorithm CreateAesCbcAlgorithm(
     const std::vector<uint8_t>& iv) {
   return blink::WebCryptoAlgorithm::adoptParamsAndCreate(
       blink::WebCryptoAlgorithmIdAesCbc,
-      new blink::WebCryptoAesCbcParams(Uint8VectorStart(iv), iv.size()));
+      new blink::WebCryptoAesCbcParams(vector_as_array(&iv), iv.size()));
 }
 
 // Creates an AES-GCM algorithm.
 blink::WebCryptoAlgorithm CreateAesGcmAlgorithm(
     const std::vector<uint8_t>& iv,
     const std::vector<uint8_t>& additional_data,
     unsigned int tag_length_bits) {
   EXPECT_TRUE(SupportsAesGcm());
   return blink::WebCryptoAlgorithm::adoptParamsAndCreate(
       blink::WebCryptoAlgorithmIdAesGcm,
-      new blink::WebCryptoAesGcmParams(Uint8VectorStart(iv),
+      new blink::WebCryptoAesGcmParams(vector_as_array(&iv),
                                        iv.size(),
                                        true,
-                                       Uint8VectorStart(additional_data),
+                                       vector_as_array(&additional_data),
                                        additional_data.size(),
                                        true,
                                        tag_length_bits));
 }
 
 // Creates an HMAC algorithm whose parameters struct is compatible with key
 // generation. It is an error to call this with a hash_id that is not a SHA*.
 // The key_length_bits parameter is optional, with zero meaning unspecified.
 blink::WebCryptoAlgorithm CreateHmacKeyGenAlgorithm(
     blink::WebCryptoAlgorithmId hash_id,
@@ skipping 389 matching lines @@
                       algorithm,
                       extractable,
                       usage_mask,
                       key);
 }
 
 // Parses a vector of JSON into a dictionary.
 scoped_ptr<base::DictionaryValue> GetJwkDictionary(
     const std::vector<uint8_t>& json) {
   base::StringPiece json_string(
-      reinterpret_cast<const char*>(Uint8VectorStart(json)), json.size());
+      reinterpret_cast<const char*>(vector_as_array(&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 281 matching lines @@
                      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(),
               Verify(algorithm,
                      key,
-                     CryptoData(Uint8VectorStart(output), output.size() - 1),
+                     CryptoData(vector_as_array(&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(),
               Verify(algorithm,
                      key,
                      CryptoData(),
                      CryptoData(test_message),
@@ skipping 1515 matching lines @@
   // Technically it is OK to fail since JWA says that consumer are not required
   // to support lack of the optional parameters.
   ASSERT_EQ(Status::OperationError(),
             ImportKeyJwkFromDict(dict,
                                  CreateRsaHashedImportAlgorithm(
                                      blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                                      blink::WebCryptoAlgorithmIdSha1),
                                  true,
                                  blink::WebCryptoKeyUsageSign,
                                  &key));
-
 }
 
 TEST_F(SharedCryptoTest, MAYBE(GenerateKeyPairRsa)) {
   // Note: using unrealistic short key lengths here to avoid bogging down tests.
 
   // Successful WebCryptoAlgorithmIdRsaSsaPkcs1v1_5 key generation (sha256)
   const unsigned int modulus_length = 256;
   const std::vector<uint8_t> public_exponent = HexStringToBytes("010001");
   blink::WebCryptoAlgorithm algorithm =
       CreateRsaHashedKeyGenAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
@@ skipping 223 matching lines @@
     blink::WebCryptoAlgorithm algorithm = CreateRsaHashedKeyGenAlgorithm(
         blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
         blink::WebCryptoAlgorithmIdSha256,
         modulus_length,
         HexStringToBytes(kPublicExponents[i]));
 
     blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
     blink::WebCryptoKey private_key = blink::WebCryptoKey::createNull();
 
     EXPECT_EQ(Status::ErrorGenerateKeyPublicExponent(),
-              GenerateKeyPair(
-                  algorithm, true, 0, &public_key, &private_key));
+              GenerateKeyPair(algorithm, true, 0, &public_key, &private_key));
   }
 }
 
 TEST_F(SharedCryptoTest, RsaSsaSignVerifyFailures) {
   if (!SupportsRsaKeyImport())
     return;
 
   // Import a key pair.
   blink::WebCryptoAlgorithm import_algorithm =
       CreateRsaHashedImportAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
@@ skipping 19 matching lines @@
   // Compute a signature.
   const std::vector<uint8_t> 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(),
       Verify(algorithm,
              public_key,
-             CryptoData(Uint8VectorStart(signature), signature.size() - 1),
+             CryptoData(vector_as_array(&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(),
             Verify(algorithm,
                    public_key,
                    CryptoData(),
                    CryptoData(data),
@@ skipping 685 matching lines @@
   std::vector<uint8_t> wrapping_key_data(16, 0);
   std::vector<uint8_t> wrapped_key = HexStringToBytes(
       "1A07ACAB6C906E50883173C29441DB1DE91D34F45C435B5F99C822867FB3956F");
 
   blink::WebCryptoKey wrapping_key =
       ImportSecretKeyFromRaw(wrapping_key_data,
                              CreateAlgorithm(blink::WebCryptoAlgorithmIdAesKw),
                              blink::WebCryptoKeyUsageUnwrapKey);
 
   blink::WebCryptoKey unwrapped_key = blink::WebCryptoKey::createNull();
-      ASSERT_EQ(Status::ErrorAes192BitUnsupported(),
-                UnwrapKey(blink::WebCryptoKeyFormatRaw,
-                          CryptoData(wrapped_key),
-                          wrapping_key,
-                          CreateAlgorithm(blink::WebCryptoAlgorithmIdAesKw),
-                          CreateAlgorithm(blink::WebCryptoAlgorithmIdAesCbc),
-                          true,
-                          blink::WebCryptoKeyUsageEncrypt,
-                          &unwrapped_key));
+  ASSERT_EQ(Status::ErrorAes192BitUnsupported(),
+            UnwrapKey(blink::WebCryptoKeyFormatRaw,
+                      CryptoData(wrapped_key),
+                      wrapping_key,
+                      CreateAlgorithm(blink::WebCryptoAlgorithmIdAesKw),
+                      CreateAlgorithm(blink::WebCryptoAlgorithmIdAesCbc),
+                      true,
+                      blink::WebCryptoKeyUsageEncrypt,
+                      &unwrapped_key));
 }
 
 class SharedCryptoRsaOaepTest : public ::testing::Test {
  public:
   scoped_ptr<base::DictionaryValue> CreatePublicKeyJwkDict() {
     scoped_ptr<base::DictionaryValue> jwk(new base::DictionaryValue());
     jwk->SetString("kty", "RSA");
     jwk->SetString("n",
                    Base64EncodeUrlSafe(HexStringToBytes(kPublicKeyModulusHex)));
     jwk->SetString(
@@ skipping 958 matching lines @@
   EXPECT_EQ(public_key_spki, unwrapped_public_key_spki);
   EXPECT_EQ(private_key_pkcs8, unwrapped_private_key_pkcs8);
 
   EXPECT_NE(public_key_spki, wrapped_public_key);
   EXPECT_NE(private_key_pkcs8, wrapped_private_key);
 }
 
 }  // namespace webcrypto
 
 }  // namespace content