Switch to standard integer types in chromeos/.

chromeos/dbus/session_manager_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/session_manager_client.h"
 
+#include <stddef.h>
+#include <stdint.h>
 #include <sys/socket.h>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
+#include "base/macros.h"
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/task_runner_util.h"
 #include "base/threading/worker_pool.h"
 #include "chromeos/chromeos_paths.h"
 #include "chromeos/dbus/blocking_method_caller.h"
 #include "chromeos/dbus/cryptohome_client.h"
 #include "crypto/sha2.h"
 #include "dbus/bus.h"
@@ skipping 244 matching lines @@
         callback);
   }
 
   void StoreDevicePolicy(const std::string& policy_blob,
                          const StorePolicyCallback& callback) override {
     dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
                                  login_manager::kSessionManagerStorePolicy);
     dbus::MessageWriter writer(&method_call);
     // static_cast does not work due to signedness.
     writer.AppendArrayOfBytes(
-        reinterpret_cast<const uint8*>(policy_blob.data()), policy_blob.size());
+        reinterpret_cast<const uint8_t*>(policy_blob.data()),
+        policy_blob.size());
     session_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&SessionManagerClientImpl::OnStorePolicy,
                    weak_ptr_factory_.GetWeakPtr(),
                    login_manager::kSessionManagerStorePolicy,
                    callback));
   }
 
   void StorePolicyForUser(const std::string& username,
@@ skipping 149 matching lines @@
   void CallStorePolicyByUsername(const std::string& method_name,
                                  const std::string& username,
                                  const std::string& policy_blob,
                                  const StorePolicyCallback& callback) {
     dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
                                  method_name);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(username);
     // static_cast does not work due to signedness.
     writer.AppendArrayOfBytes(
-        reinterpret_cast<const uint8*>(policy_blob.data()), policy_blob.size());
+        reinterpret_cast<const uint8_t*>(policy_blob.data()),
+        policy_blob.size());
     session_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(
             &SessionManagerClientImpl::OnStorePolicy,
             weak_ptr_factory_.GetWeakPtr(),
             method_name,
             callback));
   }
 
@@ skipping 89 matching lines @@
   }
 
   void ExtractString(const std::string& method_name,
                      dbus::Response* response,
                      std::string* extracted) {
     if (!response) {
       LOG(ERROR) << "Failed to call " << method_name;
       return;
     }
     dbus::MessageReader reader(response);
-    const uint8* values = NULL;
+    const uint8_t* values = NULL;
     size_t length = 0;
     if (!reader.PopArrayOfBytes(&values, &length)) {
       LOG(ERROR) << "Invalid response: " << response->ToString();
       return;
     }
     // static_cast does not work due to signedness.
     extracted->assign(reinterpret_cast<const char*>(values), length);
   }
 
   // Called when kSessionManagerRetrievePolicy or
@@ skipping 73 matching lines @@
       LOG(ERROR) << "Failed to call "
                  << login_manager::kSessionManagerGetServerBackedStateKeys;
     } else {
       dbus::MessageReader reader(response);
       dbus::MessageReader array_reader(NULL);
 
       if (!reader.PopArray(&array_reader)) {
         LOG(ERROR) << "Bad response: " << response->ToString();
       } else {
         while (array_reader.HasMoreData()) {
-          const uint8* data = NULL;
+          const uint8_t* data = NULL;
           size_t size = 0;
           if (!array_reader.PopArrayOfBytes(&data, &size)) {
             LOG(ERROR) << "Bad response: " << response->ToString();
             state_keys.clear();
             break;
           }
           state_keys.push_back(
               std::string(reinterpret_cast<const char*>(data), size));
         }
       }
@@ skipping 230 matching lines @@
 
 SessionManagerClient* SessionManagerClient::Create(
     DBusClientImplementationType type) {
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
     return new SessionManagerClientImpl();
   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
   return new SessionManagerClientStubImpl();
 }
 
 }  // namespace chromeos