Switch to standard integer types in chrome/browser/chromeos/.

chrome/browser/chromeos/ownership/owner_settings_service_chromeos.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/browser/chromeos/ownership/owner_settings_service_chromeos.h"
 
 #include <keyhi.h>
+#include <stdint.h>
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/prefs/pref_service.h"
 #include "base/threading/thread_checker.h"
@@ skipping 76 matching lines @@
                           FROM_HERE,
                           base::Bind(callback, public_key, private_key));
 }
 
 void LoadPrivateKey(
     const scoped_refptr<OwnerKeyUtil>& owner_key_util,
     const std::string username_hash,
     const base::Callback<void(const scoped_refptr<PublicKey>& public_key,
                               const scoped_refptr<PrivateKey>& private_key)>&
         callback) {
-  std::vector<uint8> public_key_data;
+  std::vector<uint8_t> public_key_data;
   scoped_refptr<PublicKey> public_key;
   if (!owner_key_util->ImportPublicKey(&public_key_data)) {
     scoped_refptr<PrivateKey> private_key;
     BrowserThread::PostTask(BrowserThread::UI,
                             FROM_HERE,
                             base::Bind(callback, public_key, private_key));
     return;
   }
   public_key = new PublicKey();
   public_key->data().swap(public_key_data);
   bool rv = BrowserThread::PostTask(BrowserThread::IO,
                                     FROM_HERE,
                                     base::Bind(&LoadPrivateKeyByPublicKey,
                                                owner_key_util,
                                                public_key,
                                                username_hash,
                                                callback));
   if (!rv) {
     // IO thread doesn't exists in unit tests, but it's safe to use NSS from
     // BlockingPool in unit tests.
     LoadPrivateKeyByPublicKey(
         owner_key_util, public_key, username_hash, callback);
   }
 }
 
 bool DoesPrivateKeyExistAsyncHelper(
     const scoped_refptr<OwnerKeyUtil>& owner_key_util) {
-  std::vector<uint8> public_key;
+  std::vector<uint8_t> public_key;
   if (!owner_key_util->ImportPublicKey(&public_key))
     return false;
   crypto::ScopedSECKEYPrivateKey key =
       crypto::FindNSSKeyFromPublicKeyInfo(public_key);
   return key && SECKEY_GetPrivateKeyType(key.get()) == rsaKey;
 }
 
 // Checks whether NSS slots with private key are mounted or
 // not. Responds via |callback|.
 void DoesPrivateKeyExistAsync(
@@ skipping 671 matching lines @@
   std::vector<OnManagementSettingsSetCallback> callbacks;
   pending_management_settings_callbacks_.swap(callbacks);
   for (const auto& callback : callbacks) {
     if (!callback.is_null())
       callback.Run(success);
   }
   StorePendingChanges();
 }
 
 }  // namespace chromeos