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

components/metrics/call_stack_profile_metrics_provider_unittest.cc

 // Copyright 2015 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/call_stack_profile_metrics_provider.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
+#include "base/macros.h"
 #include "base/metrics/field_trial.h"
 #include "base/profiler/stack_sampling_profiler.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
+#include "build/build_config.h"
 #include "components/metrics/proto/chrome_user_metrics_extension.pb.h"
 #include "components/variations/entropy_provider.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::StackSamplingProfiler;
 using Frame = StackSamplingProfiler::Frame;
 using Module = StackSamplingProfiler::Module;
 using Profile = StackSamplingProfiler::CallStackProfile;
 using Profiles = StackSamplingProfiler::CallStackProfiles;
 using Sample = StackSamplingProfiler::Sample;
@@ skipping 86 matching lines @@
 
   // Values for Windows generated with:
   // perl -MDigest::MD5=md5 -MEncode=encode
   //     -e 'for(@ARGV){printf "%x\n", unpack "Q>", md5 encode "UTF-16LE", $_}'
   //     chrome.exe third_party.dll third_party2.dll
   //
   // Values for Linux generated with:
   // perl -MDigest::MD5=md5
   //     -e 'for(@ARGV){printf "%x\n", unpack "Q>", md5 $_}'
   //     chrome third_party.so third_party2.so
-  const uint64 profile_expected_name_md5_prefixes[][2] = {
-    {
+  const uint64_t profile_expected_name_md5_prefixes[][2] = {
+      {
 #if defined(OS_WIN)
-      0x46c3e4166659ac02ULL,
-      0x7e2b8bfddeae1abaULL
+          0x46c3e4166659ac02ULL, 0x7e2b8bfddeae1abaULL
 #else
-      0x554838a8451ac36cUL,
-      0x843661148659c9f8UL
+          0x554838a8451ac36cUL, 0x843661148659c9f8UL
 #endif
-    },
-    {
+      },
+      {
 #if defined(OS_WIN)
-      0x87b66f4573a4d5caULL,
-      0x46c3e4166659ac02ULL
+          0x87b66f4573a4d5caULL, 0x46c3e4166659ac02ULL
 #else
-      0xb4647e539fa6ec9eUL,
-      0x554838a8451ac36cUL
+          0xb4647e539fa6ec9eUL, 0x554838a8451ac36cUL
 #endif
-    }
-  };
+      }};
 
   // Represents two stack samples for each of two profiles, where each stack
   // contains three frames. Each frame contains an instruction pointer and a
   // module index corresponding to the module for the profile in
   // profile_modules.
   //
   // So, the first stack sample below has its top frame in module 0 at an offset
   // of 0x10 from the module's base address, the next-to-top frame in module 1
   // at an offset of 0x20 from the module's base address, and the bottom frame
   // in module 0 at an offset of 0x30 from the module's base address
@@ skipping 84 matching lines @@
       EXPECT_EQ(1u, proto_sample.count());
       for (size_t k = 0; k < arraysize(profile_sample_frames[i][j]); ++k) {
         SCOPED_TRACE("frame " + base::SizeTToString(k));
         const CallStackProfile::Entry& entry = proto_sample.entry().Get(k);
         ASSERT_TRUE(entry.has_address());
         const char* instruction_pointer = reinterpret_cast<const char*>(
             profile_sample_frames[i][j][k].instruction_pointer);
         const char* module_base_address = reinterpret_cast<const char*>(
             profile_modules[i][profile_sample_frames[i][j][k].module_index]
             .base_address);
-        EXPECT_EQ(static_cast<uint64>(instruction_pointer -
-                                      module_base_address), entry.address());
+        EXPECT_EQ(
+            static_cast<uint64_t>(instruction_pointer - module_base_address),
+            entry.address());
         ASSERT_TRUE(entry.has_module_id_index());
         EXPECT_EQ(profile_sample_frames[i][j][k].module_index,
                   static_cast<size_t>(entry.module_id_index()));
       }
     }
 
     ASSERT_EQ(static_cast<int>(arraysize(profile_modules[i])),
               call_stack_profile.module_id().size());
     for (size_t j = 0; j < arraysize(profile_modules[i]); ++j) {
       SCOPED_TRACE("module " + base::SizeTToString(j));
@@ skipping 80 matching lines @@
     ASSERT_TRUE(proto_sample.has_count());
     EXPECT_EQ(i == 0 ? 3u : 1u, proto_sample.count());
     for (size_t j = 0; j < arraysize(sample_frames[i]); ++j) {
       SCOPED_TRACE("frame " + base::SizeTToString(j));
       const CallStackProfile::Entry& entry = proto_sample.entry().Get(j);
       ASSERT_TRUE(entry.has_address());
       const char* instruction_pointer = reinterpret_cast<const char*>(
           sample_frames[i][j].instruction_pointer);
       const char* module_base_address = reinterpret_cast<const char*>(
           modules[sample_frames[i][j].module_index].base_address);
-      EXPECT_EQ(static_cast<uint64>(instruction_pointer - module_base_address),
-                entry.address());
+      EXPECT_EQ(
+          static_cast<uint64_t>(instruction_pointer - module_base_address),
+          entry.address());
       ASSERT_TRUE(entry.has_module_id_index());
       EXPECT_EQ(sample_frames[i][j].module_index,
                 static_cast<size_t>(entry.module_id_index()));
     }
   }
 }
 
 // Checks that only contiguous duplicate samples are collapsed with
 // preserve_sample_ordering = true.
 TEST_F(CallStackProfileMetricsProviderTest, RepeatedStacksOrdered) {
@@ skipping 56 matching lines @@
     ASSERT_TRUE(proto_sample.has_count());
     EXPECT_EQ(i == 2 ? 2u : 1u, proto_sample.count());
     for (size_t j = 0; j < arraysize(sample_frames[i]); ++j) {
       SCOPED_TRACE("frame " + base::SizeTToString(j));
       const CallStackProfile::Entry& entry = proto_sample.entry().Get(j);
       ASSERT_TRUE(entry.has_address());
       const char* instruction_pointer = reinterpret_cast<const char*>(
           sample_frames[i][j].instruction_pointer);
       const char* module_base_address = reinterpret_cast<const char*>(
           modules[sample_frames[i][j].module_index].base_address);
-      EXPECT_EQ(static_cast<uint64>(instruction_pointer - module_base_address),
-                entry.address());
+      EXPECT_EQ(
+          static_cast<uint64_t>(instruction_pointer - module_base_address),
+          entry.address());
       ASSERT_TRUE(entry.has_module_id_index());
       EXPECT_EQ(sample_frames[i][j].module_index,
                 static_cast<size_t>(entry.module_id_index()));
     }
   }
 }
 
 // Checks that unknown modules produce an empty Entry.
 TEST_F(CallStackProfileMetricsProviderTest, UnknownModule) {
   const Frame frame(0x1000, Frame::kUnknownModuleIndex);
@@ skipping 174 matching lines @@
 
   provider.OnRecordingEnabled();
   callback.Run(std::vector<Profile>(1, profile));
   ChromeUserMetricsExtension uma_proto;
   provider.ProvideGeneralMetrics(&uma_proto);
 
   EXPECT_EQ(0, uma_proto.sampled_profile_size());
 }
 
 }  // namespace metrics