Fix the computation of the usage metric in UserClassifier.

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 <float.h>
 
 #include <algorithm>
 #include <string>
@@ skipping 97 matching lines @@
   // Ignore events within the same "browsing session".
   if (hours_since_last_time < kMinHours)
     return;
   SetLastTimeToNow(last_time_pref_name);
 
   double avg_events_per_hour = pref_service_->GetDouble(metric_pref_name);
   // Compute and store the new discounted average according to the formula
   //   avg_events := 1 + e^{-discount_rate_per_hour * hours_since} * avg_events.
   double new_avg_events_per_hour =
       1 +
-      std::exp(discount_rate_per_hour_ * hours_since_last_time) *
+      std::exp(-discount_rate_per_hour_ * hours_since_last_time) *
           avg_events_per_hour;
   pref_service_->SetDouble(metric_pref_name, new_avg_events_per_hour);
 }
 
 double UserClassifier::GetEstimateHoursBetweenEvents(
     const char* metric_pref_name) {
   double avg_events_per_hour = pref_service_->GetDouble(metric_pref_name);
 
   // Right after the first update, the metric is equal to 1.
   if (avg_events_per_hour <= 1)
     return kMaxHours;
 
   // This is the estimate with the assumption that last event happened right
   // now and the system is in the steady-state. Solve estimate_hours in the
   // steady-state equation:
-  //   avg_events = 1 + e^{-discount_rate * estimate_hours} * avg_events.
+  //   avg_events = 1 + e^{-discount_rate * estimate_hours} * avg_events,
+  // i.e.
+  //   -discount_rate * estimate_hours = log((avg_events - 1) / avg_events),
+  //   discount_rate * estimate_hours = log(avg_events / (avg_events - 1)),
+  //   estimate_hours = log(avg_events / (avg_events - 1)) / discount_rate.
   return std::min(kMaxHours,
                   std::log(avg_events_per_hour / (avg_events_per_hour - 1)) /
                       discount_rate_per_hour_);
 }
 
 double UserClassifier::GetHoursSinceLastTime(
     const char* last_time_pref_name) {
   if (!pref_service_->HasPrefPath(last_time_pref_name))
     return DBL_MAX;
 
   base::TimeDelta since_last_time =
       base::Time::Now() - base::Time::FromInternalValue(
                               pref_service_->GetInt64(last_time_pref_name));
   return since_last_time.InSecondsF() / 3600;
 }
 
 void UserClassifier::SetLastTimeToNow(const char* last_time_pref_name) {
   pref_service_->SetInt64(last_time_pref_name,
                           base::Time::Now().ToInternalValue());
 }
 
 }  // namespace ntp_snippets