Switch to standard integer types in chrome/browser/, part 1 of 4.

chrome/browser/devtools/device/usb/android_usb_device.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/devtools/device/usb/android_usb_device.h"
 
 #include <set>
 
 #include "base/barrier_closure.h"
 #include "base/base64.h"
@@ skipping 27 matching lines @@
 namespace {
 
 const size_t kHeaderSize = 24;
 
 const int kAdbClass = 0xff;
 const int kAdbSubclass = 0x42;
 const int kAdbProtocol = 0x1;
 
 const int kUsbTimeout = 0;
 
-const uint32 kMaxPayload = 4096;
-const uint32 kVersion = 0x01000000;
+const uint32_t kMaxPayload = 4096;
+const uint32_t kVersion = 0x01000000;
 
 static const char kHostConnectMessage[] = "host::";
 
 using content::BrowserThread;
 
 typedef std::vector<scoped_refptr<UsbDevice> > UsbDevices;
 typedef std::set<scoped_refptr<UsbDevice> > UsbDeviceSet;
 
 // Stores android wrappers around claimed usb devices on caller thread.
 base::LazyInstance<std::vector<AndroidUsbDevice*> >::Leaky g_devices =
@@ skipping 21 matching lines @@
           ++device_count;
         }
       }
     }
   }
 
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(callback, device_count));
 }
 
