[Remote suggestions] Refactor the scheduler

chrome/browser/ntp_snippets/content_suggestions_service_factory.cc

 // 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.
 
 #include "chrome/browser/ntp_snippets/content_suggestions_service_factory.h"
 
 #include <utility>
 
 #include "base/feature_list.h"
 #include "base/files/file_path.h"
@@ skipping 21 matching lines @@
 #include "components/keyed_service/core/service_access_type.h"
 #include "components/ntp_snippets/bookmarks/bookmark_suggestions_provider.h"
 #include "components/ntp_snippets/category_rankers/category_ranker.h"
 #include "components/ntp_snippets/content_suggestions_service.h"
 #include "components/ntp_snippets/features.h"
 #include "components/ntp_snippets/ntp_snippets_constants.h"
 #include "components/ntp_snippets/remote/persistent_scheduler.h"
 #include "components/ntp_snippets/remote/remote_suggestions_database.h"
 #include "components/ntp_snippets/remote/remote_suggestions_fetcher.h"
 #include "components/ntp_snippets/remote/remote_suggestions_provider_impl.h"
+#include "components/ntp_snippets/remote/remote_suggestions_scheduler_impl.h"
 #include "components/ntp_snippets/remote/remote_suggestions_status_service.h"
-#include "components/ntp_snippets/remote/scheduling_remote_suggestions_provider.h"
 #include "components/ntp_snippets/sessions/foreign_sessions_suggestions_provider.h"
 #include "components/ntp_snippets/sessions/tab_delegate_sync_adapter.h"
+#include "components/ntp_snippets/user_classifier.h"
 #include "components/prefs/pref_service.h"
 #include "components/safe_json/safe_json_parser.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "components/translate/core/browser/language_model.h"
 #include "components/version_info/version_info.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/storage_partition.h"
 #include "google_apis/google_api_keys.h"
@@ skipping 32 matching lines @@
 using image_fetcher::ImageFetcherImpl;
 using ntp_snippets::BookmarkSuggestionsProvider;
 using ntp_snippets::CategoryRanker;
 using ntp_snippets::ContentSuggestionsService;
 using ntp_snippets::ForeignSessionsSuggestionsProvider;
 using ntp_snippets::GetFetchEndpoint;
 using ntp_snippets::PersistentScheduler;
 using ntp_snippets::RemoteSuggestionsDatabase;
 using ntp_snippets::RemoteSuggestionsFetcher;
 using ntp_snippets::RemoteSuggestionsProviderImpl;
+using ntp_snippets::RemoteSuggestionsSchedulerImpl;
 using ntp_snippets::RemoteSuggestionsStatusService;
-using ntp_snippets::SchedulingRemoteSuggestionsProvider;
 using ntp_snippets::TabDelegateSyncAdapter;
+using ntp_snippets::UserClassifier;
 using suggestions::ImageDecoderImpl;
 using syncer::SyncService;
 using translate::LanguageModel;
 
 // For now, ContentSuggestionsService must only be instantiated on Android.
 // See also crbug.com/688366.
 #if defined(OS_ANDROID)
 #define CONTENT_SUGGESTIONS_ENABLED 1
 #else
 #define CONTENT_SUGGESTIONS_ENABLED 0
@@ skipping 63 matching lines @@
       service, physical_web_data_source, pref_service);
   service->RegisterProvider(std::move(provider));
 }
 
 #endif  // OS_ANDROID
 
 void RegisterArticleProvider(SigninManagerBase* signin_manager,
                              OAuth2TokenService* token_service,
                              ContentSuggestionsService* service,
                              LanguageModel* language_model,
+                             UserClassifier* user_classifier,
                              PrefService* pref_service,
                              Profile* profile) {
   scoped_refptr<net::URLRequestContextGetter> request_context =
       content::BrowserContext::GetDefaultStoragePartition(profile)
           ->GetURLRequestContext();
 
   base::FilePath database_dir(
       profile->GetPath().Append(ntp_snippets::kDatabaseFolder));
   scoped_refptr<base::SequencedTaskRunner> task_runner =
       BrowserThread::GetBlockingPool()
           ->GetSequencedTaskRunnerWithShutdownBehavior(
               base::SequencedWorkerPool::GetSequenceToken(),
               base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN);
   std::string api_key;
   // The API is private. If we don't have the official API key, don't even try.
   if (google_apis::IsGoogleChromeAPIKeyUsed()) {
     bool is_stable_channel =
         chrome::GetChannel() == version_info::Channel::STABLE;
     api_key = is_stable_channel ? google_apis::GetAPIKey()
                                 : google_apis::GetNonStableAPIKey();
   }
   auto suggestions_fetcher = base::MakeUnique<RemoteSuggestionsFetcher>(
       signin_manager, token_service, request_context, pref_service,
       language_model, base::Bind(&safe_json::SafeJsonParser::Parse),
-      GetFetchEndpoint(chrome::GetChannel()), api_key,
-      service->user_classifier());
+      GetFetchEndpoint(chrome::GetChannel()), api_key, user_classifier);
   auto provider = base::MakeUnique<RemoteSuggestionsProviderImpl>(
       service, pref_service, g_browser_process->GetApplicationLocale(),
-      service->category_ranker(), std::move(suggestions_fetcher),
+      service->category_ranker(), service->remote_suggestions_scheduler(),
+      std::move(suggestions_fetcher),
       base::MakeUnique<ImageFetcherImpl>(base::MakeUnique<ImageDecoderImpl>(),
                                          request_context.get()),
       base::MakeUnique<RemoteSuggestionsDatabase>(database_dir, task_runner),
       base::MakeUnique<RemoteSuggestionsStatusService>(signin_manager,
                                                        pref_service));
 
