StackSamplingProfiler clean up

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 "base/profiler/stack_sampling_profiler.h"
 #include "base/strings/string_number_conversions.h"
 #include "components/metrics/proto/chrome_user_metrics_extension.pb.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::StackSamplingProfiler;
 using Frame = StackSamplingProfiler::Frame;
 using Module = StackSamplingProfiler::Module;
-using Profile = StackSamplingProfiler::Profile;
+using Profile = StackSamplingProfiler::CallStackProfile;
 using Sample = StackSamplingProfiler::Sample;
 
 namespace metrics {
 
 // Checks that all properties from multiple profiles are filled as expected.
 TEST(CallStackProfileMetricsProviderTest, MultipleProfiles) {
   const uintptr_t module1_base_address = 0x1000;
   const uintptr_t module2_base_address = 0x2000;
   const uintptr_t module3_base_address = 0x3000;
 
@@ skipping 168 matching lines @@
         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());
         ASSERT_TRUE(entry.has_module_id_index());
         EXPECT_EQ(profile_sample_frames[i][j][k].module_index,
-                  entry.module_id_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::IntToString(j));
       const CallStackProfile::ModuleIdentifier& module_identifier =
           call_stack_profile.module_id().Get(j);
       ASSERT_TRUE(module_identifier.has_build_id());
@@ skipping 76 matching lines @@
       SCOPED_TRACE("frame " + base::IntToString(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());
       ASSERT_TRUE(entry.has_module_id_index());
-      EXPECT_EQ(sample_frames[i][j].module_index, entry.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(CallStackProfileMetricsProviderTest, RepeatedStacksOrdered) {
   const uintptr_t module_base_address = 0x1000;
 
   const Module modules[] = {
@@ skipping 55 matching lines @@
       SCOPED_TRACE("frame " + base::IntToString(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());
       ASSERT_TRUE(entry.has_module_id_index());
-      EXPECT_EQ(sample_frames[i][j].module_index, entry.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(CallStackProfileMetricsProviderTest, UnknownModule) {
-  // -1 indicates an unknown module.
-  const Frame frame(reinterpret_cast<const void*>(0x1000), -1);
+  const Frame frame(reinterpret_cast<const void*>(0x1000),
+                    Frame::kUnknownModuleIndex);
 
   Profile profile;
 
   profile.samples.push_back(Sample(1, frame));
 
   profile.profile_duration = base::TimeDelta::FromMilliseconds(100);
   profile.sampling_period = base::TimeDelta::FromMilliseconds(10);
   profile.preserve_sample_ordering = false;
 
   CallStackProfileMetricsProvider provider;
@@ skipping 12 matching lines @@
       call_stack_profile.sample().Get(0);
   ASSERT_EQ(1, proto_sample.entry().size());
   ASSERT_TRUE(proto_sample.has_count());
   EXPECT_EQ(1u, proto_sample.count());
   const CallStackProfile::Entry& entry = proto_sample.entry().Get(0);
   EXPECT_FALSE(entry.has_address());
   EXPECT_FALSE(entry.has_module_id_index());
 }
 
 }  // namespace metrics