Move kInstallDate from chrome/common/pref_names.h to components/metrics/metrics_pref_names.h

components/metrics/metrics_log_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/metrics_log.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/basictypes.h"
@@ skipping 223 matching lines @@
   EXPECT_EQ(10, histogram_proto.bucket(3).min());
 
   // 11-12 becomes /-12 (last record must keep max, min is same as max - 1).
   EXPECT_FALSE(histogram_proto.bucket(4).has_min());
   EXPECT_TRUE(histogram_proto.bucket(4).has_max());
   EXPECT_EQ(12, histogram_proto.bucket(4).max());
 }
 
 TEST_F(MetricsLogTest, RecordEnvironment) {
   TestMetricsServiceClient client;
-  client.set_install_date(kInstallDate);
   TestMetricsLog log(
       kClientId, kSessionId, MetricsLog::ONGOING_LOG, &client, &prefs_);
 
   std::vector<variations::ActiveGroupId> synthetic_trials;
   // Add two synthetic trials.
   synthetic_trials.push_back(kSyntheticTrials[0]);
   synthetic_trials.push_back(kSyntheticTrials[1]);
 
   log.RecordEnvironment(std::vector<MetricsProvider*>(),
-                        synthetic_trials);
+                        synthetic_trials,
+                        kInstallDate);
   // Check that the system profile on the log has the correct values set.
   CheckSystemProfile(log.system_profile());
 
   // Check that the system profile has also been written to prefs.
   const std::string base64_system_profile =
       prefs_.GetString(prefs::kStabilitySavedSystemProfile);
   EXPECT_FALSE(base64_system_profile.empty());
   std::string serialied_system_profile;
   EXPECT_TRUE(base::Base64Decode(base64_system_profile,
                                  &serialied_system_profile));
   SystemProfileProto decoded_system_profile;
   EXPECT_TRUE(decoded_system_profile.ParseFromString(serialied_system_profile));
   CheckSystemProfile(decoded_system_profile);
 }
 
 TEST_F(MetricsLogTest, LoadSavedEnvironmentFromPrefs) {
   const char* kSystemProfilePref = prefs::kStabilitySavedSystemProfile;
   const char* kSystemProfileHashPref =
       prefs::kStabilitySavedSystemProfileHash;
 
   TestMetricsServiceClient client;
-  client.set_install_date(kInstallDate);
 
   // The pref value is empty, so loading it from prefs should fail.
   {
     TestMetricsLog log(
         kClientId, kSessionId, MetricsLog::ONGOING_LOG, &client, &prefs_);
     EXPECT_FALSE(log.LoadSavedEnvironmentFromPrefs());
   }
 
   // Do a RecordEnvironment() call and check whether the pref is recorded.
   {
     TestMetricsLog log(
         kClientId, kSessionId, MetricsLog::ONGOING_LOG, &client, &prefs_);
     log.RecordEnvironment(std::vector<MetricsProvider*>(),
-                          std::vector<variations::ActiveGroupId>());
+                          std::vector<variations::ActiveGroupId>(),
+                          kInstallDate);
     EXPECT_FALSE(prefs_.GetString(kSystemProfilePref).empty());
     EXPECT_FALSE(prefs_.GetString(kSystemProfileHashPref).empty());
   }
 
   {
     TestMetricsLog log(
         kClientId, kSessionId, MetricsLog::ONGOING_LOG, &client, &prefs_);
     EXPECT_TRUE(log.LoadSavedEnvironmentFromPrefs());
     // Check some values in the system profile.
     EXPECT_EQ(kInstallDateExpected, log.system_profile().install_date());
     EXPECT_EQ(kEnabledDateExpected, log.system_profile().uma_enabled_date());
     // Ensure that the call cleared the prefs.
     EXPECT_TRUE(prefs_.GetString(kSystemProfilePref).empty());
     EXPECT_TRUE(prefs_.GetString(kSystemProfileHashPref).empty());
   }
 
   // Ensure that a non-matching hash results in the pref being invalid.
   {
     TestMetricsLog log(
         kClientId, kSessionId, MetricsLog::ONGOING_LOG, &client, &prefs_);
     // Call RecordEnvironment() to record the pref again.
     log.RecordEnvironment(std::vector<MetricsProvider*>(),
-                          std::vector<variations::ActiveGroupId>());
+                          std::vector<variations::ActiveGroupId>(),
+                          kInstallDate);
   }
 
   {
     // Set the hash to a bad value.
     prefs_.SetString(kSystemProfileHashPref, "deadbeef");
     TestMetricsLog log(
         kClientId, kSessionId, MetricsLog::ONGOING_LOG, &client, &prefs_);
     EXPECT_FALSE(log.LoadSavedEnvironmentFromPrefs());
     // Ensure that the prefs are cleared, even if the call failed.
     EXPECT_TRUE(prefs_.GetString(kSystemProfilePref).empty());
     EXPECT_TRUE(prefs_.GetString(kSystemProfileHashPref).empty());
   }
 }
 
 TEST_F(MetricsLogTest, InitialLogStabilityMetrics) {
   TestMetricsServiceClient client;
   TestMetricsLog log(kClientId,
                      kSessionId,
                      MetricsLog::INITIAL_STABILITY_LOG,
                      &client,
                      &prefs_);
   std::vector<MetricsProvider*> metrics_providers;
   log.RecordEnvironment(metrics_providers,
-                        std::vector<variations::ActiveGroupId>());
+                        std::vector<variations::ActiveGroupId>(),
+                        kInstallDate);
   log.RecordStabilityMetrics(metrics_providers, base::TimeDelta(),
                              base::TimeDelta());
   const SystemProfileProto_Stability& stability =
       log.system_profile().stability();
   // Required metrics:
   EXPECT_TRUE(stability.has_launch_count());
   EXPECT_TRUE(stability.has_crash_count());
   // Initial log metrics:
   EXPECT_TRUE(stability.has_incomplete_shutdown_count());
   EXPECT_TRUE(stability.has_breakpad_registration_success_count());
   EXPECT_TRUE(stability.has_breakpad_registration_failure_count());
   EXPECT_TRUE(stability.has_debugger_present_count());
   EXPECT_TRUE(stability.has_debugger_not_present_count());
 }
 
 TEST_F(MetricsLogTest, OngoingLogStabilityMetrics) {
   TestMetricsServiceClient client;
   TestMetricsLog log(
       kClientId, kSessionId, MetricsLog::ONGOING_LOG, &client, &prefs_);
   std::vector<MetricsProvider*> metrics_providers;
   log.RecordEnvironment(metrics_providers,
-                        std::vector<variations::ActiveGroupId>());
+                        std::vector<variations::ActiveGroupId>(),
+                        kInstallDate);
   log.RecordStabilityMetrics(metrics_providers, base::TimeDelta(),
                              base::TimeDelta());
   const SystemProfileProto_Stability& stability =
       log.system_profile().stability();
   // Required metrics:
   EXPECT_TRUE(stability.has_launch_count());
   EXPECT_TRUE(stability.has_crash_count());
   // Initial log metrics:
   EXPECT_FALSE(stability.has_incomplete_shutdown_count());
   EXPECT_FALSE(stability.has_breakpad_registration_success_count());
   EXPECT_FALSE(stability.has_breakpad_registration_failure_count());
   EXPECT_FALSE(stability.has_debugger_present_count());
   EXPECT_FALSE(stability.has_debugger_not_present_count());
 }
 
 TEST_F(MetricsLogTest, ChromeChannelWrittenToProtobuf) {
   TestMetricsServiceClient client;
   TestMetricsLog log(
       "user@test.com", kSessionId, MetricsLog::ONGOING_LOG, &client, &prefs_);
   EXPECT_TRUE(log.uma_proto().system_profile().has_channel());
 }
 
 }  // namespace metrics