Switch to standard integer types in gpu/.

gpu/config/gpu_control_list_unittest.cc

 // Copyright (c) 2013 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 <stdint.h>
+
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "gpu/config/gpu_control_list.h"
 #include "gpu/config/gpu_info.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 const char kOsVersion[] = "10.6.4";
-const uint32 kIntelVendorId = 0x8086;
-const uint32 kNvidiaVendorId = 0x10de;
-const uint32 kAmdVendorId = 0x10de;
+const uint32_t kIntelVendorId = 0x8086;
+const uint32_t kNvidiaVendorId = 0x10de;
+const uint32_t kAmdVendorId = 0x10de;
 
 #define LONG_STRING_CONST(...) #__VA_ARGS__
 
 #define EXPECT_EMPTY_SET(feature_set) EXPECT_EQ(0u, feature_set.size())
 #define EXPECT_SINGLE_FEATURE(feature_set, feature) \
     EXPECT_TRUE(feature_set.size() == 1 && feature_set.count(feature) == 1)
 
 namespace gpu {
 
 enum TestFeatureType {
@@ skipping 103 matching lines @@
       GpuControlList::kOsMacosx, kOsVersion, gpu_info());
   EXPECT_SINGLE_FEATURE(features, TEST_FEATURE_0);
 
   // Invalid json input should not change the current control_list settings.
   const std::string invalid_json = "invalid";
 
   EXPECT_FALSE(control_list->LoadList(invalid_json, GpuControlList::kAllOs));
   features = control_list->MakeDecision(
       GpuControlList::kOsMacosx, kOsVersion, gpu_info());
   EXPECT_SINGLE_FEATURE(features, TEST_FEATURE_0);
-  std::vector<uint32> entries;
+  std::vector<uint32_t> entries;
   control_list->GetDecisionEntries(&entries, false);
   ASSERT_EQ(1u, entries.size());
   EXPECT_EQ(5u, entries[0]);
   EXPECT_EQ(5u, control_list->max_entry_id());
 }
 
 TEST_F(GpuControlListTest, VendorOnAllOsEntry) {
   // ControlList a vendor on all OS.
   const std::string vendor_json = LONG_STRING_CONST(
       {
@@ skipping 121 matching lines @@
             ]
           }
         ]
       }
   );
   scoped_ptr<GpuControlList> control_list(Create());
   EXPECT_TRUE(control_list->LoadList(disabled_json, GpuControlList::kAllOs));
   std::set<int> features = control_list->MakeDecision(
       GpuControlList::kOsWin, kOsVersion, gpu_info());
   EXPECT_EMPTY_SET(features);
-  std::vector<uint32> flag_entries;
+  std::vector<uint32_t> flag_entries;
   control_list->GetDecisionEntries(&flag_entries, false);
   EXPECT_EQ(0u, flag_entries.size());
   control_list->GetDecisionEntries(&flag_entries, true);
   EXPECT_EQ(1u, flag_entries.size());
 }
 
 TEST_F(GpuControlListTest, NeedsMoreInfo) {
   const std::string json = LONG_STRING_CONST(
       {
         "name": "gpu control list",
@@ skipping 19 matching lines @@
   GPUInfo gpu_info;
   gpu_info.gpu.vendor_id = kNvidiaVendorId;
 
   scoped_ptr<GpuControlList> control_list(Create());
   EXPECT_TRUE(control_list->LoadList(json, GpuControlList::kAllOs));
 
   std::set<int> features = control_list->MakeDecision(
       GpuControlList::kOsWin, kOsVersion, gpu_info);
   EXPECT_EMPTY_SET(features);
   EXPECT_TRUE(control_list->needs_more_info());
-  std::vector<uint32> decision_entries;
+  std::vector<uint32_t> decision_entries;
   control_list->GetDecisionEntries(&decision_entries, false);
   EXPECT_EQ(0u, decision_entries.size());
 
   gpu_info.driver_version = "11";
   features = control_list->MakeDecision(
       GpuControlList::kOsWin, kOsVersion, gpu_info);
   EXPECT_SINGLE_FEATURE(features, TEST_FEATURE_0);
   EXPECT_FALSE(control_list->needs_more_info());
   control_list->GetDecisionEntries(&decision_entries, false);
   EXPECT_EQ(1u, decision_entries.size());
@@ skipping 324 matching lines @@
         GpuControlList::kOsWin, kOsVersion, gpu_info);
   EXPECT_SINGLE_FEATURE(features, TEST_FEATURE_0);
 
   gpu_info.in_process_gpu = false;
   features = control_list->MakeDecision(
         GpuControlList::kOsWin, kOsVersion, gpu_info);
   EXPECT_EMPTY_SET(features);
 }
 
 }  // namespace gpu