Switch to standard integer types in chromeos/.

chromeos/dbus/cryptohome_client.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 "chromeos/dbus/cryptohome_client.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/bind.h"
 #include "base/location.h"
+#include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "chromeos/cryptohome/async_method_caller.h"
 #include "chromeos/dbus/blocking_method_caller.h"
 #include "chromeos/dbus/cryptohome/key.pb.h"
 #include "chromeos/dbus/cryptohome/rpc.pb.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
 #include "dbus/object_proxy.h"
@@ skipping 323 matching lines @@
     proxy_->CallMethod(
         &method_call, kTpmDBusTimeoutMs ,
         base::Bind(
             &CryptohomeClientImpl::OnPkcs11GetTpmTokenInfoForUser,
             weak_ptr_factory_.GetWeakPtr(),
             callback));
   }
 
   // CryptohomeClient override.
   bool InstallAttributesGet(const std::string& name,
-                            std::vector<uint8>* value,
+                            std::vector<uint8_t>* value,
                             bool* successful) override {
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  cryptohome::kCryptohomeInstallAttributesGet);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(name);
     scoped_ptr<dbus::Response> response(
         blocking_method_caller_->CallMethodAndBlock(&method_call));
     if (!response.get())
       return false;
     dbus::MessageReader reader(response.get());
-    const uint8* bytes = NULL;
+    const uint8_t* bytes = NULL;
     size_t length = 0;
     if (!reader.PopArrayOfBytes(&bytes, &length) ||
         !reader.PopBool(successful))
       return false;
     value->assign(bytes, bytes + length);
     return true;
   }
 
   // CryptohomeClient override.
   bool InstallAttributesSet(const std::string& name,
-                            const std::vector<uint8>& value,
+                            const std::vector<uint8_t>& value,
                             bool* successful) override {
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  cryptohome::kCryptohomeInstallAttributesSet);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(name);
     writer.AppendArrayOfBytes(value.data(), value.size());
     return CallBoolMethodAndBlock(&method_call, successful);
   }
 
   // CryptohomeClient override.