-uint32 Checksum(const std::string& data) {
+uint32_t Checksum(const std::string& data) {
   unsigned char* x = (unsigned char*)data.data();
   int count = data.length();
-  uint32 sum = 0;
+  uint32_t sum = 0;
   while (count-- > 0)
     sum += *x++;
   return sum;
 }
 
 void DumpMessage(bool outgoing, const char* data, size_t length) {
 #if 0
   std::string result = "";
   if (length == kHeaderSize) {
     for (size_t i = 0; i < 24; ++i) {
@@ skipping 178 matching lines @@
     caller_task_runner->PostTask(FROM_HERE,
                                  base::Bind(callback, AndroidUsbDevices()));
   } else {
     service->GetDevices(
         base::Bind(&OpenAndroidDevices, rsa_key, callback, caller_task_runner));
   }
 }
 
 }  // namespace
 
-AdbMessage::AdbMessage(uint32 command,
-                       uint32 arg0,
-                       uint32 arg1,
+AdbMessage::AdbMessage(uint32_t command,
+                       uint32_t arg0,
+                       uint32_t arg1,
                        const std::string& body)
-    : command(command), arg0(arg0), arg1(arg1), body(body) {
-}
+    : command(command), arg0(arg0), arg1(arg1), body(body) {}
 
 AdbMessage::~AdbMessage() {
 }
 
 // static
 void AndroidUsbDevice::CountDevices(const base::Callback<void(int)>& callback) {
   UsbService* service = device::DeviceClient::Get()->GetUsbService();
   if (service != NULL) {
     service->GetDevices(base::Bind(&CountAndroidDevices, callback));
   } else {
@@ skipping 46 matching lines @@
   task_runner_ = base::ThreadTaskRunnerHandle::Get();
   Queue(make_scoped_ptr(new AdbMessage(AdbMessage::kCommandCNXN, kVersion,
                                        kMaxPayload, kHostConnectMessage)));
   ReadHeader();
 }
 
 net::StreamSocket* AndroidUsbDevice::CreateSocket(const std::string& command) {
   if (!usb_handle_.get())
     return NULL;
 
-  uint32 socket_id = ++last_socket_id_;
+  uint32_t socket_id = ++last_socket_id_;
   sockets_[socket_id] = new AndroidUsbSocket(this, socket_id, command,
       base::Bind(&AndroidUsbDevice::SocketDeleted, this, socket_id));
   return sockets_[socket_id];
 }
 
-void AndroidUsbDevice::Send(uint32 command,
-                            uint32 arg0,
-                            uint32 arg1,
+void AndroidUsbDevice::Send(uint32_t command,
+                            uint32_t arg0,
+                            uint32_t arg1,
                             const std::string& body) {
   scoped_ptr<AdbMessage> message(new AdbMessage(command, arg0, arg1, body));
   // Delay open request if not yet connected.
   if (!is_connected_) {
     pending_messages_.push_back(message.release());
     return;
   }
   Queue(message.Pass());
 }
 
 AndroidUsbDevice::~AndroidUsbDevice() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   Terminate();
 }
 
 void AndroidUsbDevice::Queue(scoped_ptr<AdbMessage> message) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // Queue header.
-  std::vector<uint32> header;
+  std::vector<uint32_t> header;
   header.push_back(message->command);
   header.push_back(message->arg0);
   header.push_back(message->arg1);
   bool append_zero = true;
   if (message->body.empty())
     append_zero = false;
   if (message->command == AdbMessage::kCommandAUTH &&
       message->arg0 == AdbMessage::kAuthSignature)
     append_zero = false;
   if (message->command == AdbMessage::kCommandWRTE)
@@ skipping 76 matching lines @@
                            base::Bind(&AndroidUsbDevice::ReadHeader, this));
     return;
   }
 
   if (status != device::USB_TRANSFER_COMPLETED || result != kHeaderSize) {
     TransferError(status);
     return;
   }
 
   DumpMessage(false, buffer->data(), result);
-  std::vector<uint32> header(6);
+  std::vector<uint32_t> header(6);
   memcpy(&header[0], buffer->data(), result);
   scoped_ptr<AdbMessage> message(
       new AdbMessage(header[0], header[1], header[2], ""));
-  uint32 data_length = header[3];
-  uint32 data_check = header[4];
-  uint32 magic = header[5];
+  uint32_t data_length = header[3];
+  uint32_t data_check = header[4];
+  uint32_t magic = header[5];
   if ((message->command ^ 0xffffffff) != magic) {
     TransferError(device::USB_TRANSFER_ERROR);
     return;
   }
 
   if (data_length == 0) {
     task_runner_->PostTask(FROM_HERE,
                            base::Bind(&AndroidUsbDevice::HandleIncoming, this,
                                       base::Passed(&message)));
   } else {
     task_runner_->PostTask(
         FROM_HERE, base::Bind(&AndroidUsbDevice::ReadBody, this,
                               base::Passed(&message), data_length, data_check));
   }
 }
 
 void AndroidUsbDevice::ReadBody(scoped_ptr<AdbMessage> message,
-                                uint32 data_length,
-                                uint32 data_check) {
+                                uint32_t data_length,
+                                uint32_t data_check) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (!usb_handle_.get()) {
     return;
   }
 
   scoped_refptr<net::IOBuffer> buffer =
       new net::IOBuffer(static_cast<size_t>(data_length));
   usb_handle_->GenericTransfer(
       device::USB_DIRECTION_INBOUND, inbound_address_, buffer, data_length,
       kUsbTimeout,
       base::Bind(&AndroidUsbDevice::ParseBody, weak_factory_.GetWeakPtr(),
                  base::Passed(&message), data_length, data_check));
 }
 
 void AndroidUsbDevice::ParseBody(scoped_ptr<AdbMessage> message,
-                                 uint32 data_length,
-                                 uint32 data_check,
+                                 uint32_t data_length,
+                                 uint32_t data_check,
                                  UsbTransferStatus status,
                                  scoped_refptr<net::IOBuffer> buffer,
                                  size_t result) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (status == device::USB_TRANSFER_TIMEOUT) {
     task_runner_->PostTask(
         FROM_HERE, base::Bind(&AndroidUsbDevice::ReadBody, this,
                               base::Passed(&message), data_length, data_check));
     return;
   }
 
   if (status != device::USB_TRANSFER_COMPLETED ||
-      static_cast<uint32>(result) != data_length) {
+      static_cast<uint32_t>(result) != data_length) {
     TransferError(status);
     return;
   }
 
   DumpMessage(false, buffer->data(), data_length);
   message->body = std::string(buffer->data(), result);
   if (Checksum(message->body) != data_check) {
     TransferError(device::USB_TRANSFER_ERROR);
     return;
   }
 
   task_runner_->PostTask(FROM_HERE,
                          base::Bind(&AndroidUsbDevice::HandleIncoming, this,
                                     base::Passed(&message)));
 }
 
 void AndroidUsbDevice::HandleIncoming(scoped_ptr<AdbMessage> message) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   switch (message->command) {
     case AdbMessage::kCommandAUTH:
       {
-        DCHECK_EQ(message->arg0, static_cast<uint32>(AdbMessage::kAuthToken));
+      DCHECK_EQ(message->arg0, static_cast<uint32_t>(AdbMessage::kAuthToken));
         if (signature_sent_) {
           Queue(make_scoped_ptr(new AdbMessage(
               AdbMessage::kCommandAUTH,
               AdbMessage::kAuthRSAPublicKey, 0,
               AndroidRSAPublicKey(rsa_key_.get()))));
         } else {
           signature_sent_ = true;
           std::string signature = AndroidRSASign(rsa_key_.get(), message->body);
           if (!signature.empty()) {
             Queue(make_scoped_ptr(new AdbMessage(AdbMessage::kCommandAUTH,
@@ skipping 73 matching lines @@
        it != sockets.end(); ++it) {
     it->second->Terminated(true);
   }
   DCHECK(sockets_.empty());
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&ReleaseInterface, usb_handle, interface_id_));
 }
 
-void AndroidUsbDevice::SocketDeleted(uint32 socket_id) {
+void AndroidUsbDevice::SocketDeleted(uint32_t socket_id) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   sockets_.erase(socket_id);
 }