Make vector_as_array use std::vector::data and switch a few directories.

components/policy/core/common/cloud/policy_builder.cc

 // Copyright (c) 2012 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/policy/core/common/cloud/policy_builder.h"
 
 #include <vector>
 
-#include "base/stl_util.h"
 #include "components/policy/core/common/cloud/cloud_policy_constants.h"
 #include "crypto/signature_creator.h"
 
 namespace em = enterprise_management;
 
 namespace policy {
 
 namespace {
 
 // Signing key test data in DER-encoded PKCS8 format.
@@ skipping 190 matching lines @@
   raw_new_signing_key_signature_.clear();
 }
 
 void PolicyBuilder::Build() {
   // Generate signatures if applicable.
   scoped_ptr<crypto::RSAPrivateKey> policy_signing_key = GetNewSigningKey();
   if (policy_signing_key) {
     // Add the new public key.
     std::vector<uint8> raw_new_public_signing_key;
     CHECK(policy_signing_key->ExportPublicKey(&raw_new_public_signing_key));
-    policy_.set_new_public_key(vector_as_array(&raw_new_public_signing_key),
+    policy_.set_new_public_key(raw_new_public_signing_key.data(),
                                raw_new_public_signing_key.size());
 
     policy_.set_new_public_key_verification_signature(
         raw_new_signing_key_signature_);
 
     // The new public key must be signed by the old key.
     scoped_ptr<crypto::RSAPrivateKey> old_signing_key = GetSigningKey();
     if (old_signing_key) {
       SignData(policy_.new_public_key(),
                old_signing_key.get(),
@@ skipping 63 matching lines @@
 void PolicyBuilder::SignData(const std::string& data,
                              crypto::RSAPrivateKey* key,
                              std::string* signature) {
   scoped_ptr<crypto::SignatureCreator> signature_creator(
       crypto::SignatureCreator::Create(key,
                                        crypto::SignatureCreator::SHA1));
   signature_creator->Update(reinterpret_cast<const uint8*>(data.c_str()),
                             data.size());
   std::vector<uint8> signature_bytes;
   CHECK(signature_creator->Final(&signature_bytes));
-  signature->assign(
-      reinterpret_cast<const char*>(vector_as_array(&signature_bytes)),
-      signature_bytes.size());
+  signature->assign(reinterpret_cast<const char*>(signature_bytes.data()),
+                    signature_bytes.size());
 }
 
 template<>
 TypedPolicyBuilder<em::CloudPolicySettings>::TypedPolicyBuilder()
     : payload_(new em::CloudPolicySettings()) {
   policy_data().set_policy_type(dm_protocol::kChromeUserPolicyType);
 }
 
 // Have the instantiation compiled into the module.
 template class TypedPolicyBuilder<em::CloudPolicySettings>;
 
 #if !defined(OS_ANDROID) && !defined(OS_IOS)
 template<>
 TypedPolicyBuilder<em::ExternalPolicyData>::TypedPolicyBuilder()
     : payload_(new em::ExternalPolicyData()) {
   policy_data().set_policy_type(dm_protocol::kChromeExtensionPolicyType);
 }
 
 template class TypedPolicyBuilder<em::ExternalPolicyData>;
 #endif
 
 }  // namespace policy