Switch //components from vector_as_array to vector::data.

components/webcrypto/algorithms/test_helpers.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 "components/webcrypto/algorithms/test_helpers.h"
 
 #include <algorithm>
 
 #include "base/base64url.h"
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.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/values.h"
 #include "components/test_runner/test_common.h"
 #include "components/webcrypto/algorithm_dispatch.h"
 #include "components/webcrypto/crypto_data.h"
 #include "components/webcrypto/generate_key_result.h"
 #include "components/webcrypto/jwk.h"
 #include "components/webcrypto/status.h"
 #include "third_party/WebKit/public/platform/WebCryptoAlgorithmParams.h"
@@ skipping 77 matching lines @@
   return result;
 }
 
 blink::WebCryptoAlgorithm CreateRsaHashedKeyGenAlgorithm(
     blink::WebCryptoAlgorithmId algorithm_id,
     const blink::WebCryptoAlgorithmId hash_id,
     unsigned int modulus_length,
     const std::vector<uint8_t>& public_exponent) {
   DCHECK(blink::WebCryptoAlgorithm::isHash(hash_id));
   return blink::WebCryptoAlgorithm::adoptParamsAndCreate(
-      algorithm_id, new blink::WebCryptoRsaHashedKeyGenParams(
-                        CreateAlgorithm(hash_id), modulus_length,
-                        vector_as_array(&public_exponent),
-                        static_cast<unsigned int>(public_exponent.size())));
+      algorithm_id,
+      new blink::WebCryptoRsaHashedKeyGenParams(
+          CreateAlgorithm(hash_id), modulus_length, public_exponent.data(),
+          static_cast<unsigned int>(public_exponent.size())));
 }
 
 std::vector<uint8_t> Corrupted(const std::vector<uint8_t>& input) {
   std::vector<uint8_t> corrupted_data(input);
   if (corrupted_data.empty())
     corrupted_data.push_back(0);
   corrupted_data[corrupted_data.size() / 2] ^= 0x01;
   return corrupted_data;
 }
 
@@ skipping 254 matching lines @@
                             bool extractable,
                             blink::WebCryptoKeyUsageMask usages,
                             blink::WebCryptoKey* key) {
   return ImportKey(blink::WebCryptoKeyFormatJwk,
                    CryptoData(MakeJsonVector(dict)), algorithm, extractable,
                    usages, key);
 }
 
 scoped_ptr<base::DictionaryValue> GetJwkDictionary(
     const std::vector<uint8_t>& json) {
-  base::StringPiece json_string(
-      reinterpret_cast<const char*>(vector_as_array(&json)), json.size());
+  base::StringPiece json_string(reinterpret_cast<const char*>(json.data()),
+                                json.size());
   scoped_ptr<base::Value> value = base::JSONReader::Read(json_string);
   EXPECT_TRUE(value.get());
   EXPECT_TRUE(value->IsType(base::Value::TYPE_DICTIONARY));
 
   return scoped_ptr<base::DictionaryValue>(
       static_cast<base::DictionaryValue*>(value.release()));
 }
 
 // Verifies the input dictionary contains the expected values. Exact matches are
 // required on the fields examined.
@@ skipping 284 matching lines @@
 }
 
 blink::WebCryptoAlgorithm CreateEcImportAlgorithm(
     blink::WebCryptoAlgorithmId id,
     blink::WebCryptoNamedCurve named_curve) {
   return blink::WebCryptoAlgorithm::adoptParamsAndCreate(
       id, new blink::WebCryptoEcKeyImportParams(named_curve));
 }
 
 }  // namespace webcrypto