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

components/webcrypto/algorithms/aes_ctr.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/aes.h>
 #include <openssl/evp.h>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/numerics/safe_math.h"
-#include "base/stl_util.h"
 #include "components/webcrypto/algorithms/aes.h"
 #include "components/webcrypto/algorithms/util.h"
 #include "components/webcrypto/blink_key_handle.h"
 #include "components/webcrypto/crypto_data.h"
 #include "components/webcrypto/status.h"
 #include "crypto/openssl_util.h"
 #include "crypto/scoped_openssl_types.h"
 #include "third_party/WebKit/public/platform/WebCryptoAlgorithmParams.h"
 
 namespace webcrypto {
@@ skipping 75 matching lines @@
   }
 
   // Otherwise make a copy of the counter and zero out the topmost bits so
   // BN_bin2bn() can be called with a byte stream.
   unsigned int byte_length = CeilDiv(counter_length_bits, 8u);
   std::vector<uint8_t> counter(
       counter_block.bytes() + counter_block.byte_length() - byte_length,
       counter_block.bytes() + counter_block.byte_length());
   counter[0] &= ~(0xFF << counter_length_remainder_bits);
 
-  return crypto::ScopedBIGNUM(
-      BN_bin2bn(vector_as_array(&counter), counter.size(), NULL));
+  return crypto::ScopedBIGNUM(BN_bin2bn(counter.data(), counter.size(), NULL));
 }
 
 // Returns a counter block with the counter bits all set all zero.
 std::vector<uint8_t> BlockWithZeroedCounter(const CryptoData& counter_block,
                                             unsigned int counter_length_bits) {
   unsigned int counter_length_bytes = counter_length_bits / 8;
   unsigned int counter_length_bits_remainder = counter_length_bits % 8;
 
   std::vector<uint8_t> new_counter_block(
       counter_block.bytes(),
@@ skipping 80 matching lines @@
 
   if (!BN_sub(num_blocks_until_reset.get(), num_counter_values.get(),
               current_counter.get())) {
     return Status::ErrorUnexpected();
   }
 
   // If the counter can be incremented for the entire input without
   // wrapping-around, do it as a single call into BoringSSL.
   if (BN_cmp(num_blocks_until_reset.get(), num_output_blocks.get()) >= 0) {
     return AesCtrEncrypt128BitCounter(cipher, CryptoData(raw_key), data,
-                                      counter_block, vector_as_array(buffer));
+                                      counter_block, buffer->data());
   }
 
   // Otherwise the encryption needs to be done in 2 parts. The first part using
   // the current counter_block, and the next part resetting the counter portion
   // of the block to zero.
 
   // This is guaranteed to fit in an "unsigned int" because input size in bytes
   // fits in an "unsigned int".
   BN_ULONG num_blocks_part1 = BN_get_word(num_blocks_until_reset.get());
   BN_ULONG input_size_part1 = num_blocks_part1 * AES_BLOCK_SIZE;
   DCHECK_LT(input_size_part1, data.byte_length());
 
   // Encrypt the first part (before wrap-around).
   Status status = AesCtrEncrypt128BitCounter(
       cipher, CryptoData(raw_key), CryptoData(data.bytes(), input_size_part1),
-      counter_block, vector_as_array(buffer));
+      counter_block, buffer->data());
   if (status.IsError())
     return status;
 
   // Encrypt the second part (after wrap-around).
   std::vector<uint8_t> counter_block_part2 =
       BlockWithZeroedCounter(counter_block, counter_length_bits);
 
   return AesCtrEncrypt128BitCounter(
       cipher, CryptoData(raw_key),
       CryptoData(data.bytes() + input_size_part1,
                  data.byte_length() - input_size_part1),
-      CryptoData(counter_block_part2),
-      vector_as_array(buffer) + input_size_part1);
+      CryptoData(counter_block_part2), buffer->data() + input_size_part1);
 }
 
 class AesCtrImplementation : public AesAlgorithm {
  public:
   AesCtrImplementation() : AesAlgorithm("CTR") {}
 
   Status Encrypt(const blink::WebCryptoAlgorithm& algorithm,
                  const blink::WebCryptoKey& key,
                  const CryptoData& data,
                  std::vector<uint8_t>* buffer) const override {
     return AesCtrEncryptDecrypt(algorithm, key, data, buffer);
   }
 
   Status Decrypt(const blink::WebCryptoAlgorithm& algorithm,
                  const blink::WebCryptoKey& key,
                  const CryptoData& data,
                  std::vector<uint8_t>* buffer) const override {
     return AesCtrEncryptDecrypt(algorithm, key, data, buffer);
   }
 };
 
 }  // namespace
 
 scoped_ptr<AlgorithmImplementation> CreateAesCtrImplementation() {
   return make_scoped_ptr(new AesCtrImplementation);
 }
 
 }  // namespace webcrypto