RemoteContentSuggestions: Stores the time of the last successful background fetch in a pref

components/ntp_snippets/remote/remote_suggestions_provider.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/remote_suggestions_provider.h"
 
 #include <algorithm>
 #include <iterator>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/feature_list.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.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/default_tick_clock.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/features.h"
 #include "components/ntp_snippets/pref_names.h"
 #include "components/ntp_snippets/remote/remote_suggestions_database.h"
 #include "components/ntp_snippets/switches.h"
@@ skipping 210 matching lines @@
       scheduler_(scheduler),
       snippets_fetcher_(std::move(snippets_fetcher)),
       image_fetcher_(std::move(image_fetcher)),
       image_decoder_(std::move(image_decoder)),
       database_(std::move(database)),
       status_service_(std::move(status_service)),
       fetch_when_ready_(false),
       nuke_when_initialized_(false),
       thumbnail_requests_throttler_(
           pref_service,
-          RequestThrottler::RequestType::CONTENT_SUGGESTION_THUMBNAIL) {
+          RequestThrottler::RequestType::CONTENT_SUGGESTION_THUMBNAIL),
+      tick_clock_(new base::DefaultTickClock()) {

[Marc Treib, 2016/12/07 14:42:13]

nit: base::MakeUnique<base::DefaultTickClock>()
(to make clear that no raw pointer is involved)

[markusheintz_, 2016/12/08 09:47:41]

Done.

   pref_service_->ClearPref(kDeprecatedSnippetHostsPref);
 
   RestoreCategoriesFromPrefs();
   // The articles category always exists. Add it if we didn't get it from prefs.
   // TODO(treib): Rethink this.
   category_contents_.insert(
       std::make_pair(articles_category_,
                      CategoryContent(BuildArticleCategoryInfo(base::nullopt))));
   // Tell the observer about all the categories.
   for (const auto& entry : category_contents_) {
@@ skipping 20 matching lines @@
 
 // static
 void RemoteSuggestionsProvider::RegisterProfilePrefs(
     PrefRegistrySimple* registry) {
   // TODO(treib): Remove after M57.
   registry->RegisterListPref(kDeprecatedSnippetHostsPref);
   registry->RegisterListPref(prefs::kRemoteSuggestionCategories);
   registry->RegisterInt64Pref(prefs::kSnippetBackgroundFetchingIntervalWifi, 0);
   registry->RegisterInt64Pref(prefs::kSnippetBackgroundFetchingIntervalFallback,
                               0);
+  registry->RegisterInt64Pref(prefs::kLastSuccessfullBackgroundFetchTime, 0);
 
   RemoteSuggestionsStatusService::RegisterProfilePrefs(registry);
 }
 
 void RemoteSuggestionsProvider::FetchSnippetsInTheBackground() {
   FetchSnippets(/*interactive_request=*/false);
 }
 
 void RemoteSuggestionsProvider::FetchSnippetsForAllCategories() {
   // TODO(markusheintz): Investigate whether we can call the Fetch method
@@ skipping 21 matching lines @@
   if (!ready()) {
     return;
   }
   MarkEmptyCategoriesAsLoading();
 
   NTPSnippetsFetcher::Params params = BuildFetchParams();
   params.hosts = hosts;
   params.interactive_request = interactive_request;
   snippets_fetcher_->FetchSnippets(
       params, base::BindOnce(&RemoteSuggestionsProvider::OnFetchFinished,
-                             base::Unretained(this)));
+                             base::Unretained(this), interactive_request));
 }
 
 void RemoteSuggestionsProvider::Fetch(
     const Category& category,
     const std::set<std::string>& known_suggestion_ids,
     const FetchDoneCallback& callback) {
   if (!ready()) {
     CallWithEmptyResults(callback,
                          Status(StatusCode::TEMPORARY_ERROR,
                                 "RemoteSuggestionsProvider is not ready!"));
@@ skipping 289 matching lines @@
   FinishInitialization();
 }
 
 void RemoteSuggestionsProvider::OnDatabaseError() {
   EnterState(State::ERROR_OCCURRED);
   UpdateAllCategoryStatus(CategoryStatus::LOADING_ERROR);
 }
 
 void RemoteSuggestionsProvider::OnFetchMoreFinished(
     const FetchDoneCallback& fetching_callback,
-    NTPSnippetsFetcher::OptionalFetchedCategories fetched_categories) {
+    NTPSnippetsFetcher::OptionalFetchedCategories fetched_categories,
+    NTPSnippetsFetcher::FetchResult fetch_result) {
   if (!fetched_categories) {
     // TODO(fhorschig): Disambiguate the kind of error that led here.
     CallWithEmptyResults(fetching_callback,
                          Status(StatusCode::PERMANENT_ERROR,
                                 "The NTPSnippetsFetcher did not "
                                 "complete the fetching successfully."));
     return;
   }
   if (fetched_categories->size() != 1u) {
     LOG(DFATAL) << "Requested one exclusive category but received "
@@ skipping 40 matching lines @@
   // once the snippets fetcher supports concurrent requests. We can then see if
   // Nuke should also cancel outstanding requests or we want to check the
   // status.
   UpdateCategoryStatus(category, CategoryStatus::AVAILABLE);
   // Notify callers and observers.
   fetching_callback.Run(Status(StatusCode::SUCCESS), std::move(result));
   NotifyNewSuggestions(category, *existing_content);
 }
 
 void RemoteSuggestionsProvider::OnFetchFinished(
-    NTPSnippetsFetcher::OptionalFetchedCategories fetched_categories) {
+    bool interactive_request,
+    NTPSnippetsFetcher::OptionalFetchedCategories fetched_categories,
+    NTPSnippetsFetcher::FetchResult fetch_result) {
   if (!ready()) {
     // TODO(tschumann): What happens if this was a user-triggered, interactive
     // request? Is the UI waiting indefinitely now?
     return;
   }
 
+  // Record the fetch time of a successfull background fetch.
+  if (!interactive_request &&
+      fetch_result == NTPSnippetsFetcher::FetchResult::SUCCESS) {
+    pref_service_->SetInt64(prefs::kLastSuccessfullBackgroundFetchTime,
+                            tick_clock_->NowTicks().ToInternalValue());
+  }
+
   // Mark all categories as not provided by the server in the latest fetch. The
   // ones we got will be marked again below.
   for (auto& item : category_contents_) {
     CategoryContent* content = &item.second;
     content->included_in_last_server_response = false;
   }
 
   // Clear up expired dismissed snippets before we use them to filter new ones.
   ClearExpiredDismissedSnippets();
 
@@ skipping 610 matching lines @@
 RemoteSuggestionsProvider::CategoryContent::CategoryContent(CategoryContent&&) =
     default;
 
 RemoteSuggestionsProvider::CategoryContent::~CategoryContent() = default;
 
 RemoteSuggestionsProvider::CategoryContent&
 RemoteSuggestionsProvider::CategoryContent::operator=(CategoryContent&&) =
     default;
 
 }  // namespace ntp_snippets