Switch to standard integer types in components/, part 2 of 4.

components/metrics/serialization/serialization_utils_unittest.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 "components/metrics/serialization/serialization_utils.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "components/metrics/serialization/metric_sample.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace metrics {
 namespace {
 
@@ skipping 47 matching lines @@
 }
 
 TEST_F(SerializationUtilsTest, IllegalNameAreFilteredTest) {
   scoped_ptr<MetricSample> sample1 =
       MetricSample::SparseHistogramSample("no space", 10);
   scoped_ptr<MetricSample> sample2 = MetricSample::LinearHistogramSample(
       base::StringPrintf("here%cbhe", '\0'), 1, 3);
 
   EXPECT_FALSE(SerializationUtils::WriteMetricToFile(*sample1.get(), filename));
   EXPECT_FALSE(SerializationUtils::WriteMetricToFile(*sample2.get(), filename));
-  int64 size = 0;
+  int64_t size = 0;
 
   ASSERT_TRUE(!PathExists(filepath) || base::GetFileSize(filepath, &size));
 
   EXPECT_EQ(0, size);
 }
 
 TEST_F(SerializationUtilsTest, BadInputIsCaughtTest) {
   std::string input(
       base::StringPrintf("sparsehistogram%cname foo%c", '\0', '\0'));
   EXPECT_EQ(NULL, MetricSample::ParseSparseHistogram(input).get());
 }
 
 TEST_F(SerializationUtilsTest, MessageSeparatedByZero) {
   scoped_ptr<MetricSample> crash = MetricSample::CrashSample("mycrash");
 
   SerializationUtils::WriteMetricToFile(*crash.get(), filename);
-  int64 size = 0;
+  int64_t size = 0;
   ASSERT_TRUE(base::GetFileSize(filepath, &size));
   // 4 bytes for the size
   // 5 bytes for crash
   // 7 bytes for mycrash
   // 2 bytes for the \0
   // -> total of 18
   EXPECT_EQ(size, 18);
 }
 
 TEST_F(SerializationUtilsTest, MessagesTooLongAreDiscardedTest) {
   // Creates a message that is bigger than the maximum allowed size.
   // As we are adding extra character (crash, \0s, etc), if the name is
   // kMessageMaxLength long, it will be too long.
   std::string name(SerializationUtils::kMessageMaxLength, 'c');
 
   scoped_ptr<MetricSample> crash = MetricSample::CrashSample(name);
   EXPECT_FALSE(SerializationUtils::WriteMetricToFile(*crash.get(), filename));
-  int64 size = 0;
+  int64_t size = 0;
   ASSERT_TRUE(base::GetFileSize(filepath, &size));
   EXPECT_EQ(0, size);
 }
 
 TEST_F(SerializationUtilsTest, ReadLongMessageTest) {
   base::File test_file(filepath,
                        base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_APPEND);
   std::string message(SerializationUtils::kMessageMaxLength + 1, 'c');
 
-  int32 message_size = message.length() + sizeof(int32);
+  int32_t message_size = message.length() + sizeof(int32_t);
   test_file.WriteAtCurrentPos(reinterpret_cast<const char*>(&message_size),
                               sizeof(message_size));
   test_file.WriteAtCurrentPos(message.c_str(), message.length());
   test_file.Close();
 
   scoped_ptr<MetricSample> crash = MetricSample::CrashSample("test");
   SerializationUtils::WriteMetricToFile(*crash.get(), filename);
 
   ScopedVector<MetricSample> samples;
   SerializationUtils::ReadAndTruncateMetricsFromFile(filename, &samples);
@@ skipping 22 matching lines @@
   ASSERT_EQ(vect.size(), size_t(5));
   for (int i = 0; i < 5; i++) {
     ASSERT_TRUE(vect[0] != NULL);
   }
   EXPECT_TRUE(hist->IsEqual(*vect[0]));
   EXPECT_TRUE(crash->IsEqual(*vect[1]));
   EXPECT_TRUE(lhist->IsEqual(*vect[2]));
   EXPECT_TRUE(shist->IsEqual(*vect[3]));
   EXPECT_TRUE(action->IsEqual(*vect[4]));
 
-  int64 size = 0;
+  int64_t size = 0;
   ASSERT_TRUE(base::GetFileSize(filepath, &size));
   ASSERT_EQ(0, size);
 }
 
 }  // namespace
 }  // namespace metrics