-  PersistentScheduler* scheduler = nullptr;
-#if defined(OS_ANDROID)
-  scheduler = NTPSnippetsLauncher::Get();
-#endif  // OS_ANDROID
-
-  RemoteSuggestionsProviderImpl* provider_raw = provider.get();
-  auto scheduling_provider =
-      base::MakeUnique<SchedulingRemoteSuggestionsProvider>(
-          service, std::move(provider), scheduler, service->user_classifier(),
-          pref_service, g_browser_process->local_state(),
-          base::MakeUnique<base::DefaultClock>());
-  provider_raw->SetRemoteSuggestionsScheduler(scheduling_provider.get());
-  service->set_remote_suggestions_provider(scheduling_provider.get());
-  service->set_remote_suggestions_scheduler(scheduling_provider.get());
-  service->RegisterProvider(std::move(scheduling_provider));
+  service->remote_suggestions_scheduler()->SetProvider(provider.get());
+  service->set_remote_suggestions_provider(provider.get());
+  service->RegisterProvider(std::move(provider));
 }
 
 void RegisterForeignSessionsProvider(SyncService* sync_service,
                                      ContentSuggestionsService* service,
                                      PrefService* pref_service) {
   std::unique_ptr<TabDelegateSyncAdapter> sync_adapter =
       base::MakeUnique<TabDelegateSyncAdapter>(sync_service);
   auto provider = base::MakeUnique<ForeignSessionsSuggestionsProvider>(
       service, std::move(sync_adapter), pref_service);
   service->RegisterProvider(std::move(provider));
@@ skipping 39 matching lines @@
 
 ContentSuggestionsServiceFactory::~ContentSuggestionsServiceFactory() = default;
 
 KeyedService* ContentSuggestionsServiceFactory::BuildServiceInstanceFor(
     content::BrowserContext* context) const {
 #if CONTENT_SUGGESTIONS_ENABLED
 
   using State = ContentSuggestionsService::State;
   Profile* profile = Profile::FromBrowserContext(context);
   DCHECK(!profile->IsOffTheRecord());
+  PrefService* pref_service = profile->GetPrefs();
+
+  auto user_classifier = base::MakeUnique<UserClassifier>(
+      pref_service, base::MakeUnique<base::DefaultClock>());
+  auto* user_classifier_raw = user_classifier.get();
+
+  // Create the RemoteSuggestionsScheduler.
+  PersistentScheduler* persistent_scheduler = nullptr;
+#if defined(OS_ANDROID)
+  persistent_scheduler = NTPSnippetsLauncher::Get();
+#endif  // OS_ANDROID
+  auto scheduler = base::MakeUnique<RemoteSuggestionsSchedulerImpl>(
+      persistent_scheduler, user_classifier_raw, pref_service,
+      g_browser_process->local_state(), base::MakeUnique<base::DefaultClock>());
 
   // Create the ContentSuggestionsService.
   SigninManagerBase* signin_manager =
       SigninManagerFactory::GetForProfile(profile);
   HistoryService* history_service = HistoryServiceFactory::GetForProfile(
       profile, ServiceAccessType::EXPLICIT_ACCESS);
-  PrefService* pref_service = profile->GetPrefs();
   std::unique_ptr<CategoryRanker> category_ranker =
       ntp_snippets::BuildSelectedCategoryRanker(
           pref_service, base::MakeUnique<base::DefaultClock>());
-  auto* service = new ContentSuggestionsService(State::ENABLED, signin_manager,
-                                                history_service, pref_service,
-                                                std::move(category_ranker));
+  auto* service = new ContentSuggestionsService(
+      State::ENABLED, signin_manager, history_service, pref_service,
+      std::move(category_ranker), std::move(user_classifier),
+      std::move(scheduler));
 
 #if defined(OS_ANDROID)
   OfflinePageModel* offline_page_model =
       OfflinePageModelFactory::GetForBrowserContext(profile);
   RequestCoordinator* request_coordinator =
       RequestCoordinatorFactory::GetForBrowserContext(profile);
   DownloadManager* download_manager =
       content::BrowserContext::GetDownloadManager(profile);
   DownloadService* download_service =
       DownloadServiceFactory::GetForBrowserContext(profile);
@@ skipping 36 matching lines @@
 
 #if defined(OS_ANDROID)
   if (IsPhysicalWebPageProviderEnabled()) {
     RegisterPhysicalWebPageProvider(service, physical_web_data_source,
                                     pref_service);
   }
 #endif  // OS_ANDROID
 
   if (base::FeatureList::IsEnabled(ntp_snippets::kArticleSuggestionsFeature)) {
     RegisterArticleProvider(signin_manager, token_service, service,
-                            language_model, pref_service, profile);
+                            language_model, user_classifier_raw, pref_service,
+                            profile);
   }
 
   if (base::FeatureList::IsEnabled(
           ntp_snippets::kForeignSessionsSuggestionsFeature)) {
     RegisterForeignSessionsProvider(sync_service, service, pref_service);
   }
 
   return service;
 
 #else
   return nullptr;
 #endif  // CONTENT_SUGGESTIONS_ENABLED
 }