Switch to standard integer types in device/.

device/usb/usb_service_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_service_impl.h"
 
+#include <stdint.h>
+
 #include <list>
 #include <set>
 
 #include "base/barrier_closure.h"
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
+#include "build/build_config.h"
 #include "components/device_event_log/device_event_log.h"
 #include "device/usb/usb_device_handle.h"
 #include "device/usb/usb_error.h"
 #include "device/usb/webusb_descriptors.h"
 #include "third_party/libusb/src/libusb/libusb.h"
 
 #if defined(OS_WIN)
 #include <setupapi.h>
 #include <usbiodef.h>
 
@@ skipping 89 matching lines @@
 }
 
 void OnReadStringDescriptor(
     const base::Callback<void(const base::string16&)>& callback,
     UsbTransferStatus status,
     scoped_refptr<net::IOBuffer> buffer,
     size_t length) {
   base::string16 string;
   if (status == USB_TRANSFER_COMPLETED &&
       ParseUsbStringDescriptor(
-          std::vector<uint8>(buffer->data(), buffer->data() + length),
+          std::vector<uint8_t>(buffer->data(), buffer->data() + length),
           &string)) {
     callback.Run(string);
   } else {
     callback.Run(base::string16());
   }
 }
 
 void ReadStringDescriptor(
     scoped_refptr<UsbDeviceHandle> device_handle,
     uint8_t index,
@@ skipping 46 matching lines @@
                                 scoped_refptr<net::IOBuffer> buffer,
                                 size_t length) {
   if (status != USB_TRANSFER_COMPLETED) {
     USB_LOG(EVENT) << "Failed to read WebUSB allowed origins.";
     callback.Run();
     return;
   }
 
   scoped_ptr<WebUsbDescriptorSet> descriptors(new WebUsbDescriptorSet());
   if (descriptors->Parse(
-          std::vector<uint8>(buffer->data(), buffer->data() + length))) {
+          std::vector<uint8_t>(buffer->data(), buffer->data() + length))) {
     UsbDeviceImpl* device_impl = static_cast<UsbDeviceImpl*>(device.get());
     device_impl->set_webusb_allowed_origins(descriptors.Pass());
   }
   callback.Run();
 }
 
 void OnReadWebUsbAllowedOriginsHeader(
     scoped_refptr<UsbDeviceHandle> device_handle,
     const base::Closure& callback,
     uint8_t vendor_code,
@@ skipping 34 matching lines @@
                          scoped_refptr<net::IOBuffer> buffer,
                          size_t length) {
   if (status != USB_TRANSFER_COMPLETED) {
     USB_LOG(EVENT) << "Failed to read BOS descriptor.";
     callback.Run();
     return;
   }
 
   WebUsbPlatformCapabilityDescriptor descriptor;
   if (!descriptor.ParseFromBosDescriptor(
-          std::vector<uint8>(buffer->data(), buffer->data() + length))) {
+          std::vector<uint8_t>(buffer->data(), buffer->data() + length))) {
     callback.Run();
     return;
   }
 
   base::Closure barrier = base::BarrierClosure(2, callback);
   ReadWebUsbLandingPage(device_handle, barrier, descriptor.vendor_code);
   ReadWebUsbAllowedOrigins(device_handle, barrier, descriptor.vendor_code);
 }
 
 void OnReadBosDescriptorHeader(scoped_refptr<UsbDeviceHandle> device_handle,
@@ skipping 530 matching lines @@
   PlatformDeviceMap::iterator it = platform_devices_.find(platform_device);
   if (it != platform_devices_.end()) {
     RemoveDevice(it->second);
   } else {
     devices_being_enumerated_.erase(platform_device);
   }
   libusb_unref_device(platform_device);
 }
 
 }  // namespace device