Switch to standard integer types in chromeos/.

chromeos/binder/command_stream.cc

 // Copyright 2015 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/binder/command_stream.h"
 
 #include <linux/android/binder.h>
+#include <stddef.h>
+#include <stdint.h>
 
 #include "base/bind.h"
 #include "chromeos/binder/buffer_reader.h"
 #include "chromeos/binder/driver.h"
 #include "chromeos/binder/transaction_data.h"
 #include "chromeos/binder/transaction_data_from_driver.h"
 #include "chromeos/binder/util.h"
 
 namespace binder {
 
@@ skipping 27 matching lines @@
 }
 
 bool CommandStream::CanProcessIncomingCommand() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return incoming_data_reader_ && incoming_data_reader_->HasMoreData();
 }
 
 bool CommandStream::ProcessIncomingCommand() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(CanProcessIncomingCommand());
-  uint32 command = 0;
+  uint32_t command = 0;
   if (!incoming_data_reader_->Read(&command, sizeof(command)) ||
       !OnIncomingCommand(command, incoming_data_reader_.get())) {
     LOG(ERROR) << "Error while handling command: " << command;
     return false;
   }
   return true;
 }
 
-void CommandStream::AppendOutgoingCommand(uint32 command,
+void CommandStream::AppendOutgoingCommand(uint32_t command,
                                           const void* data,
                                           size_t size) {
   DCHECK(thread_checker_.CalledOnValidThread());
   VLOG(1) << "Appending " << CommandToString(command) << ", this = " << this;
 
   DCHECK_EQ(0u, size % 4);  // Must be 4-byte aligned.
   outgoing_data_.insert(
       outgoing_data_.end(), reinterpret_cast<const char*>(&command),
       reinterpret_cast<const char*>(&command) + sizeof(command));
   outgoing_data_.insert(outgoing_data_.end(),
@@ skipping 11 matching lines @@
       LOG(ERROR) << "WriteRead() failed: pos = " << pos
                  << ", size = " << outgoing_data_.size();
       return false;
     }
     pos += written_bytes;
   }
   outgoing_data_.clear();
   return true;
 }
 
-bool CommandStream::OnIncomingCommand(uint32 command, BufferReader* reader) {
+bool CommandStream::OnIncomingCommand(uint32_t command, BufferReader* reader) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // TODO(hashimoto): Replace all NOTIMPLEMENTED with logic to handle incoming
   // commands.
   VLOG(1) << "Processing " << CommandToString(command) << ", this = " << this;
   switch (command) {
     case BR_ERROR: {
-      int32 error = 0;
+      int32_t error = 0;
       if (!reader->Read(&error, sizeof(error))) {
         LOG(ERROR) << "Failed to read error code.";
         return false;
       }
       break;
     }
     case BR_OK:
       break;
     case BR_TRANSACTION:
       NOTIMPLEMENTED();
@@ skipping 51 matching lines @@
   }
   return true;
 }
 
 void CommandStream::FreeTransactionBuffer(const void* ptr) {
   DCHECK(thread_checker_.CalledOnValidThread());
   AppendOutgoingCommand(BC_FREE_BUFFER, &ptr, sizeof(ptr));
 }
 
 }  // namespace binder