Don't instantiate ContentSuggestionsService on non-Android

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 77 matching lines @@
 using ntp_snippets::RemoteSuggestionsDatabase;
 using ntp_snippets::RemoteSuggestionsFetcher;
 using ntp_snippets::RemoteSuggestionsProviderImpl;
 using ntp_snippets::RemoteSuggestionsStatusService;
 using ntp_snippets::SchedulingRemoteSuggestionsProvider;
 using ntp_snippets::TabDelegateSyncAdapter;
 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
+#endif  // OS_ANDROID
+
+// The actual #if that does the work is below in BuildServiceInstanceFor. This
+// one is just required to avoid "unused code" compiler errors.
+#if CONTENT_SUGGESTIONS_ENABLED
+
 namespace {
 
 #if defined(OS_ANDROID)
 
 bool IsRecentTabProviderEnabled() {
   return base::FeatureList::IsEnabled(
              ntp_snippets::kRecentOfflineTabSuggestionsFeature) &&
          base::FeatureList::IsEnabled(
              offline_pages::kOffliningRecentPagesFeature);
 }
 
 void RegisterRecentTabProvider(OfflinePageModel* offline_page_model,
                                ContentSuggestionsService* service,
                                PrefService* pref_service) {
   auto provider = base::MakeUnique<RecentTabSuggestionsProvider>(
       service, offline_page_model, pref_service);
   service->RegisterProvider(std::move(provider));
 }
 
 void RegisterDownloadsProvider(OfflinePageModel* offline_page_model,
                                DownloadManager* download_manager,
                                DownloadHistory* download_history,
                                ContentSuggestionsService* service,
                                PrefService* pref_service) {
   auto provider = base::MakeUnique<DownloadSuggestionsProvider>(
       service, offline_page_model, download_manager, download_history,
       pref_service, base::MakeUnique<base::DefaultClock>());
   service->RegisterProvider(std::move(provider));
 }
+
 #endif  // OS_ANDROID
 
 void RegisterBookmarkProvider(BookmarkModel* bookmark_model,
                               ContentSuggestionsService* service,
                               PrefService* pref_service) {
   auto provider = base::MakeUnique<BookmarkSuggestionsProvider>(
       service, bookmark_model, pref_service);
   service->RegisterProvider(std::move(provider));
 }
 
 #if defined(OS_ANDROID)
 
 bool IsPhysicalWebPageProviderEnabled() {
   return base::FeatureList::IsEnabled(
              ntp_snippets::kPhysicalWebPageSuggestionsFeature) &&
          base::FeatureList::IsEnabled(chrome::android::kPhysicalWebFeature);
 }
 
 void RegisterPhysicalWebPageProvider(
     ContentSuggestionsService* service,
     PhysicalWebDataSource* physical_web_data_source,
     PrefService* pref_service) {
   auto provider = base::MakeUnique<PhysicalWebPageSuggestionsProvider>(
       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,
                              PrefService* pref_service,
                              Profile* profile) {
   scoped_refptr<net::URLRequestContextGetter> request_context =
       content::BrowserContext::GetDefaultStoragePartition(profile)
@@ skipping 43 matching lines @@
                                      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));
 }
 
 }  // namespace
 
+#endif  // CONTENT_SUGGESTIONS_ENABLED
+
 // static
 ContentSuggestionsServiceFactory*
 ContentSuggestionsServiceFactory::GetInstance() {
   return base::Singleton<ContentSuggestionsServiceFactory>::get();
 }
 
 // static
 ContentSuggestionsService* ContentSuggestionsServiceFactory::GetForProfile(
     Profile* profile) {
   return static_cast<ContentSuggestionsService*>(
@@ skipping 18 matching lines @@
 #endif  // OS_ANDROID
   DependsOn(ProfileOAuth2TokenServiceFactory::GetInstance());
   DependsOn(ProfileSyncServiceFactory::GetInstance());
   DependsOn(SigninManagerFactory::GetInstance());
 }
 
 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());
 
   // Create the ContentSuggestionsService.
   SigninManagerBase* signin_manager =
       SigninManagerFactory::GetForProfile(profile);
   HistoryService* history_service = HistoryServiceFactory::GetForProfile(
       profile, ServiceAccessType::EXPLICIT_ACCESS);
   PrefService* pref_service = profile->GetPrefs();
@@ skipping 58 matching lines @@
     RegisterArticleProvider(signin_manager, token_service, service,
                             language_model, 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
 }