[NTP::SectionOrder] Replace CategoryFactory with a category ranker.

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 11 matching lines @@
 #include "chrome/common/channel_info.h"
 #include "chrome/common/chrome_features.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/browser_sync/profile_sync_service.h"
 #include "components/image_fetcher/image_decoder.h"
 #include "components/image_fetcher/image_fetcher.h"
 #include "components/image_fetcher/image_fetcher_impl.h"
 #include "components/keyed_service/content/browser_context_dependency_manager.h"
 #include "components/keyed_service/core/service_access_type.h"
 #include "components/ntp_snippets/bookmarks/bookmark_suggestions_provider.h"
-#include "components/ntp_snippets/category_factory.h"
+#include "components/ntp_snippets/category_rankers/constant_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/ntp_snippets_fetcher.h"
 #include "components/ntp_snippets/remote/ntp_snippets_scheduler.h"
 #include "components/ntp_snippets/remote/remote_suggestions_database.h"
 #include "components/ntp_snippets/remote/remote_suggestions_provider.h"
 #include "components/ntp_snippets/remote/remote_suggestions_status_service.h"
 #include "components/ntp_snippets/sessions/foreign_sessions_suggestions_provider.h"
 #include "components/ntp_snippets/sessions/tab_delegate_sync_adapter.h"
@@ skipping 25 matching lines @@
 using offline_pages::OfflinePageModel;
 using offline_pages::OfflinePageModelFactory;
 using physical_web::PhysicalWebDataSource;
 #endif  // OS_ANDROID
 
 using bookmarks::BookmarkModel;
 using content::BrowserThread;
 using history::HistoryService;
 using image_fetcher::ImageFetcherImpl;
 using ntp_snippets::BookmarkSuggestionsProvider;
