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

components/webcrypto/algorithms/hmac.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 <openssl/hmac.h>
 
 #include "base/logging.h"
 #include "base/numerics/safe_math.h"
-#include "base/stl_util.h"
 #include "components/webcrypto/algorithm_implementation.h"
 #include "components/webcrypto/algorithms/secret_key_util.h"
 #include "components/webcrypto/algorithms/util.h"
 #include "components/webcrypto/blink_key_handle.h"
 #include "components/webcrypto/crypto_data.h"
 #include "components/webcrypto/jwk.h"
 #include "components/webcrypto/status.h"
 #include "crypto/openssl_util.h"
 #include "crypto/secure_util.h"
 #include "third_party/WebKit/public/platform/WebCryptoAlgorithmParams.h"
@@ skipping 68 matching lines @@
                 std::vector<uint8_t>* buffer) {
   crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
 
   const EVP_MD* digest_algorithm = GetDigest(hash);
   if (!digest_algorithm)
     return Status::ErrorUnsupported();
   size_t hmac_expected_length = EVP_MD_size(digest_algorithm);
 
   buffer->resize(hmac_expected_length);
   crypto::ScopedOpenSSLSafeSizeBuffer<EVP_MAX_MD_SIZE> hmac_result(
-      vector_as_array(buffer), hmac_expected_length);
+      buffer->data(), hmac_expected_length);
 
   unsigned int hmac_actual_length;
-  unsigned char* const success = HMAC(
-      digest_algorithm, vector_as_array(&raw_key), raw_key.size(), data.bytes(),
-      data.byte_length(), hmac_result.safe_buffer(), &hmac_actual_length);
+  unsigned char* const success =
+      HMAC(digest_algorithm, raw_key.data(), raw_key.size(), data.bytes(),
+           data.byte_length(), hmac_result.safe_buffer(), &hmac_actual_length);
   if (!success || hmac_actual_length != hmac_expected_length)
     return Status::OperationError();
 
   return Status::Success();
 }
 
 class HmacImplementation : public AlgorithmImplementation {
  public:
   HmacImplementation() {}
 
@@ skipping 129 matching lines @@
                 const CryptoData& signature,
                 const CryptoData& data,
                 bool* signature_match) const override {
     std::vector<uint8_t> result;
     Status status = Sign(algorithm, key, data, &result);
 
     if (status.IsError())
       return status;
 
     // Do not allow verification of truncated MACs.
-    *signature_match =
-        result.size() == signature.byte_length() &&
-        crypto::SecureMemEqual(vector_as_array(&result), signature.bytes(),
-                               signature.byte_length());
+    *signature_match = result.size() == signature.byte_length() &&
+                       crypto::SecureMemEqual(result.data(), signature.bytes(),
+                                              signature.byte_length());
 
     return Status::Success();
   }
 
   Status DeserializeKeyForClone(const blink::WebCryptoKeyAlgorithm& algorithm,
                                 blink::WebCryptoKeyType type,
                                 bool extractable,
                                 blink::WebCryptoKeyUsageMask usages,
                                 const CryptoData& key_data,
                                 blink::WebCryptoKey* key) const override {
@@ skipping 19 matching lines @@
   }
 };
 
 }  // namespace
 
 scoped_ptr<AlgorithmImplementation> CreateHmacImplementation() {
   return make_scoped_ptr(new HmacImplementation);
 }
 
 }  // namespace webcrypto