@@ skipping 65 matching lines @@
   // CryptohomeClient override.
   void AsyncTpmAttestationEnroll(attestation::PrivacyCAType pca_type,
                                  const std::string& pca_response,
                                  const AsyncMethodCallback& callback) override {
     dbus::MethodCall method_call(
         cryptohome::kCryptohomeInterface,
         cryptohome::kCryptohomeAsyncTpmAttestationEnroll);
     dbus::MessageWriter writer(&method_call);
     writer.AppendInt32(pca_type);
     writer.AppendArrayOfBytes(
-        reinterpret_cast<const uint8*>(pca_response.data()),
+        reinterpret_cast<const uint8_t*>(pca_response.data()),
         pca_response.size());
     proxy_->CallMethod(&method_call, kTpmDBusTimeoutMs ,
                        base::Bind(&CryptohomeClientImpl::OnAsyncMethodCall,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // CryptohomeClient override.
   void AsyncTpmAttestationCreateCertRequest(
       attestation::PrivacyCAType pca_type,
@@ skipping 20 matching lines @@
       const std::string& pca_response,
       attestation::AttestationKeyType key_type,
       const std::string& user_id,
       const std::string& key_name,
       const AsyncMethodCallback& callback) override {
     dbus::MethodCall method_call(
         cryptohome::kCryptohomeInterface,
         cryptohome::kCryptohomeAsyncTpmAttestationFinishCertRequest);
     dbus::MessageWriter writer(&method_call);
     writer.AppendArrayOfBytes(
-        reinterpret_cast<const uint8*>(pca_response.data()),
+        reinterpret_cast<const uint8_t*>(pca_response.data()),
         pca_response.size());
     bool is_user_specific = (key_type == attestation::KEY_USER);
     writer.AppendBool(is_user_specific);
     writer.AppendString(user_id);
     writer.AppendString(key_name);
     proxy_->CallMethod(&method_call, kTpmDBusTimeoutMs ,
                        base::Bind(&CryptohomeClientImpl::OnAsyncMethodCall,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
@@ skipping 85 matching lines @@
       const AsyncMethodCallback& callback) override {
     dbus::MethodCall method_call(
         cryptohome::kCryptohomeInterface,
         cryptohome::kCryptohomeTpmAttestationSignEnterpriseChallenge);
     dbus::MessageWriter writer(&method_call);
     bool is_user_specific = (key_type == attestation::KEY_USER);
     writer.AppendBool(is_user_specific);
     writer.AppendString(user_id);
     writer.AppendString(key_name);
     writer.AppendString(domain);
-    writer.AppendArrayOfBytes(reinterpret_cast<const uint8*>(device_id.data()),
-                              device_id.size());
+    writer.AppendArrayOfBytes(
+        reinterpret_cast<const uint8_t*>(device_id.data()), device_id.size());
     bool include_signed_public_key =
         (options & attestation::CHALLENGE_INCLUDE_SIGNED_PUBLIC_KEY);
     writer.AppendBool(include_signed_public_key);
-    writer.AppendArrayOfBytes(reinterpret_cast<const uint8*>(challenge.data()),
-                              challenge.size());
+    writer.AppendArrayOfBytes(
+        reinterpret_cast<const uint8_t*>(challenge.data()), challenge.size());
     proxy_->CallMethod(&method_call, kTpmDBusTimeoutMs ,
                        base::Bind(&CryptohomeClientImpl::OnAsyncMethodCall,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // CryptohomeClient override.
   void TpmAttestationSignSimpleChallenge(
       attestation::AttestationKeyType key_type,
       const std::string& user_id,
       const std::string& key_name,
       const std::string& challenge,
       const AsyncMethodCallback& callback) override {
     dbus::MethodCall method_call(
         cryptohome::kCryptohomeInterface,
         cryptohome::kCryptohomeTpmAttestationSignSimpleChallenge);
     dbus::MessageWriter writer(&method_call);
     bool is_user_specific = (key_type == attestation::KEY_USER);
     writer.AppendBool(is_user_specific);
     writer.AppendString(user_id);
     writer.AppendString(key_name);
-    writer.AppendArrayOfBytes(reinterpret_cast<const uint8*>(challenge.data()),
-                              challenge.size());
+    writer.AppendArrayOfBytes(
+        reinterpret_cast<const uint8_t*>(challenge.data()), challenge.size());
     proxy_->CallMethod(&method_call, kTpmDBusTimeoutMs ,
                        base::Bind(&CryptohomeClientImpl::OnAsyncMethodCall,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // CryptohomeClient override.
   void TpmAttestationGetKeyPayload(
       attestation::AttestationKeyType key_type,
       const std::string& user_id,
@@ skipping 21 matching lines @@
       const std::string& payload,
       const BoolDBusMethodCallback& callback) override {
     dbus::MethodCall method_call(
         cryptohome::kCryptohomeInterface,
         cryptohome::kCryptohomeTpmAttestationSetKeyPayload);
     dbus::MessageWriter writer(&method_call);
     bool is_user_specific = (key_type == attestation::KEY_USER);
     writer.AppendBool(is_user_specific);
     writer.AppendString(user_id);
     writer.AppendString(key_name);
-    writer.AppendArrayOfBytes(reinterpret_cast<const uint8*>(payload.data()),
+    writer.AppendArrayOfBytes(reinterpret_cast<const uint8_t*>(payload.data()),
                               payload.size());
     CallBoolMethod(&method_call, callback);
   }
 
   // CryptohomeClient override.
   void TpmAttestationDeleteKeys(
       attestation::AttestationKeyType key_type,
       const std::string& user_id,
       const std::string& key_prefix,
       const BoolDBusMethodCallback& callback) override {
@@ skipping 205 matching lines @@
       LOG(ERROR) << "Invalid response: " << response->ToString();
       return;
     }
     callback.Run(async_id);
   }
 
   // Handles the result of GetSystemSalt().
   void OnGetSystemSalt(const GetSystemSaltCallback& callback,
                        dbus::Response* response) {
     if (!response) {
-      callback.Run(DBUS_METHOD_CALL_FAILURE, std::vector<uint8>());
+      callback.Run(DBUS_METHOD_CALL_FAILURE, std::vector<uint8_t>());
       return;
     }
     dbus::MessageReader reader(response);
-    const uint8* bytes = NULL;
+    const uint8_t* bytes = NULL;
     size_t length = 0;
     if (!reader.PopArrayOfBytes(&bytes, &length)) {
-      callback.Run(DBUS_METHOD_CALL_FAILURE, std::vector<uint8>());
+      callback.Run(DBUS_METHOD_CALL_FAILURE, std::vector<uint8_t>());
       return;
     }
     callback.Run(DBUS_METHOD_CALL_SUCCESS,
-                 std::vector<uint8>(bytes, bytes + length));
+                 std::vector<uint8_t>(bytes, bytes + length));
   }
 
   // Calls a method without result values.
   void CallVoidMethod(dbus::MethodCall* method_call,
                       const VoidDBusMethodCallback& callback) {
     proxy_->CallMethod(method_call, kTpmDBusTimeoutMs ,
                        base::Bind(&CryptohomeClientImpl::OnVoidMethod,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
@@ skipping 62 matching lines @@
   }
 
   // Handles responses for methods with a bool result and data.
   void OnDataMethod(const DataMethodCallback& callback,
                     dbus::Response* response) {
     if (!response) {
       callback.Run(DBUS_METHOD_CALL_FAILURE, false, std::string());
       return;
     }
     dbus::MessageReader reader(response);
-    const uint8* data_buffer = NULL;
+    const uint8_t* data_buffer = NULL;
     size_t data_length = 0;
     bool result = false;
     if (!reader.PopArrayOfBytes(&data_buffer, &data_length) ||
         !reader.PopBool(&result)) {
       callback.Run(DBUS_METHOD_CALL_FAILURE, false, std::string());
       return;
     }
     std::string data(reinterpret_cast<const char*>(data_buffer), data_length);
     callback.Run(DBUS_METHOD_CALL_SUCCESS, result, data);
   }
@@ skipping 68 matching lines @@
     }
     if (!async_call_status_handler_.is_null())
       async_call_status_handler_.Run(async_id, return_status, return_code);
   }
 
   // Handles AsyncCallStatusWithData signal.
   void OnAsyncCallStatusWithData(dbus::Signal* signal) {
     dbus::MessageReader reader(signal);
     int async_id = 0;
     bool return_status = false;
-    const uint8* return_data_buffer = NULL;
+    const uint8_t* return_data_buffer = NULL;
     size_t return_data_length = 0;
     if (!reader.PopInt32(&async_id) ||
         !reader.PopBool(&return_status) ||
         !reader.PopArrayOfBytes(&return_data_buffer, &return_data_length)) {
       LOG(ERROR) << "Invalid signal: " << signal->ToString();
       return;
     }
     if (!async_call_status_data_handler_.is_null()) {
       std::string return_data(reinterpret_cast<const char*>(return_data_buffer),
                               return_data_length);
@@ skipping 35 matching lines @@
   return new CryptohomeClientImpl();
 }
 
 // static
 std::string CryptohomeClient::GetStubSanitizedUsername(
     const std::string& username) {
   return username + kUserIdStubHashSuffix;
 }
 
 }  // namespace chromeos