[UserClassifier] Inject a clock

components/ntp_snippets/user_classifier.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/ntp_snippets/user_classifier.h"
 
 #include <algorithm>
 #include <cfloat>
 #include <string>
 
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/time/clock.h"
 #include "components/ntp_snippets/features.h"
 #include "components/ntp_snippets/pref_names.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
 #include "components/variations/variations_associated_data.h"
 
 namespace ntp_snippets {
 
 namespace {
 
@@ skipping 151 matching lines @@
   // |metric_value| returns |estimate_hours|. Thus, solve |metric_value| in
   //   metric_value = 1 + e^{-discount_rate * estimate_hours} * metric_value,
   // i.e.
   //   metric_value * (1 - e^{-discount_rate * estimate_hours}) = 1,
   //   metric_value = 1 / (1 - e^{-discount_rate * estimate_hours}).
   return 1.0 / (1.0 - std::exp(-discount_rate_per_hour * estimate_hours));
 }
 
 }  // namespace
 
-UserClassifier::UserClassifier(PrefService* pref_service)
+UserClassifier::UserClassifier(PrefService* pref_service,
+                               std::unique_ptr<base::Clock> clock)
     : pref_service_(pref_service),
+      clock_(std::move(clock)),
       discount_rate_per_hour_(GetDiscountRatePerHour()),
       min_hours_(GetMinHours()),
       max_hours_(GetMaxHours()),
       active_consumer_clicks_at_least_once_per_hours_(
           variations::GetVariationParamByFeatureAsDouble(
               kArticleSuggestionsFeature,
               kActiveConsumerClicksAtLeastOncePerHoursParam,
               kActiveConsumerClicksAtLeastOncePerHours)),
       rare_user_opens_ntp_at_most_once_per_hours_(
           variations::GetVariationParamByFeatureAsDouble(
@@ skipping 150 matching lines @@
   return DiscountMetric(metric_value, hours_since_last_time,
                         discount_rate_per_hour_);
 }
 
 double UserClassifier::GetHoursSinceLastTime(Metric metric) const {
   if (!HasLastTime(metric)) {
     return 0;
   }
 
   base::TimeDelta since_last_time =
-      base::Time::Now() - base::Time::FromInternalValue(pref_service_->GetInt64(
-                              kLastTimeKeys[static_cast<int>(metric)]));
+      clock_->Now() - base::Time::FromInternalValue(pref_service_->GetInt64(
+                          kLastTimeKeys[static_cast<int>(metric)]));
   return since_last_time.InSecondsF() / 3600;
 }
 
 bool UserClassifier::HasLastTime(Metric metric) const {
   return pref_service_->HasPrefPath(kLastTimeKeys[static_cast<int>(metric)]);
 }
 
 void UserClassifier::SetLastTimeToNow(Metric metric) {
   pref_service_->SetInt64(kLastTimeKeys[static_cast<int>(metric)],
-                          base::Time::Now().ToInternalValue());
+                          clock_->Now().ToInternalValue());
 }
 
 double UserClassifier::GetMetricValue(Metric metric) const {
   return pref_service_->GetDouble(kMetricKeys[static_cast<int>(metric)]);
 }
 
 void UserClassifier::SetMetricValue(Metric metric, double metric_value) {
   pref_service_->SetDouble(kMetricKeys[static_cast<int>(metric)], metric_value);
 }
 
 void UserClassifier::ClearMetricValue(Metric metric) {
   pref_service_->ClearPref(kMetricKeys[static_cast<int>(metric)]);
 }
 
 }  // namespace ntp_snippets