Switch to standard integer types in gpu/.

gpu/config/gpu_test_expectations_parser.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_test_expectations_parser.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 
 namespace gpu {
 
 namespace {
@@ skipping 53 matching lines @@
   kNumberOfExactMatchTokens,
 
   // others
   kConfigGPUDeviceID,
   kTokenComment,
   kTokenWord,
 };
 
 struct TokenInfo {
   const char* name;
-  int32 flag;
+  int32_t flag;
 };
 
 const TokenInfo kTokenData[] = {
     {"xp", GPUTestConfig::kOsWinXP},
     {"vista", GPUTestConfig::kOsWinVista},
     {"win7", GPUTestConfig::kOsWin7},
     {"win8", GPUTestConfig::kOsWin8},
     {"win10", GPUTestConfig::kOsWin10},
     {"win", GPUTestConfig::kOsWin},
     {"leopard", GPUTestConfig::kOsMacLeopard},
@@ skipping 53 matching lines @@
     "entry with expectation modifier conflicts",
     "two entries' configs overlap",
 };
 
 Token ParseToken(const std::string& word) {
   if (base::StartsWith(word, "//", base::CompareCase::INSENSITIVE_ASCII))
     return kTokenComment;
   if (base::StartsWith(word, "0x", base::CompareCase::INSENSITIVE_ASCII))
     return kConfigGPUDeviceID;
 
-  for (int32 i = 0; i < kNumberOfExactMatchTokens; ++i) {
+  for (int32_t i = 0; i < kNumberOfExactMatchTokens; ++i) {
     if (base::LowerCaseEqualsASCII(word, kTokenData[i].name))
       return static_cast<Token>(i);
   }
   return kTokenWord;
 }
 
 // reference name can have the last character as *.
 bool NamesMatching(const std::string& ref, const std::string& test_name) {
   size_t len = ref.length();
   if (len == 0)
@@ skipping 45 matching lines @@
   error_messages_.clear();
 
   std::string data;
   if (!base::ReadFileToString(path, &data)) {
     error_messages_.push_back(kErrorMessage[kErrorFileIO]);
     return false;
   }
   return LoadTestExpectations(data);
 }
 
-int32 GPUTestExpectationsParser::GetTestExpectation(
+int32_t GPUTestExpectationsParser::GetTestExpectation(
     const std::string& test_name,
     const GPUTestBotConfig& bot_config) const {
   for (size_t i = 0; i < entries_.size(); ++i) {
     if (NamesMatching(entries_[i].test_name, test_name) &&
         bot_config.Matches(entries_[i].test_config))
       return entries_[i].test_expectation;
   }
   return kGpuTestPass;
 }
 
@@ skipping 53 matching lines @@
     }
   }
   return true;
 }
 
 bool GPUTestExpectationsParser::ParseLine(
     const std::string& line_data, size_t line_number) {
   std::vector<std::string> tokens = base::SplitString(
       line_data, base::kWhitespaceASCII, base::KEEP_WHITESPACE,
       base::SPLIT_WANT_NONEMPTY);
-  int32 stage = kLineParserBegin;
+  int32_t stage = kLineParserBegin;
   GPUTestExpectationEntry entry;
   entry.line_number = line_number;
   GPUTestConfig& config = entry.test_config;
   bool comments_encountered = false;
   for (size_t i = 0; i < tokens.size() && !comments_encountered; ++i) {
     Token token = ParseToken(tokens[i]);
     switch (token) {
       case kTokenComment:
         comments_encountered = true;
         break;
@@ skipping 107 matching lines @@
         PushErrorMessage(kErrorMessage[kErrorInvalidEntry], line_number);
         return false;
     }
     entries_.push_back(entry);
     return true;
   }
   PushErrorMessage(kErrorMessage[kErrorIllegalEntry], line_number);
   return false;
 }
 
-bool GPUTestExpectationsParser::UpdateTestConfig(
-    GPUTestConfig* config, int32 token, size_t line_number) {
+bool GPUTestExpectationsParser::UpdateTestConfig(GPUTestConfig* config,
+                                                 int32_t token,
+                                                 size_t line_number) {
   DCHECK(config);
   switch (token) {
     case kConfigWinXP:
     case kConfigWinVista:
     case kConfigWin7:
     case kConfigWin8:
     case kConfigWin10:
     case kConfigWin:
     case kConfigMacLeopard:
     case kConfigMacSnowLeopard:
@@ skipping 11 matching lines @@
                          line_number);
         return false;
       }
       config->set_os(config->os() | kTokenData[token].flag);
       break;
     case kConfigNVidia:
     case kConfigAMD:
     case kConfigIntel:
     case kConfigVMWare:
       {
-        uint32 gpu_vendor =
-            static_cast<uint32>(kTokenData[token].flag);
+      uint32_t gpu_vendor = static_cast<uint32_t>(kTokenData[token].flag);
         for (size_t i = 0; i < config->gpu_vendor().size(); ++i) {
           if (config->gpu_vendor()[i] == gpu_vendor) {
             PushErrorMessage(
                 kErrorMessage[kErrorEntryWithGpuVendorConflicts],
                 line_number);
             return false;
           }
         }
         config->AddGPUVendor(gpu_vendor);
       }
@@ skipping 25 matching lines @@
       break;
   }
   return true;
 }
 
 bool GPUTestExpectationsParser::UpdateTestConfig(
     GPUTestConfig* config,
     const std::string& gpu_device_id,
     size_t line_number) {
   DCHECK(config);
-  uint32 device_id = 0;
+  uint32_t device_id = 0;
   if (config->gpu_device_id() != 0 ||
       !base::HexStringToUInt(gpu_device_id, &device_id) ||
       device_id == 0) {
     PushErrorMessage(kErrorMessage[kErrorEntryWithGpuDeviceIdConflicts],
                      line_number);
     return false;
   }
   config->set_gpu_device_id(device_id);
   return true;
 }
@@ skipping 32 matching lines @@
                          message.c_str()));
 }
 
 GPUTestExpectationsParser:: GPUTestExpectationEntry::GPUTestExpectationEntry()
     : test_expectation(0),
       line_number(0) {
 }
 
 }  // namespace gpu