Switch to standard integer types in device/.

device/usb/usb_device_handle_impl.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 "device/usb/usb_device_handle_impl.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/location.h"
+#include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string16.h"
 #include "base/synchronization/lock.h"
 #include "base/thread_task_runner_handle.h"
 #include "components/device_event_log/device_event_log.h"
 #include "device/usb/usb_context.h"
 #include "device/usb/usb_descriptors.h"
 #include "device/usb/usb_device_impl.h"
 #include "device/usb/usb_error.h"
@@ skipping 226 matching lines @@
   scoped_ptr<Transfer> transfer(new Transfer(
       device_handle, nullptr, USB_TRANSFER_CONTROL, buffer,
       length + LIBUSB_CONTROL_SETUP_SIZE, callback_task_runner, callback));
 
   transfer->platform_transfer_ = libusb_alloc_transfer(0);
   if (!transfer->platform_transfer_) {
     USB_LOG(ERROR) << "Failed to allocate control transfer.";
     return nullptr;
   }
 
-  libusb_fill_control_setup(reinterpret_cast<uint8*>(buffer->data()), type,
+  libusb_fill_control_setup(reinterpret_cast<uint8_t*>(buffer->data()), type,
                             request, value, index, length);
   libusb_fill_control_transfer(transfer->platform_transfer_,
                                device_handle->handle_,
-                               reinterpret_cast<uint8*>(buffer->data()),
+                               reinterpret_cast<uint8_t*>(buffer->data()),
                                &UsbDeviceHandleImpl::Transfer::PlatformCallback,
                                transfer.get(), timeout);
 
   return transfer.Pass();
 }
 
 // static
 scoped_ptr<UsbDeviceHandleImpl::Transfer>
 UsbDeviceHandleImpl::Transfer::CreateBulkTransfer(
     scoped_refptr<UsbDeviceHandleImpl> device_handle,
     uint8_t endpoint,
     scoped_refptr<net::IOBuffer> buffer,
     int length,
     unsigned int timeout,
     scoped_refptr<base::TaskRunner> callback_task_runner,
     const TransferCallback& callback) {
   scoped_ptr<Transfer> transfer(new Transfer(
       device_handle, device_handle->GetClaimedInterfaceForEndpoint(endpoint),
       USB_TRANSFER_BULK, buffer, length, callback_task_runner, callback));
 
   transfer->platform_transfer_ = libusb_alloc_transfer(0);
   if (!transfer->platform_transfer_) {
     USB_LOG(ERROR) << "Failed to allocate bulk transfer.";
     return nullptr;
   }
 
   libusb_fill_bulk_transfer(
       transfer->platform_transfer_, device_handle->handle_, endpoint,
-      reinterpret_cast<uint8*>(buffer->data()), static_cast<int>(length),
+      reinterpret_cast<uint8_t*>(buffer->data()), static_cast<int>(length),
       &UsbDeviceHandleImpl::Transfer::PlatformCallback, transfer.get(),
       timeout);
 
   return transfer.Pass();
 }
 
 // static
 scoped_ptr<UsbDeviceHandleImpl::Transfer>
 UsbDeviceHandleImpl::Transfer::CreateInterruptTransfer(
     scoped_refptr<UsbDeviceHandleImpl> device_handle,
     uint8_t endpoint,
     scoped_refptr<net::IOBuffer> buffer,
     int length,
     unsigned int timeout,
     scoped_refptr<base::TaskRunner> callback_task_runner,
     const TransferCallback& callback) {
   scoped_ptr<Transfer> transfer(new Transfer(
       device_handle, device_handle->GetClaimedInterfaceForEndpoint(endpoint),
       USB_TRANSFER_INTERRUPT, buffer, length, callback_task_runner, callback));
 
   transfer->platform_transfer_ = libusb_alloc_transfer(0);
   if (!transfer->platform_transfer_) {
     USB_LOG(ERROR) << "Failed to allocate interrupt transfer.";
     return nullptr;
   }
 
   libusb_fill_interrupt_transfer(
       transfer->platform_transfer_, device_handle->handle_, endpoint,
-      reinterpret_cast<uint8*>(buffer->data()), static_cast<int>(length),
+      reinterpret_cast<uint8_t*>(buffer->data()), static_cast<int>(length),
       &UsbDeviceHandleImpl::Transfer::PlatformCallback, transfer.get(),
       timeout);
 
   return transfer.Pass();
 }
 
 // static
 scoped_ptr<UsbDeviceHandleImpl::Transfer>
 UsbDeviceHandleImpl::Transfer::CreateIsochronousTransfer(
     scoped_refptr<UsbDeviceHandleImpl> device_handle,
@@ skipping 14 matching lines @@
       callback));
 
   transfer->platform_transfer_ = libusb_alloc_transfer(packets);
   if (!transfer->platform_transfer_) {
     USB_LOG(ERROR) << "Failed to allocate isochronous transfer.";
     return nullptr;
   }
 
   libusb_fill_iso_transfer(
       transfer->platform_transfer_, device_handle->handle_, endpoint,
-      reinterpret_cast<uint8*>(buffer->data()), static_cast<int>(length),
+      reinterpret_cast<uint8_t*>(buffer->data()), static_cast<int>(length),
       packets, &Transfer::PlatformCallback, transfer.get(), timeout);
   libusb_set_iso_packet_lengths(transfer->platform_transfer_, packet_length);
 
   return transfer.Pass();
 }
 
 UsbDeviceHandleImpl::Transfer::Transfer(
     scoped_refptr<UsbDeviceHandleImpl> device_handle,
     scoped_refptr<InterfaceClaimer> claimed_interface,
     UsbTransferType transfer_type,
@@ skipping 643 matching lines @@
   // Attempt-release all the interfaces.
   // It will be retained until the transfer cancellation is finished.
   claimed_interfaces_.clear();
 
   // Cannot close device handle here. Need to wait for libusb_cancel_transfer to
   // finish.
   device_ = NULL;
 }
 
 }  // namespace device