-using ntp_snippets::CategoryFactory;
 using ntp_snippets::ContentSuggestionsService;
 using ntp_snippets::ForeignSessionsSuggestionsProvider;
 using ntp_snippets::NTPSnippetsFetcher;
 using ntp_snippets::NTPSnippetsScheduler;
 using ntp_snippets::RemoteSuggestionsDatabase;
 using ntp_snippets::RemoteSuggestionsProvider;
 using ntp_snippets::RemoteSuggestionsStatusService;
 using ntp_snippets::TabDelegateSyncAdapter;
 using suggestions::ImageDecoderImpl;
 using syncer::SyncService;
 using translate::LanguageModel;
 
 namespace {
 
 // Clear the tasks that can be scheduled by running services.
 void ClearScheduledTasks() {
 #if defined(OS_ANDROID)
   NTPSnippetsLauncher::Get()->Unschedule();
 #endif  // OS_ANDROID
 }
 
 #if defined(OS_ANDROID)
 void RegisterRecentTabProvider(OfflinePageModel* offline_page_model,
                                ContentSuggestionsService* service,
-                               CategoryFactory* category_factory,
                                PrefService* pref_service) {
   auto provider = base::MakeUnique<RecentTabSuggestionsProvider>(
-      service, category_factory, offline_page_model, pref_service);
+      service, offline_page_model, pref_service);
   service->RegisterProvider(std::move(provider));
 }
 
 void RegisterDownloadsProvider(OfflinePageModel* offline_page_model,
                                DownloadManager* download_manager,
                                ContentSuggestionsService* service,
-                               CategoryFactory* category_factory,
                                PrefService* pref_service) {
   bool download_manager_ui_enabled =
       base::FeatureList::IsEnabled(chrome::android::kDownloadsUiFeature);
   auto provider = base::MakeUnique<DownloadSuggestionsProvider>(
-      service, category_factory, offline_page_model, download_manager,
-      pref_service, download_manager_ui_enabled);
+      service, offline_page_model, download_manager, pref_service,
+      download_manager_ui_enabled);
   service->RegisterProvider(std::move(provider));
 }
 #endif  // OS_ANDROID
 
 void RegisterBookmarkProvider(BookmarkModel* bookmark_model,
                               ContentSuggestionsService* service,
-                              CategoryFactory* category_factory,
                               PrefService* pref_service) {
   auto provider = base::MakeUnique<BookmarkSuggestionsProvider>(
-      service, category_factory, bookmark_model, pref_service);
+      service, bookmark_model, pref_service);
   service->RegisterProvider(std::move(provider));
 }
 
 #if defined(OS_ANDROID)
 void RegisterPhysicalWebPageProvider(
     ContentSuggestionsService* service,
-    CategoryFactory* category_factory,
     PhysicalWebDataSource* physical_web_data_source,
     PrefService* pref_service) {
   auto provider = base::MakeUnique<PhysicalWebPageSuggestionsProvider>(
-      service, category_factory, physical_web_data_source, pref_service);
+      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,
-                             CategoryFactory* category_factory,
                              LanguageModel* language_model,
                              PrefService* pref_service,
                              Profile* profile) {
   scoped_refptr<net::URLRequestContextGetter> request_context =
       content::BrowserContext::GetDefaultStoragePartition(profile)
           ->GetURLRequestContext();
 
   NTPSnippetsScheduler* scheduler = nullptr;
 #if defined(OS_ANDROID)
   scheduler = NTPSnippetsLauncher::Get();
 #endif  // OS_ANDROID
   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);
   bool is_stable_channel =
       chrome::GetChannel() == version_info::Channel::STABLE;
   auto provider = base::MakeUnique<RemoteSuggestionsProvider>(
-      service, service->category_factory(), pref_service,
-      g_browser_process->GetApplicationLocale(), service->user_classifier(),
-      scheduler, base::MakeUnique<NTPSnippetsFetcher>(
-                     signin_manager, token_service, request_context,
-                     pref_service, category_factory, language_model,
-                     base::Bind(&safe_json::SafeJsonParser::Parse),
-                     is_stable_channel ? google_apis::GetAPIKey()
-                                       : google_apis::GetNonStableAPIKey(),
-                     service->user_classifier()),
+      service, pref_service, g_browser_process->GetApplicationLocale(),
+      service->category_ranker(), service->user_classifier(), scheduler,

[tschumann, 2016/12/15 11:50:26]

that's a bit of an anti-pattern but okay for now (as we do the same with the
user_classifier).
As we create those instances within this factory, it would be cleaner to pass
them intothe function instead of abusing the service to carry them through (the
service shouldn't have to expose those members).

[vitaliii, 2016/12/15 15:30:12]

That's true, but currently user_classifier is used in the bridge and
snippets_internals, so this is out of scope for this CL. Marc has already
pointed this out and I added a TODO (ntp_snippets_bridge.cc:370).

+      base::MakeUnique<NTPSnippetsFetcher>(
+          signin_manager, token_service, request_context, pref_service,
+          language_model, base::Bind(&safe_json::SafeJsonParser::Parse),
+          is_stable_channel ? google_apis::GetAPIKey()
+                            : google_apis::GetNonStableAPIKey(),
+          service->user_classifier()),
       base::MakeUnique<ImageFetcherImpl>(base::MakeUnique<ImageDecoderImpl>(),
                                          request_context.get()),
       base::MakeUnique<ImageDecoderImpl>(),
       base::MakeUnique<RemoteSuggestionsDatabase>(database_dir, task_runner),
       base::MakeUnique<RemoteSuggestionsStatusService>(signin_manager,
                                                        pref_service));
   service->set_ntp_snippets_service(provider.get());
   service->RegisterProvider(std::move(provider));
 }
 
 void RegisterForeignSessionsProvider(SyncService* sync_service,
                                      ContentSuggestionsService* service,
-                                     CategoryFactory* category_factory,
                                      PrefService* pref_service) {
   std::unique_ptr<TabDelegateSyncAdapter> sync_adapter =
       base::MakeUnique<TabDelegateSyncAdapter>(sync_service);
   auto provider = base::MakeUnique<ForeignSessionsSuggestionsProvider>(
-      service, category_factory, std::move(sync_adapter), pref_service);
+      service, std::move(sync_adapter), pref_service);
   service->RegisterProvider(std::move(provider));
 }
 
 }  // namespace
 
 // static
 ContentSuggestionsServiceFactory*
 ContentSuggestionsServiceFactory::GetInstance() {
   return base::Singleton<ContentSuggestionsServiceFactory>::get();
 }
