[Remote suggestions] Refactor the scheduler

components/ntp_snippets/remote/remote_suggestions_provider_impl.h

 // 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.
 
 #ifndef COMPONENTS_NTP_SNIPPETS_REMOTE_REMOTE_SUGGESTIONS_PROVIDER_IMPL_H_
 #define COMPONENTS_NTP_SNIPPETS_REMOTE_REMOTE_SUGGESTIONS_PROVIDER_IMPL_H_
 
 #include <cstddef>
 #include <deque>
 #include <map>
@@ skipping 99 matching lines @@
  public:
   // |application_language_code| should be a ISO 639-1 compliant string, e.g.
   // 'en' or 'en-US'. Note that this code should only specify the language, not
   // the locale, so 'en_US' (English language with US locale) and 'en-GB_US'
   // (British English person in the US) are not language codes.
   RemoteSuggestionsProviderImpl(
       Observer* observer,
       PrefService* pref_service,
       const std::string& application_language_code,
       CategoryRanker* category_ranker,
+      RemoteSuggestionsScheduler* scheduler,
       std::unique_ptr<RemoteSuggestionsFetcher> suggestions_fetcher,
       std::unique_ptr<image_fetcher::ImageFetcher> image_fetcher,
       std::unique_ptr<RemoteSuggestionsDatabase> database,
       std::unique_ptr<RemoteSuggestionsStatusService> status_service);
 
   ~RemoteSuggestionsProviderImpl() override;
 
   static void RegisterProfilePrefs(PrefRegistrySimple* registry);
 
   // Returns whether the service is ready. While this is false, the list of
   // suggestions will be empty, and all modifications to it (fetch, dismiss,
   // etc) will be ignored.
   bool ready() const { return state_ == State::READY; }
 
   // Returns whether the service is successfully initialized. While this is
   // false, some calls may trigger DCHECKs.
   bool initialized() const { return ready() || state_ == State::DISABLED; }
 
-  // Set the scheduler to be notified whenever the provider becomes active /
-  // in-active and whenever history is deleted. The initial change is also
-  // notified (switching from an initial undecided status). If the scheduler is
-  // set after the first change, it is called back immediately.
-  void SetRemoteSuggestionsScheduler(RemoteSuggestionsScheduler* scheduler);
-
   // RemoteSuggestionsProvider implementation.
   void RefetchInTheBackground(
       std::unique_ptr<FetchStatusCallback> callback) override;
 
   // TODO(fhorschig): Remove this getter when there is an interface for the
   // fetcher that allows better mocks.
   const RemoteSuggestionsFetcher* suggestions_fetcher_for_debugging()
       const override;
 
   // ContentSuggestionsProvider implementation.
@@ skipping 269 matching lines @@
   const Category articles_category_;
 
   std::map<Category, CategoryContent, Category::CompareByID> category_contents_;
 
   // The ISO 639-1 code of the language used by the application.
   const std::string application_language_code_;
 
   // Ranker that orders the categories. Not owned.
   CategoryRanker* category_ranker_;
 
+  // Scheduler to inform about scheduling-related events. Not owned.
+  RemoteSuggestionsScheduler* remote_suggestions_scheduler_;
+
   // The suggestions fetcher.
   std::unique_ptr<RemoteSuggestionsFetcher> suggestions_fetcher_;
 
   // The database for persisting suggestions.
   std::unique_ptr<RemoteSuggestionsDatabase> database_;
   base::TimeTicks database_load_start_;
 
   // The image fetcher.
   CachedImageFetcher image_fetcher_;
 
   // The service that provides events and data about the signin and sync state.
   std::unique_ptr<RemoteSuggestionsStatusService> status_service_;
 
   // Set to true if FetchSuggestions is called while the service isn't ready.
   // The fetch will be executed once the service enters the READY state.
   // TODO(jkrcal): create a struct and have here just one base::Optional<>?
   bool fetch_when_ready_;
 
   // The parameters for the fetch to perform later.
   bool fetch_when_ready_interactive_;
   std::unique_ptr<FetchStatusCallback> fetch_when_ready_callback_;
 
-  RemoteSuggestionsScheduler* remote_suggestions_scheduler_;
-
   // Set to true if ClearHistoryDependentState is called while the service isn't
   // ready. The nuke will be executed once the service finishes initialization
   // or enters the READY state.
   bool clear_history_dependent_state_when_initialized_;
 
   // A clock for getting the time. This allows to inject a clock in tests.
   std::unique_ptr<base::Clock> clock_;
 
   DISALLOW_COPY_AND_ASSIGN(RemoteSuggestionsProviderImpl);
 };
 
 }  // namespace ntp_snippets
 
 #endif  // COMPONENTS_NTP_SNIPPETS_REMOTE_REMOTE_SUGGESTIONS_PROVIDER_IMPL_H_