[Background fetching] Configure and report fetching triggers

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 98 matching lines @@
       static FetchingSchedule Empty();
       bool operator==(const FetchingSchedule& other) const;
       bool operator!=(const FetchingSchedule& other) const;
       bool is_empty() const;
 
       base::TimeDelta interval_persistent_wifi;
       base::TimeDelta interval_persistent_fallback;
       base::TimeDelta interval_soft_on_usage_event;
   };
 
+  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();
 
+  // Trigger a background refetch for the given |trigger| if enabled.
+  void RefetchInTheBackgroundIfEnabled(TriggerType trigger);
+
   // Checks whether it is time to perform a soft background fetch, according to
   // |schedule|.
   bool ShouldRefetchInTheBackgroundNow();
 
+  // Returns whether background fetching (for the given |trigger|) is disabled.
+  bool BackgroundFetchesDisabled(TriggerType trigger) const;
+
   // Callback after Fetch is completed.
   void FetchFinished(const FetchDoneCallback& callback,
                      Status fetch_status,
                      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);
 
   FetchingSchedule GetDesiredFetchingSchedule() const;
 
   // Load and store |schedule_|.
   void LoadLastFetchingSchedule();
   void StoreFetchingSchedule();
-  bool BackgroundFetchesDisabled() const;
 
   // Applies the persistent schedule given by |schedule_|.
   void ApplyPersistentFetchingSchedule();
 
+  // Gets enabled trigger types from the variation parameter.
+  std::set<TriggerType> GetEnabledTriggerTypes();
+
+  // Gets trigger types enabled by default.
+  std::set<TriggerType> GetDefaultEnabledTriggerTypes();
+
   // Interface for doing all the actual work (apart from scheduling).
   std::unique_ptr<RemoteSuggestionsProvider> provider_;
 
   // Interface for scheduling hard fetches, OS dependent. Not owned, may be
   // null.
   PersistentScheduler* persistent_scheduler_;
 
   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_;
 
   DISALLOW_COPY_AND_ASSIGN(SchedulingRemoteSuggestionsProvider);
 };
 
 }  // namespace ntp_snippets
 
 #endif  // COMPONENTS_NTP_SNIPPETS_REMOTE_SCHEDULING_REMOTE_SUGGESTIONS_PROVIDER_H_