@@ skipping 37 matching lines @@
   // Create the ContentSuggestionsService.
   State state =
       base::FeatureList::IsEnabled(ntp_snippets::kContentSuggestionsFeature)
           ? State::ENABLED
           : State::DISABLED;
   SigninManagerBase* signin_manager =
       SigninManagerFactory::GetForProfile(profile);
   HistoryService* history_service = HistoryServiceFactory::GetForProfile(
       profile, ServiceAccessType::EXPLICIT_ACCESS);
   PrefService* pref_service = profile->GetPrefs();
-  auto* service = new ContentSuggestionsService(state, signin_manager,
-                                                history_service, pref_service);
+  auto category_ranker =
+      base::MakeUnique<ntp_snippets::ConstantCategoryRanker>();
+  auto* service =
+      new ContentSuggestionsService(state, signin_manager, history_service,
+                                    pref_service, std::move(category_ranker));
   if (state == State::DISABLED) {
     // Since we won't initialise the services, they won't get a chance to
     // unschedule their tasks. We do it explicitly here instead.
     ClearScheduledTasks();
     return service;
   }
 
-  CategoryFactory* category_factory = service->category_factory();
 #if defined(OS_ANDROID)
   OfflinePageModel* offline_page_model =
       OfflinePageModelFactory::GetForBrowserContext(profile);
   DownloadManager* download_manager =
       content::BrowserContext::GetDownloadManager(profile);
   PhysicalWebDataSource* physical_web_data_source =
       g_browser_process->GetPhysicalWebDataSource();
 #endif  // OS_ANDROID
   BookmarkModel* bookmark_model =
       BookmarkModelFactory::GetForBrowserContext(profile);
   OAuth2TokenService* token_service =
       ProfileOAuth2TokenServiceFactory::GetForProfile(profile);
   SyncService* sync_service =
       ProfileSyncServiceFactory::GetSyncServiceForBrowserContext(profile);
   LanguageModel* language_model =
       LanguageModelFactory::GetInstance()->GetForBrowserContext(profile);
 
 #if defined(OS_ANDROID)
   if (base::FeatureList::IsEnabled(
           ntp_snippets::kRecentOfflineTabSuggestionsFeature)) {
-    RegisterRecentTabProvider(offline_page_model, service, category_factory,
-                              pref_service);
+    RegisterRecentTabProvider(offline_page_model, service, pref_service);
   }
 
   bool show_asset_downloads =
       base::FeatureList::IsEnabled(features::kAssetDownloadSuggestionsFeature);
   bool show_offline_page_downloads = base::FeatureList::IsEnabled(
       features::kOfflinePageDownloadSuggestionsFeature);
   if (show_asset_downloads || show_offline_page_downloads) {
     RegisterDownloadsProvider(
         show_offline_page_downloads ? offline_page_model : nullptr,
         show_asset_downloads ? download_manager : nullptr, service,
-        category_factory, pref_service);
+        pref_service);
   }
 #endif  // OS_ANDROID
 
   // |bookmark_model| can be null in tests.
   if (base::FeatureList::IsEnabled(ntp_snippets::kBookmarkSuggestionsFeature) &&
       bookmark_model) {
-    RegisterBookmarkProvider(bookmark_model, service, category_factory,
-                             pref_service);
+    RegisterBookmarkProvider(bookmark_model, service, pref_service);
   }
 
 #if defined(OS_ANDROID)
   if (base::FeatureList::IsEnabled(
           ntp_snippets::kPhysicalWebPageSuggestionsFeature)) {
-    RegisterPhysicalWebPageProvider(service, category_factory,
-                                    physical_web_data_source, pref_service);
+    RegisterPhysicalWebPageProvider(service, physical_web_data_source,
+                                    pref_service);
   }
 #endif  // OS_ANDROID
 
   if (base::FeatureList::IsEnabled(ntp_snippets::kArticleSuggestionsFeature)) {
     RegisterArticleProvider(signin_manager, token_service, service,
-                            category_factory, language_model, pref_service,
-                            profile);
+                            language_model, pref_service, profile);
   }
 
   if (base::FeatureList::IsEnabled(
           ntp_snippets::kForeignSessionsSuggestionsFeature)) {
-    RegisterForeignSessionsProvider(sync_service, service, category_factory,
-                                    pref_service);
+    RegisterForeignSessionsProvider(sync_service, service, pref_service);
   }
 
   return service;
 }