Switch to standard integer types in chrome/.

chrome/utility/media_galleries/pmp_column_reader_unittest.cc

 // Copyright 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 <stddef.h>
+#include <stdint.h>
+
 #include <algorithm>
 #include <vector>
 
 #include "base/files/file.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "chrome/common/media_galleries/pmp_constants.h"
 #include "chrome/common/media_galleries/pmp_test_util.h"
 #include "chrome/utility/media_galleries/pmp_column_reader.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 20 matching lines @@
     return false;
 
   base::File file(temp_path, base::File::FLAG_OPEN | base::File::FLAG_READ);
   if (!file.IsValid())
     return false;
 
   return reader->ReadFile(&file, expected_type);
 }
 
 // Overridden version of Read method to make test code templatable.
-bool DoRead(const PmpColumnReader* reader, uint32 row, std::string* target) {
+bool DoRead(const PmpColumnReader* reader, uint32_t row, std::string* target) {
   return reader->ReadString(row, target);
 }
 
-bool DoRead(const PmpColumnReader* reader, uint32 row, uint32* target) {
+bool DoRead(const PmpColumnReader* reader, uint32_t row, uint32_t* target) {
   return reader->ReadUInt32(row, target);
 }
 
-bool DoRead(const PmpColumnReader* reader, uint32 row, double* target) {
+bool DoRead(const PmpColumnReader* reader, uint32_t row, double* target) {
   return reader->ReadDouble64(row, target);
 }
 
-bool DoRead(const PmpColumnReader* reader, uint32 row, uint8* target) {
+bool DoRead(const PmpColumnReader* reader, uint32_t row, uint8_t* target) {
   return reader->ReadUInt8(row, target);
 }
 
-bool DoRead(const PmpColumnReader* reader, uint32 row, uint64* target) {
+bool DoRead(const PmpColumnReader* reader, uint32_t row, uint64_t* target) {
   return reader->ReadUInt64(row, target);
 }
 
 // TestValid
 template<class T>
 void TestValid(const PmpFieldType field_type,
                const std::vector<T>& elems) {
   PmpColumnReader reader;
   std::vector<char> data =
       PmpTestUtil::MakeHeaderAndBody(field_type, elems.size(), elems);
   ASSERT_TRUE(InitColumnReaderFromBytes(&reader, data, field_type));
   EXPECT_EQ(elems.size(), reader.rows_read());
 
-  for (uint32 i = 0; i < elems.size() && i < reader.rows_read(); i++) {
+  for (uint32_t i = 0; i < elems.size() && i < reader.rows_read(); i++) {
     T target;
     EXPECT_TRUE(DoRead(&reader, i, &target));
     EXPECT_EQ(elems[i], target);
   }
 }
 
 template<class T>
 void TestMalformed(const PmpFieldType field_type,
                    const std::vector<T>& elems) {
   PmpColumnReader reader_too_few_declared_rows;
@@ skipping 23 matching lines @@
       PmpTestUtil::MakeHeaderAndBody(field_type, elems.size(), elems);
   data_padded.resize(data_padded.size()+10);
   EXPECT_FALSE(InitColumnReaderFromBytes(&reader_padded,
                                          data_padded,
                                          field_type));
 }
 
 template<class T>
 void TestPrimitive(const PmpFieldType field_type) {
   // Make an ascending vector of the primitive.
-  uint32 n = 100;
+  uint32_t n = 100;
   std::vector<T> data(n, 0);
-  for (uint32 i = 0; i < n; i++) {
+  for (uint32_t i = 0; i < n; i++) {
     data[i] = i*3;
   }
 
   TestValid<T>(field_type, data);
   TestMalformed<T>(field_type, data);
 }
 
 
 TEST(PmpColumnReaderTest, HeaderParsingAndValidation) {
   PmpColumnReader reader_good_header;
@@ skipping 55 matching lines @@
   mixed_strings.push_back("");
 
   // Test that a mixed set of strings read correctly.
   TestValid(PMP_TYPE_STRING, mixed_strings);
 
   // Test with the data messed up in a variety of ways.
   TestMalformed(PMP_TYPE_STRING, mixed_strings);
 }
 
 TEST(PmpColumnReaderTest, PrimitiveParsing) {
-  TestPrimitive<uint32>(PMP_TYPE_UINT32);
+  TestPrimitive<uint32_t>(PMP_TYPE_UINT32);
   TestPrimitive<double>(PMP_TYPE_DOUBLE64);
-  TestPrimitive<uint8>(PMP_TYPE_UINT8);
-  TestPrimitive<uint64>(PMP_TYPE_UINT64);
+  TestPrimitive<uint8_t>(PMP_TYPE_UINT8);
+  TestPrimitive<uint64_t>(PMP_TYPE_UINT64);
 }
 
 }  // namespace
 
 }  // namespace picasa