[NTP Snippets] Refactor background scheduling for remote suggestions

components/ntp_snippets/content_suggestions_service.h

 // 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.
 
 #ifndef COMPONENTS_NTP_SNIPPETS_CONTENT_SUGGESTIONS_SERVICE_H_
 #define COMPONENTS_NTP_SNIPPETS_CONTENT_SUGGESTIONS_SERVICE_H_
 
 #include <map>
 #include <memory>
 #include <set>
@@ skipping 15 matching lines @@
 #include "components/ntp_snippets/content_suggestions_provider.h"
 #include "components/ntp_snippets/user_classifier.h"
 #include "components/signin/core/browser/signin_manager.h"
 
 class PrefService;
 class PrefRegistrySimple;
 
 namespace ntp_snippets {
 
 class RemoteSuggestionsProvider;
+class RemoteSuggestionsScheduler;
 
 // Retrieves suggestions from a number of ContentSuggestionsProviders and serves
 // them grouped into categories. There can be at most one provider per category.
 class ContentSuggestionsService : public KeyedService,
                                   public ContentSuggestionsProvider::Observer,
                                   public SigninManagerBase::Observer,
                                   public history::HistoryServiceObserver {
  public:
   class Observer {
    public:
@@ skipping 89 matching lines @@
   // Restores all dismissed categories.
   // This will not trigger an update through the observers.
   void RestoreDismissedCategories();
 
   // Returns whether |category| is dismissed.
   bool IsCategoryDismissed(Category category) const;
 
   // Fetches additional contents for the given |category|. If the fetch was
   // completed, the given |callback| is called with the updated content.
   // This includes new and old data.
+  // TODO(jkrcal): Consider either renaming this to FetchMore or unify the ways
+  // to get suggestions to just this async Fetch() API.
   void Fetch(const Category& category,
              const std::set<std::string>& known_suggestion_ids,
              const FetchDoneCallback& callback);
 
+  // Reloads suggestions from all categories, from all providers. If a provider
+  // naturally has some ability to generate fresh suggestions, it may provide a
+  // completely new set of suggestions. If the provider has no ability to
+  // generate fresh suggestions on demand, it may only fill in any vacant space
+  // by suggestions that were previously not included due to space limits (there
+  // may be vacant space because of the user dismissing suggestions in the
+  // meantime).
+  void ReloadSuggestions();
+
   // Observer accessors.
   void AddObserver(Observer* observer);
   void RemoveObserver(Observer* observer);
 
   // Registers a new ContentSuggestionsProvider. It must be ensured that at most
   // one provider is registered for every category and that this method is
   // called only once per provider.
   void RegisterProvider(std::unique_ptr<ContentSuggestionsProvider> provider);
 
   // Removes history from the specified time range where the URL matches the
@@ skipping 27 matching lines @@
       Category category,
       const DismissedSuggestionsCallback& callback);
 
   // Only for debugging use through the internals page. Some providers
   // internally store a list of dismissed suggestions to prevent them from
   // reappearing. This function clears all suggestions of the given |category|
   // from such lists, making dismissed suggestions reappear (if the provider
   // supports it).
   void ClearDismissedSuggestionsForDebugging(Category category);
 
-  // The reference to the RemoteSuggestionsProvider provider should only be set
-  // by the factory and only be used for scheduling, periodic fetching and
-  // debugging.
-  RemoteSuggestionsProvider* ntp_snippets_service() {
-    return ntp_snippets_service_;
+  // The reference to the RemoteSuggestionsProvider provider should
+  // only be set by the factory and only used for debugging.
+  // TODO(jkrcal) The way we deal with the circular dependency feels wrong to
+  // Tim. Consider swapping the dependencies: first constructing all providers,
+  // then constructing the service (passing the remote provider as arg), finally
+  // registering the service as an observer of all providers?
+  void set_remote_suggestions_provider(
+      RemoteSuggestionsProvider* remote_suggestions_provider) {
+    remote_suggestions_provider_ = remote_suggestions_provider;
   }
-  void set_ntp_snippets_service(
-      RemoteSuggestionsProvider* ntp_snippets_service) {
-    ntp_snippets_service_ = ntp_snippets_service;
+  RemoteSuggestionsProvider* remote_suggestions_provider_for_debugging() {
+    return remote_suggestions_provider_;
+  }
+
+  // The reference to RemoteSuggestionsScheduler should only be set by the
+  // factory. The interface is suited for informing about external events that
+  // have influence on scheduling remote fetches.
+  void set_remote_suggestions_scheduler(
+      ntp_snippets::RemoteSuggestionsScheduler* remote_suggestions_scheduler) {
+    remote_suggestions_scheduler_ = remote_suggestions_scheduler;
+  }
+  RemoteSuggestionsScheduler* remote_suggestions_scheduler() {
+    return remote_suggestions_scheduler_;
   }
 
   UserClassifier* user_classifier() { return &user_classifier_; }
   CategoryRanker* category_ranker() { return category_ranker_.get(); }
 
  private:
   friend class ContentSuggestionsServiceTest;
 
   // Implementation of ContentSuggestionsProvider::Observer.
   void OnNewSuggestions(ContentSuggestionsProvider* provider,
@@ skipping 88 matching lines @@
 
   // Observer for the HistoryService. All providers are notified when history is
   // deleted.
   ScopedObserver<history::HistoryService, history::HistoryServiceObserver>
       history_service_observer_;
 
   base::ObserverList<Observer> observers_;
 
   const std::vector<ContentSuggestion> no_suggestions_;
 
-  // Keep a direct reference to this special provider to redirect scheduling,
-  // background fetching and debugging calls to it. If the
-  // RemoteSuggestionsProvider is loaded, it is also present in |providers_|,
-  // otherwise this is a nullptr.
-  RemoteSuggestionsProvider* ntp_snippets_service_;
+  // Keep a direct reference to this special provider to redirect debugging
+  // calls to it. If the RemoteSuggestionsProvider is loaded, it is also present
+  // in |providers_|, otherwise this is a nullptr.
+  RemoteSuggestionsProvider* remote_suggestions_provider_;
+
+  // Interface for informing about external events that have influence on
+  // scheduling remote fetches. Not owned.
+  RemoteSuggestionsScheduler* remote_suggestions_scheduler_;
 
   PrefService* pref_service_;
 
   UserClassifier user_classifier_;
 
   // Provides order for categories.
   std::unique_ptr<CategoryRanker> category_ranker_;
 
   DISALLOW_COPY_AND_ASSIGN(ContentSuggestionsService);
 };
 
 }  // namespace ntp_snippets
 
 #endif  // COMPONENTS_NTP_SNIPPETS_CONTENT_SUGGESTIONS_SERVICE_H_