[NTP Snippets] Hook up background fetching scheduler to UserClassifier

components/ntp_snippets/remote/ntp_snippets_service.cc

 // Copyright 2015 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/remote/ntp_snippets_service.h"
 
 #include <algorithm>
 #include <iterator>
 #include <utility>
 
 #include "base/command_line.h"
-#include "base/files/file_path.h"
-#include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/path_service.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task_runner_util.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "components/data_use_measurement/core/data_use_user_data.h"
 #include "components/history/core/browser/history_service.h"
 #include "components/image_fetcher/image_decoder.h"
 #include "components/image_fetcher/image_fetcher.h"
-#include "components/ntp_snippets/ntp_snippets_constants.h"
+#include "components/ntp_snippets/features.h"
 #include "components/ntp_snippets/pref_names.h"
 #include "components/ntp_snippets/remote/ntp_snippets_database.h"
 #include "components/ntp_snippets/switches.h"
+#include "components/ntp_snippets/user_classifier.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
 #include "components/suggestions/proto/suggestions.pb.h"
 #include "components/variations/variations_associated_data.h"
 #include "grit/components_strings.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/image/image.h"
 
 using image_fetcher::ImageDecoder;
 using image_fetcher::ImageFetcher;
 using suggestions::ChromeSuggestion;
 using suggestions::SuggestionsProfile;
 using suggestions::SuggestionsService;
 
 namespace ntp_snippets {
 
 namespace {
 
 // Number of snippets requested to the server. Consider replacing sparse UMA
 // histograms with COUNTS() if this number increases beyond 50.
 const int kMaxSnippetCount = 10;
 
 // Number of archived snippets we keep around in memory.
 const int kMaxArchivedSnippetCount = 200;
 
-// Default values for snippets fetching intervals - once per day only.
-const int kDefaultFetchingIntervalWifiSeconds = 0;
-const int kDefaultFetchingIntervalFallbackSeconds = 24 * 60 * 60;
+// Default values for fetching intervals, fallback and wifi.
+const double kDefaultFetchingIntervalRareNtpUser[] = {48.0, 24.0};
+const double kDefaultFetchingIntervalActiveNtpUser[] = {24.0, 6.0};
+const double kDefaultFetchingIntervalActiveSuggestionsConsumer[] = {24.0, 6.0};
 
 // Variation parameters than can override the default fetching intervals.
-const char kFetchingIntervalWifiParamName[] =
-    "fetching_interval_wifi_seconds";
-const char kFetchingIntervalFallbackParamName[] =
-    "fetching_interval_fallback_seconds";
+const char* kFetchingIntervalParamNameRareNtpUser[] = {
+    "fetching_interval_hours-fallback-rare_ntp_user",
+    "fetching_interval_hours-wifi-rare_ntp_user"};
+const char* kFetchingIntervalParamNameActiveNtpUser[] = {
+    "fetching_interval_hours-fallback-active_ntp_user",
+    "fetching_interval_hours-wifi-active_ntp_user"};
+const char* kFetchingIntervalParamNameActiveSuggestionsConsumer[] = {
+    "fetching_interval_hours-fallback-active_suggestions_consumer",
+    "fetching_interval_hours-wifi-active_suggestions_consumer"};
 
 const int kDefaultExpiryTimeMins = 3 * 24 * 60;
 
-base::TimeDelta GetFetchingInterval(const char* switch_name,
-                                    const char* param_name,
-                                    int default_value_seconds) {
-  int value_seconds = default_value_seconds;
+base::TimeDelta GetFetchingInterval(bool is_wifi,
+                                    UserClassifier::UserClass user_class) {
+  double value_hours = 0.0;
+
+  const int index = is_wifi ? 1 : 0;
+  const char* param_name = "";
+  switch (user_class) {
+    case UserClassifier::UserClass::RARE_NTP_USER:
+      value_hours = kDefaultFetchingIntervalRareNtpUser[index];
+      param_name = kFetchingIntervalParamNameRareNtpUser[index];
+      break;
+    case UserClassifier::UserClass::ACTIVE_NTP_USER:
+      value_hours = kDefaultFetchingIntervalActiveNtpUser[index];
+      param_name = kFetchingIntervalParamNameActiveNtpUser[index];
+      break;
+    case UserClassifier::UserClass::ACTIVE_SUGGESTIONS_CONSUMER:
+      value_hours = kDefaultFetchingIntervalActiveSuggestionsConsumer[index];
+      param_name = kFetchingIntervalParamNameActiveSuggestionsConsumer[index];
+      break;
+  }
 
   // The default value can be overridden by a variation parameter.
-  // TODO(treib,jkrcal): Use GetVariationParamValueByFeature and get rid of
-  // kStudyName, also in NTPSnippetsFetcher.
-  std::string param_value_str = variations::GetVariationParamValue(
-        ntp_snippets::kStudyName, param_name);
+  std::string param_value_str = variations::GetVariationParamValueByFeature(
+        ntp_snippets::kArticleSuggestionsFeature, param_name);
   if (!param_value_str.empty()) {
-    int param_value_seconds = 0;
-    if (base::StringToInt(param_value_str, &param_value_seconds))
-      value_seconds = param_value_seconds;
+    double param_value_hours = 0.0;
+    if (base::StringToDouble(param_value_str, &param_value_hours))
+      value_hours = param_value_hours;
     else
       LOG(WARNING) << "Invalid value for variation parameter " << param_name;
   }
 
-  // A value from the command line parameter overrides anything else.
-  const base::CommandLine& cmdline = *base::CommandLine::ForCurrentProcess();
-  if (cmdline.HasSwitch(switch_name)) {
-    std::string str = cmdline.GetSwitchValueASCII(switch_name);
-    int switch_value_seconds = 0;
-    if (base::StringToInt(str, &switch_value_seconds))
-      value_seconds = switch_value_seconds;
-    else
-      LOG(WARNING) << "Invalid value for switch " << switch_name;
-  }
-  return base::TimeDelta::FromSeconds(value_seconds);
-}
-
-base::TimeDelta GetFetchingIntervalWifi() {
-  return GetFetchingInterval(switches::kFetchingIntervalWifiSeconds,
-                             kFetchingIntervalWifiParamName,
-                             kDefaultFetchingIntervalWifiSeconds);
-}
-
-base::TimeDelta GetFetchingIntervalFallback() {
-  return GetFetchingInterval(switches::kFetchingIntervalFallbackSeconds,
-                             kFetchingIntervalFallbackParamName,
-                             kDefaultFetchingIntervalFallbackSeconds);
+  return base::TimeDelta::FromSecondsD(value_hours * 3600.0);
 }
 
 // Extracts the hosts from |suggestions| and returns them in a set.
 std::set<std::string> GetSuggestionsHostsImpl(
     const SuggestionsProfile& suggestions) {
   std::set<std::string> hosts;
   for (int i = 0; i < suggestions.suggestions_size(); ++i) {
     const ChromeSuggestion& suggestion = suggestions.suggestions(i);
     GURL url(suggestion.url());
     if (url.is_valid())
@@ skipping 55 matching lines @@
 }
 
 }  // namespace
 
 NTPSnippetsService::NTPSnippetsService(
     Observer* observer,
     CategoryFactory* category_factory,
     PrefService* pref_service,
     SuggestionsService* suggestions_service,
     const std::string& application_language_code,
+    const UserClassifier* user_classifier,
     NTPSnippetsScheduler* scheduler,
     std::unique_ptr<NTPSnippetsFetcher> snippets_fetcher,
     std::unique_ptr<ImageFetcher> image_fetcher,
     std::unique_ptr<ImageDecoder> image_decoder,
     std::unique_ptr<NTPSnippetsDatabase> database,
     std::unique_ptr<NTPSnippetsStatusService> status_service)
     : ContentSuggestionsProvider(observer, category_factory),
       state_(State::NOT_INITED),
       pref_service_(pref_service),
       suggestions_service_(suggestions_service),
       articles_category_(
           category_factory->FromKnownCategory(KnownCategories::ARTICLES)),
       application_language_code_(application_language_code),
+      user_classifier_(user_classifier),
       scheduler_(scheduler),
       snippets_fetcher_(std::move(snippets_fetcher)),
       image_fetcher_(std::move(image_fetcher)),
       image_decoder_(std::move(image_decoder)),
       database_(std::move(database)),
       snippets_status_service_(std::move(status_service)),
       fetch_when_ready_(false),
       nuke_when_initialized_(false),
       thumbnail_requests_throttler_(
           pref_service,
@@ skipping 68 matching lines @@
   if (!scheduler_)
     return;
 
   if (ready()) {
     base::TimeDelta old_interval_wifi =
         base::TimeDelta::FromInternalValue(pref_service_->GetInt64(
             prefs::kSnippetBackgroundFetchingIntervalWifi));
     base::TimeDelta old_interval_fallback =
         base::TimeDelta::FromInternalValue(pref_service_->GetInt64(
             prefs::kSnippetBackgroundFetchingIntervalFallback));
-    base::TimeDelta interval_wifi = GetFetchingIntervalWifi();
-    base::TimeDelta interval_fallback = GetFetchingIntervalFallback();
+    UserClassifier::UserClass user_class = user_classifier_->GetUserClass();
+    base::TimeDelta interval_wifi =
+        GetFetchingInterval(/*is_wifi=*/true, user_class);
+    base::TimeDelta interval_fallback =
+        GetFetchingInterval(/*is_wifi=*/false, user_class);
     if (force || interval_wifi != old_interval_wifi ||
         interval_fallback != old_interval_fallback) {
       scheduler_->Schedule(interval_wifi, interval_fallback);
       pref_service_->SetInt64(prefs::kSnippetBackgroundFetchingIntervalWifi,
                               interval_wifi.ToInternalValue());
       pref_service_->SetInt64(
           prefs::kSnippetBackgroundFetchingIntervalFallback,
           interval_fallback.ToInternalValue());
     }
   } else {
-    // If we're NOT_INITED, we don't know whether to schedule or un-schedule.
+    // If we're NOT_INITED, we don't know whether to schedule or unschedule.
     // If |force| is false, all is well: We'll reschedule on the next state
     // change anyway. If it's true, then unschedule here, to make sure that the
     // next reschedule actually happens.
     if (state_ != State::NOT_INITED || force) {
       scheduler_->Unschedule();
       pref_service_->ClearPref(prefs::kSnippetBackgroundFetchingIntervalWifi);
       pref_service_->ClearPref(
           prefs::kSnippetBackgroundFetchingIntervalFallback);
     }
   }
@@ skipping 352 matching lines @@
 
   // Fill in default publish/expiry dates where required.
   for (std::unique_ptr<NTPSnippet>& snippet : new_snippets) {
     if (snippet->publish_date().is_null())
       snippet->set_publish_date(base::Time::Now());
     if (snippet->expiry_date().is_null()) {
       snippet->set_expiry_date(
           snippet->publish_date() +
           base::TimeDelta::FromMinutes(kDefaultExpiryTimeMins));
     }
-
-    // TODO(treib): Prefetch and cache the snippet image. crbug.com/605870
   }
 
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kAddIncompleteSnippets)) {
     int num_new_snippets = new_snippets.size();
     // Remove snippets that do not have all the info we need to display it to
     // the user.
     new_snippets.erase(
         std::remove_if(new_snippets.begin(), new_snippets.end(),
                        [](const std::unique_ptr<NTPSnippet>& snippet) {
@@ skipping 379 matching lines @@
 }
 
 NTPSnippetsService::CategoryContent::CategoryContent() = default;
 NTPSnippetsService::CategoryContent::CategoryContent(CategoryContent&&) =
     default;
 NTPSnippetsService::CategoryContent::~CategoryContent() = default;
 NTPSnippetsService::CategoryContent& NTPSnippetsService::CategoryContent::
 operator=(CategoryContent&&) = default;
 
 }  // namespace ntp_snippets