Switch to standard integer types in chromeos/.

chromeos/dbus/fake_cryptohome_client.cc

 // Copyright 2013 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 "chromeos/dbus/fake_cryptohome_client.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/threading/thread_restrictions.h"
 #include "chromeos/chromeos_paths.h"
 #include "chromeos/dbus/cryptohome/key.pb.h"
 #include "chromeos/dbus/cryptohome/rpc.pb.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
@@ skipping 207 matching lines @@
                  kStubSlot));
 }
 
 void FakeCryptohomeClient::Pkcs11GetTpmTokenInfoForUser(
     const std::string& username,
     const Pkcs11GetTpmTokenInfoCallback& callback) {
   Pkcs11GetTpmTokenInfo(callback);
 }
 
 bool FakeCryptohomeClient::InstallAttributesGet(const std::string& name,
-                                                    std::vector<uint8>* value,
-                                                    bool* successful) {
+                                                std::vector<uint8_t>* value,
+                                                bool* successful) {
   if (install_attrs_.find(name) != install_attrs_.end()) {
     *value = install_attrs_[name];
     *successful = true;
   } else {
     value->clear();
     *successful = false;
   }
   return true;
 }
 
 bool FakeCryptohomeClient::InstallAttributesSet(
     const std::string& name,
-    const std::vector<uint8>& value,
+    const std::vector<uint8_t>& value,
     bool* successful) {
   install_attrs_[name] = value;
   *successful = true;
   return true;
 }
 
 bool FakeCryptohomeClient::InstallAttributesFinalize(bool* successful) {
   locked_ = true;
   *successful = true;
 
@@ skipping 14 matching lines @@
     // scope.
     google::protobuf::io::StringOutputStream result_stream(&result);
     google::protobuf::io::CodedOutputStream result_output(&result_stream);
 
     // These tags encode a variable-length value on the wire, which can be
     // used to encode strings, bytes and messages. We only needs constants
     // for tag numbers 1 and 2 (see install_attributes.proto).
     const int kVarLengthTag1 = (1 << 3) | 0x2;
     const int kVarLengthTag2 = (2 << 3) | 0x2;
 
-    typedef std::map<std::string, std::vector<uint8> >::const_iterator Iter;
+    typedef std::map<std::string, std::vector<uint8_t>>::const_iterator Iter;
     for (Iter it = install_attrs_.begin(); it != install_attrs_.end(); ++it) {
       std::string attr;
       {
         google::protobuf::io::StringOutputStream attr_stream(&attr);
         google::protobuf::io::CodedOutputStream attr_output(&attr_stream);
 
         attr_output.WriteVarint32(kVarLengthTag1);
         attr_output.WriteVarint32(it->first.size());
         attr_output.WriteString(it->first);
         attr_output.WriteVarint32(kVarLengthTag2);
@@ skipping 251 matching lines @@
   service_is_available_ = is_available;
   if (is_available) {
     std::vector<WaitForServiceToBeAvailableCallback> callbacks;
     callbacks.swap(pending_wait_for_service_to_be_available_callbacks_);
     for (size_t i = 0; i < callbacks.size(); ++i)
       callbacks[i].Run(is_available);
   }
 }
 
 // static
-std::vector<uint8> FakeCryptohomeClient::GetStubSystemSalt() {
+std::vector<uint8_t> FakeCryptohomeClient::GetStubSystemSalt() {
   const char kStubSystemSalt[] = "stub_system_salt";
-  return std::vector<uint8>(kStubSystemSalt,
-                            kStubSystemSalt + arraysize(kStubSystemSalt) - 1);
+  return std::vector<uint8_t>(kStubSystemSalt,
+                              kStubSystemSalt + arraysize(kStubSystemSalt) - 1);
 }
 
 void FakeCryptohomeClient::ReturnProtobufMethodCallback(
     const cryptohome::BaseReply& reply,
     const ProtobufMethodCallback& callback) {
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(callback,
                  DBUS_METHOD_CALL_SUCCESS,
                  true,
@@ skipping 27 matching lines @@
         FROM_HERE,
         base::Bind(async_call_status_data_handler_,
                    async_call_id_,
                    true,
                    std::string()));
   }
   ++async_call_id_;
 }
 
 }  // namespace chromeos