Switch to standard integer types in gpu/.

gpu/config/gpu_info_collector_win.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 "gpu/config/gpu_info_collector.h"
 
 // This has to be included before windows.h.
 #include "third_party/re2/re2/re2.h"
 
 #include <windows.h>
 #include <cfgmgr32.h>
 #include <d3d9.h>
 #include <d3d11.h>
 #include <dxgi.h>
 #include <setupapi.h>
+#include <stddef.h>
+#include <stdint.h>
 
 #include "base/command_line.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/scoped_native_library.h"
@@ skipping 56 matching lines @@
   if (key.OpenKey(L"Lenovo", KEY_READ | KEY_WOW64_64KEY))
     return false;
 
   if (key.OpenKey(L"Lenovo dCute", KEY_READ | KEY_WOW64_64KEY))
     return false;
 
   return true;
 }
 
 void DeviceIDToVendorAndDevice(const std::wstring& id,
-                               uint32* vendor_id,
-                               uint32* device_id) {
+                               uint32_t* vendor_id,
+                               uint32_t* device_id) {
   *vendor_id = 0;
   *device_id = 0;
   if (id.length() < 21)
     return;
   base::string16 vendor_id_string = id.substr(8, 4);
   base::string16 device_id_string = id.substr(17, 4);
   int vendor = 0;
   int device = 0;
   base::HexStringToInt(base::UTF16ToASCII(vendor_id_string), &vendor);
   base::HexStringToInt(base::UTF16ToASCII(device_id_string), &device);
@@ skipping 106 matching lines @@
           GPUDriver driver;
 
           driver.driver_vendor = driver_vendor;
           driver.driver_version = driver_version;
           driver.driver_date = driver_date;
           std::wstring id = new_device_id;
 
           if (id.compare(0, device_id.size(), device_id) == 0)
             primary_device = drivers.size();
 
-          uint32 vendor_id = 0, device_id = 0;
+          uint32_t vendor_id = 0, device_id = 0;
           DeviceIDToVendorAndDevice(id, &vendor_id, &device_id);
           driver.device.vendor_id = vendor_id;
           driver.device.device_id = device_id;
           drivers.push_back(driver);
 
           if (vendor_id == 0x8086)
             found_intel = true;
           if (vendor_id == 0x1002)
             found_amd = true;
         }
@@ skipping 116 matching lines @@
     // DirectX diagnostics are collected asynchronously because it takes a
     // couple of seconds.
   } else {
     gpu_info->dx_diagnostics_info_state = kCollectInfoNonFatalFailure;
   }
 
   gpu_info->context_info_state = kCollectInfoSuccess;
   return kCollectInfoSuccess;
 }
 
-CollectInfoResult CollectGpuID(uint32* vendor_id, uint32* device_id) {
+CollectInfoResult CollectGpuID(uint32_t* vendor_id, uint32_t* device_id) {
   DCHECK(vendor_id && device_id);
   *vendor_id = 0;
   *device_id = 0;
 
   // Taken from http://developer.nvidia.com/object/device_ids.html
   DISPLAY_DEVICE dd;
   dd.cb = sizeof(DISPLAY_DEVICE);
   std::wstring id;
   for (int i = 0; EnumDisplayDevices(NULL, i, &dd, 0); ++i) {
     if (dd.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE) {
@@ skipping 125 matching lines @@
   }
 
   MergeGPUInfoGL(basic_gpu_info, context_gpu_info);
 
   basic_gpu_info->dx_diagnostics_info_state =
       context_gpu_info.dx_diagnostics_info_state;
   basic_gpu_info->dx_diagnostics = context_gpu_info.dx_diagnostics;
 }
 
 }  // namespace gpu