[Remote suggestions] Move all decisions to fetch to the scheduler

components/ntp_snippets/remote/scheduling_remote_suggestions_provider.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_REMOTE_SCHEDULING_REMOTE_SUGGESTIONS_PROVIDER_H_
 #define COMPONENTS_NTP_SNIPPETS_REMOTE_SCHEDULING_REMOTE_SUGGESTIONS_PROVIDER_H_
 
 #include <memory>
 #include <set>
 #include <string>
@@ skipping 33 matching lines @@
 // TODO(jkrcal): Clarify what Fetch() should do for this provider and maybe stop
 // intercepting it.
 // TODO(jkrcal): Intercept also ReloadSuggestions() call (after the user swipes
 // away everything incl. all empty sections and presses "More"); Not done in the
 // first shot because  it implements a public interface function without any
 // callback.
 // This class is final because it does things in its constructor which make it
 // unsafe to derive from it.
 // TODO(jkrcal): Introduce two-phase initialization and make the class not
 // final? (see the same comment for RemoteSuggestionsProvider)
+// TODO(jkrcal): Change the interface to ContentSuggestionsProvider. We do not
+// need any special functionality, all special should be exposed in the
+// Scheduler interface. crbug.com/695447
 class SchedulingRemoteSuggestionsProvider final
     : public RemoteSuggestionsProvider,
       public RemoteSuggestionsScheduler {
  public:
   SchedulingRemoteSuggestionsProvider(
       Observer* observer,
       std::unique_ptr<RemoteSuggestionsProvider> provider,
       PersistentScheduler* persistent_scheduler,
       const UserClassifier* user_classifier,
       PrefService* pref_service,
       std::unique_ptr<base::Clock> clock);
 
   ~SchedulingRemoteSuggestionsProvider() override;
 
   static void RegisterProfilePrefs(PrefRegistrySimple* registry);
 
   // RemoteSuggestionsScheduler implementation.
+  void OnProviderActivated() override;
+  void OnProviderDeactivated() override;
+  void OnSuggestionsCleared() override;
+  void OnHistoryCleared() override;
   void RescheduleFetching() override;
   void OnPersistentSchedulerWakeUp() override;
   void OnBrowserForegrounded() override;
   void OnBrowserColdStart() override;
   void OnNTPOpened() override;
 
   // RemoteSuggestionsProvider implementation.
-  void SetProviderStatusCallback(
-      std::unique_ptr<ProviderStatusCallback> callback) override;
   void RefetchInTheBackground(
       std::unique_ptr<FetchStatusCallback> callback) override;
   const RemoteSuggestionsFetcher* suggestions_fetcher_for_debugging()
       const override;
 
   // ContentSuggestionsProvider implementation.
   CategoryStatus GetCategoryStatus(Category category) override;
   CategoryInfo GetCategoryInfo(Category category) override;
   void DismissSuggestion(const ContentSuggestion::ID& suggestion_id) override;
   void FetchSuggestionImage(const ContentSuggestion::ID& suggestion_id,
@@ skipping 22 matching lines @@
       bool is_empty() const;
 
       base::TimeDelta interval_persistent_wifi;
       base::TimeDelta interval_persistent_fallback;
       base::TimeDelta interval_soft_on_usage_event;
       base::TimeDelta interval_soft_on_ntp_opened;
   };
 
   enum class TriggerType;
 
-  // Callback that is notified whenever the status of |provider_| changes.
-  void OnProviderStatusChanged(
-      RemoteSuggestionsProvider::ProviderStatus status);
-
   // After the call, updates will be scheduled in the future. Idempotent, can be
   // run any time later without impacting the current schedule.
   // If you want to enforce rescheduling, call Unschedule() and then Schedule().
   void StartScheduling();
 
   // After the call, no updates will happen before another call to Schedule().
   // Idempotent, can be run any time later without impacting the current
   // schedule.
   void StopScheduling();
 
@@ skipping 13 matching lines @@
                      std::vector<ContentSuggestion> suggestions);
 
   // Callback after RefetchInTheBackground is completed.
   void RefetchInTheBackgroundFinished(
       std::unique_ptr<FetchStatusCallback> callback,
       Status fetch_status);
 
   // Common function to call after a fetch of any type is finished.
   void OnFetchCompleted(Status fetch_status);
 
+  // Clears the time of the last fetch so that the provider is ready to make a
+  // soft fetch at any later time (upon a trigger).
+  void ClearLastFetchAttemptTime();
+
   FetchingSchedule GetDesiredFetchingSchedule() const;
 
   // Load and store |schedule_|.
   void LoadLastFetchingSchedule();
   void StoreFetchingSchedule();
 
   // Applies the persistent schedule given by |schedule_|.
   void ApplyPersistentFetchingSchedule();
 
   // Gets enabled trigger types from the variation parameter.
@@ skipping 12 matching lines @@
   FetchingSchedule schedule_;
   bool background_fetch_in_progress_;
 
   // Used to adapt the schedule based on usage activity of the user. Not owned.
   const UserClassifier* user_classifier_;
 
   PrefService* pref_service_;
   std::unique_ptr<base::Clock> clock_;
   std::set<SchedulingRemoteSuggestionsProvider::TriggerType> enabled_triggers_;
 
+  base::Time background_fetches_allowed_after_;
+
   DISALLOW_COPY_AND_ASSIGN(SchedulingRemoteSuggestionsProvider);
 };
 
 }  // namespace ntp_snippets
 
 #endif  // COMPONENTS_NTP_SNIPPETS_REMOTE_SCHEDULING_REMOTE_SUGGESTIONS_PROVIDER_H_