Remove 'global' user-data in favor of 'process' user-data.

components/browser_watcher/postmortem_report_collector_unittest.cc

 // Copyright 2016 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/browser_watcher/postmortem_report_collector.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <set>
@@ skipping 38 matching lines @@
 using testing::_;
 using testing::Return;
 using testing::SetArgPointee;
 
 namespace {
 
 const char kProductName[] = "TestProduct";
 const char kVersionNumber[] = "TestVersionNumber";
 const char kChannelName[] = "TestChannel";
 
+// The tracker creates some data entries internally.
+const size_t kInternalProcessDatums = 1;
+
 void ContainsKeyValue(
     const google::protobuf::Map<std::string, TypedValue>& data,
     const std::string& key,
     const std::string& value) {
   auto it = data.find(key);
   ASSERT_TRUE(it != data.end());
   EXPECT_EQ(TypedValue::kStringValue, it->second.value_case());
   EXPECT_EQ(value, it->second.string_value());
 }
 
@@ skipping 502 matching lines @@
   StabilityReport report;
   ASSERT_EQ(SUCCESS, collector.CollectOneReport(debug_file_path(), &report));
 
   // Validate the report's log content.
   ASSERT_EQ(2, report.log_messages_size());
   ASSERT_EQ("hello world", report.log_messages(0));
   ASSERT_EQ("foo bar", report.log_messages(1));
 }
 
 TEST_F(PostmortemReportCollectorCollectionFromGlobalTrackerTest,
-       GlobalUserDataCollection) {
+       ProcessUserDataCollection) {
   const char string1[] = "foo";
   const char string2[] = "bar";
 
-  // Record some global user data.
+  // Record some process user data.
   GlobalActivityTracker::CreateWithFile(debug_file_path(), kMemorySize, 0ULL,
                                         "", 3);
-  ActivityUserData& global_data = GlobalActivityTracker::Get()->global_data();
-  global_data.Set("raw", "foo", 3);
-  global_data.SetString("string", "bar");
-  global_data.SetChar("char", '9');
-  global_data.SetInt("int", -9999);
-  global_data.SetUint("uint", 9999);
-  global_data.SetBool("bool", true);
-  global_data.SetReference("ref", string1, strlen(string1));
-  global_data.SetStringReference("sref", string2);
+  ActivityUserData& process_data = GlobalActivityTracker::Get()->process_data();
+  ActivityUserData::Snapshot snapshot;
+  ASSERT_TRUE(process_data.CreateSnapshot(&snapshot));
+  ASSERT_EQ(kInternalProcessDatums, snapshot.size());
+  process_data.Set("raw", "foo", 3);
+  process_data.SetString("string", "bar");
+  process_data.SetChar("char", '9');
+  process_data.SetInt("int", -9999);
+  process_data.SetUint("uint", 9999);
+  process_data.SetBool("bool", true);
+  process_data.SetReference("ref", string1, strlen(string1));
+  process_data.SetStringReference("sref", string2);
 
   // Collect the stability report.
   PostmortemReportCollector collector(kProductName, kVersionNumber,
                                       kChannelName, nullptr);
   StabilityReport report;
   ASSERT_EQ(SUCCESS, collector.CollectOneReport(debug_file_path(), &report));
 
   // Validate the report's user data.
   const auto& collected_data = report.global_data();
-  ASSERT_EQ(12U, collected_data.size());
+  ASSERT_EQ(kInternalProcessDatums + 12U, collected_data.size());
 
   ASSERT_TRUE(base::ContainsKey(collected_data, "raw"));
   EXPECT_EQ(TypedValue::kBytesValue, collected_data.at("raw").value_case());
   EXPECT_EQ("foo", collected_data.at("raw").bytes_value());
 
   ASSERT_TRUE(base::ContainsKey(collected_data, "string"));
   EXPECT_EQ(TypedValue::kStringValue, collected_data.at("string").value_case());
   EXPECT_EQ("bar", collected_data.at("string").string_value());
 
   ASSERT_TRUE(base::ContainsKey(collected_data, "char"));
@@ skipping 35 matching lines @@
   ContainsKeyValue(collected_data, kStabilityReporterPlatform, "Win64");
 #endif
   ContainsKeyValue(collected_data, kStabilityReporterVersion, kVersionNumber);
 }
 
 TEST_F(PostmortemReportCollectorCollectionFromGlobalTrackerTest,
        FieldTrialCollection) {
   // Record some data.
   GlobalActivityTracker::CreateWithFile(debug_file_path(), kMemorySize, 0ULL,
                                         "", 3);
-  ActivityUserData& global_data = GlobalActivityTracker::Get()->global_data();
-  global_data.SetString("string", "bar");
-  global_data.SetString("FieldTrial.string", "bar");
-  global_data.SetString("FieldTrial.foo", "bar");
+  ActivityUserData& process_data = GlobalActivityTracker::Get()->process_data();
+  process_data.SetString("string", "bar");
+  process_data.SetString("FieldTrial.string", "bar");
+  process_data.SetString("FieldTrial.foo", "bar");
 
   // Collect the stability report.
   PostmortemReportCollector collector(kProductName, kVersionNumber,
                                       kChannelName, nullptr);
   StabilityReport report;
   ASSERT_EQ(SUCCESS, collector.CollectOneReport(debug_file_path(), &report));
 
   // Validate the report's experiment and global data.
   ASSERT_EQ(2, report.field_trials_size());
   EXPECT_NE(0U, report.field_trials(0).name_id());
   EXPECT_NE(0U, report.field_trials(0).group_id());
   EXPECT_NE(0U, report.field_trials(1).name_id());
   EXPECT_EQ(report.field_trials(0).group_id(),
             report.field_trials(1).group_id());
 
   // Expect 5 key/value pairs (including product details).
   const auto& collected_data = report.global_data();
-  EXPECT_EQ(5U, collected_data.size());
+  EXPECT_EQ(kInternalProcessDatums + 5U, collected_data.size());
   EXPECT_TRUE(base::ContainsKey(collected_data, "string"));
 }
 
 TEST_F(PostmortemReportCollectorCollectionFromGlobalTrackerTest,
        ModuleCollection) {
   // Record some module information.
   GlobalActivityTracker::CreateWithFile(debug_file_path(), kMemorySize, 0ULL,
                                         "", 3);
 
   base::debug::GlobalActivityTracker::ModuleInfo module_info = {};
@@ skipping 34 matching lines @@
   EXPECT_EQ("", collected_module.version());
   EXPECT_EQ(0LL, collected_module.shrink_down_delta());
   EXPECT_EQ(!module_info.is_loaded, collected_module.is_unloaded());
 }
 
 TEST_F(PostmortemReportCollectorCollectionFromGlobalTrackerTest,
        SystemStateTest) {
   // Setup.
   GlobalActivityTracker::CreateWithFile(debug_file_path(), kMemorySize, 0ULL,
                                         "", 3);
-  ActivityUserData& global_data = GlobalActivityTracker::Get()->global_data();
-  global_data.SetInt(kStabilityStartTimestamp, 12345LL);
+  ActivityUserData& process_data = GlobalActivityTracker::Get()->process_data();
+  process_data.SetInt(kStabilityStartTimestamp, 12345LL);
 
   // Collect.
   MockSystemSessionAnalyzer analyzer;
   EXPECT_CALL(analyzer,
               IsSessionUnclean(base::Time::FromInternalValue(12345LL)))
       .Times(1)
       .WillOnce(Return(SystemSessionAnalyzer::CLEAN));
   PostmortemReportCollector collector(kProductName, kVersionNumber,
                                       kChannelName, &analyzer);
   StabilityReport report;
   ASSERT_EQ(SUCCESS, collector.CollectOneReport(debug_file_path(), &report));
 
   // Validate the report.
   ASSERT_EQ(SystemState::CLEAN, report.system_state().session_state());
 }
 
 }  // namespace browser_watcher