Merge "[UserClassifier] Fix the classification for M58 condensed NTP..."

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>
 
@@ skipping 23 matching lines @@
 const double kMaxHours = 7 * 24;
 const char kMaxHoursParam[] = "user_classifier_max_hours";
 
 // Ignore events within |kMinHours| hours since the last event (|kMinHours| is
 // the length of the browsing session where subsequent events of the same type
 // do not count again).
 const double kMinHours = 0.5;
 const char kMinHoursParam[] = "user_classifier_min_hours";
 
 // Classification constants.
-const double kActiveConsumerScrollsAtLeastOncePerHours = 24;
-const char kActiveConsumerScrollsAtLeastOncePerHoursParam[] =
-    "user_classifier_active_consumer_scrolls_at_least_once_per_hours";
+const double kActiveConsumerClicksAtLeastOncePerHours = 72;
+const char kActiveConsumerClicksAtLeastOncePerHoursParam[] =
+    "user_classifier_active_consumer_clicks_at_least_once_per_hours";
 
-const double kRareUserOpensNTPAtMostOncePerHours = 72;
+const double kRareUserOpensNTPAtMostOncePerHours = 96;
 const char kRareUserOpensNTPAtMostOncePerHoursParam[] =
     "user_classifier_rare_user_opens_ntp_at_most_once_per_hours";
 
 // Histograms for logging the estimated average hours to next event.
 const char kHistogramAverageHoursToOpenNTP[] =
     "NewTabPage.UserClassifier.AverageHoursToOpenNTP";
 const char kHistogramAverageHoursToShowSuggestions[] =
     "NewTabPage.UserClassifier.AverageHoursToShowSuggestions";
 const char kHistogramAverageHoursToUseSuggestions[] =
     "NewTabPage.UserClassifier.AverageHoursToUseSuggestions";
 
 // The enum used for iteration.
 const UserClassifier::Metric kMetrics[] = {
     UserClassifier::Metric::NTP_OPENED,
     UserClassifier::Metric::SUGGESTIONS_SHOWN,
     UserClassifier::Metric::SUGGESTIONS_USED};
 
 // The summary of the prefs.
 const char* kMetricKeys[] = {
     prefs::kUserClassifierAverageNTPOpenedPerHour,
     prefs::kUserClassifierAverageSuggestionsShownPerHour,
     prefs::kUserClassifierAverageSuggestionsUsedPerHour};
 const char* kLastTimeKeys[] = {prefs::kUserClassifierLastTimeToOpenNTP,
                                prefs::kUserClassifierLastTimeToShowSuggestions,
                                prefs::kUserClassifierLastTimeToUseSuggestions};
 
 // Default lengths of the intervals for new users for the metrics.
-const double kInitialHoursBetweenEvents[] = {24, 36, 48};
+const double kInitialHoursBetweenEvents[] = {24, 48, 96};
 const char* kInitialHoursBetweenEventsParams[] = {
     "user_classifier_default_interval_ntp_opened",
     "user_classifier_default_interval_suggestions_shown",
     "user_classifier_default_interval_suggestions_used"};
 
 static_assert(arraysize(kMetrics) ==
                       static_cast<int>(UserClassifier::Metric::COUNT) &&
                   arraysize(kMetricKeys) ==
                       static_cast<int>(UserClassifier::Metric::COUNT) &&
                   arraysize(kLastTimeKeys) ==
@@ skipping 92 matching lines @@
   return 1.0 / (1.0 - std::exp(-discount_rate_per_hour * estimate_hours));
 }
 
 }  // namespace
 
 UserClassifier::UserClassifier(PrefService* pref_service)
     : pref_service_(pref_service),
       discount_rate_per_hour_(GetDiscountRatePerHour()),
       min_hours_(GetMinHours()),
       max_hours_(GetMaxHours()),
-      active_consumer_scrolls_at_least_once_per_hours_(
+      active_consumer_clicks_at_least_once_per_hours_(
           variations::GetVariationParamByFeatureAsDouble(
               kArticleSuggestionsFeature,
-              kActiveConsumerScrollsAtLeastOncePerHoursParam,
-              kActiveConsumerScrollsAtLeastOncePerHours)),
+              kActiveConsumerClicksAtLeastOncePerHoursParam,
+              kActiveConsumerClicksAtLeastOncePerHours)),
       rare_user_opens_ntp_at_most_once_per_hours_(
           variations::GetVariationParamByFeatureAsDouble(
               kArticleSuggestionsFeature,
               kRareUserOpensNTPAtMostOncePerHoursParam,
               kRareUserOpensNTPAtMostOncePerHours)) {
   // The pref_service_ can be null in tests.
   if (!pref_service_) {
     return;
   }
 
@@ skipping 65 matching lines @@
   // The pref_service_ can be null in tests.
   if (!pref_service_) {
     return UserClass::ACTIVE_NTP_USER;
   }
 
   if (GetEstimatedAvgTime(Metric::NTP_OPENED) >=
       rare_user_opens_ntp_at_most_once_per_hours_) {
     return UserClass::RARE_NTP_USER;
   }
 
-  if (GetEstimatedAvgTime(Metric::SUGGESTIONS_SHOWN) <=
-      active_consumer_scrolls_at_least_once_per_hours_) {
+  if (GetEstimatedAvgTime(Metric::SUGGESTIONS_USED) <=
+      active_consumer_clicks_at_least_once_per_hours_) {
     return UserClass::ACTIVE_SUGGESTIONS_CONSUMER;
   }
 
   return UserClass::ACTIVE_NTP_USER;
 }
 
 std::string UserClassifier::GetUserClassDescriptionForDebugging() const {
   switch (GetUserClass()) {
     case UserClass::RARE_NTP_USER:
       return "Rare user of the NTP";
@@ skipping 82 matching lines @@
 
 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