Convert vector_as_array to vector::data in //chrome{,cast,os}.

chrome/common/extensions/api/networking_private/networking_private_crypto.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 "chrome/common/extensions/api/networking_private/networking_private_crypto.h"
 
 #include <openssl/digest.h>
 #include <openssl/evp.h>
 #include <openssl/rsa.h>
 #include <openssl/x509.h>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "crypto/openssl_util.h"
 #include "crypto/rsa_private_key.h"
 #include "crypto/scoped_openssl_types.h"
 #include "extensions/common/cast/cast_cert_validator.h"
 #include "net/cert/pem_tokenizer.h"
 
 namespace {
 
 namespace cast_crypto = ::extensions::api::cast_crypto;
@@ skipping 84 matching lines @@
   }
   return true;
 }
 
 bool EncryptByteString(const std::vector<uint8_t>& pub_key_der,
                        const std::string& data,
                        std::vector<uint8_t>* encrypted_output) {
   crypto::EnsureOpenSSLInit();
   crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
 
-  crypto::ScopedRSA rsa(RSA_public_key_from_bytes(vector_as_array(&pub_key_der),
-                                                  pub_key_der.size()));
+  crypto::ScopedRSA rsa(
+      RSA_public_key_from_bytes(pub_key_der.data(), pub_key_der.size()));
   if (!rsa || RSA_size(rsa.get()) == 0) {
     LOG(ERROR) << "Failed to parse public key";
     return false;
   }
 
   encrypted_output->resize(RSA_size(rsa.get()));
   int encrypted_length = RSA_public_encrypt(
       data.size(), reinterpret_cast<const uint8_t*>(data.data()),
-      vector_as_array(encrypted_output), rsa.get(), RSA_PKCS1_PADDING);
+      encrypted_output->data(), rsa.get(), RSA_PKCS1_PADDING);
   if (encrypted_length < 0) {
     LOG(ERROR) << "Error during decryption";
     return false;
   }
   encrypted_output->resize(encrypted_length);
   return true;
 }
 
 bool DecryptByteString(const std::string& private_key_pem,
                        const std::vector<uint8_t>& encrypted_data,
@@ skipping 26 matching lines @@
                           rsa.get(), RSA_PKCS1_PADDING);
   if (output_length < 0) {
     LOG(ERROR) << "Error during decryption.";
     return false;
   }
   decrypted_output->resize(output_length);
   return true;
 }
 
 }  // namespace networking_private_crypto