[Offline Pages] Add a GCMAppHandler for offline page prefetch.

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 29 matching lines @@
 #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/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/offline_pages/features/features.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"
 #include "net/url_request/url_request_context_getter.h"
 
 #if defined(OS_ANDROID)
 #include "chrome/browser/android/chrome_feature_list.h"
 #include "chrome/browser/android/ntp/ntp_snippets_launcher.h"
-#include "chrome/browser/android/offline_pages/offline_page_model_factory.h"
-#include "chrome/browser/android/offline_pages/request_coordinator_factory.h"
 #include "chrome/browser/download/download_core_service.h"
 #include "chrome/browser/download/download_core_service_factory.h"
 #include "chrome/browser/download/download_history.h"
 #include "chrome/browser/ntp_snippets/download_suggestions_provider.h"
+#include "components/ntp_snippets/physical_web_pages/physical_web_page_suggestions_provider.h"
+#include "components/physical_web/data_source/physical_web_data_source.h"
+#endif
+
+#if BUILDFLAG(ENABLE_OFFLINE_PAGES)
+#include "chrome/browser/android/offline_pages/offline_page_model_factory.h"
+#include "chrome/browser/android/offline_pages/request_coordinator_factory.h"
+#include "chrome/browser/offline_pages/prefetch/prefetch_service_factory.h"
 #include "components/ntp_snippets/offline_pages/recent_tab_suggestions_provider.h"
-#include "components/ntp_snippets/physical_web_pages/physical_web_page_suggestions_provider.h"
-#include "components/offline_pages/content/suggested_articles_observer.h"
 #include "components/offline_pages/core/background/request_coordinator.h"
 #include "components/offline_pages/core/offline_page_feature.h"
 #include "components/offline_pages/core/offline_page_model.h"
+#include "components/offline_pages/core/prefetch/suggested_articles_observer.h"
 #include "components/offline_pages/core/recent_tabs/recent_tabs_ui_adapter_delegate.h"
-#include "components/physical_web/data_source/physical_web_data_source.h"
-
-using content::DownloadManager;
-using ntp_snippets::PhysicalWebPageSuggestionsProvider;
-using ntp_snippets::RecentTabSuggestionsProvider;
-using offline_pages::OfflinePageModel;
-using offline_pages::RequestCoordinator;
-using offline_pages::OfflinePageModelFactory;
-using offline_pages::RequestCoordinatorFactory;
-using physical_web::PhysicalWebDataSource;
-#endif  // OS_ANDROID
+#endif
 
 using bookmarks::BookmarkModel;
 using content::BrowserThread;
 using history::HistoryService;
 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::TabDelegateSyncAdapter;
 using ntp_snippets::UserClassifier;
 using suggestions::ImageDecoderImpl;
 using syncer::SyncService;
 using translate::LanguageModel;
 
+#if defined(OS_ANDROID)
+using content::DownloadManager;
+using ntp_snippets::PhysicalWebPageSuggestionsProvider;
+using physical_web::PhysicalWebDataSource;
+#endif  // OS_ANDROID
+
+#if BUILDFLAG(ENABLE_OFFLINE_PAGES)
+using ntp_snippets::RecentTabSuggestionsProvider;
+using offline_pages::OfflinePageModel;
+using offline_pages::RequestCoordinator;
+using offline_pages::OfflinePageModelFactory;
+using offline_pages::RequestCoordinatorFactory;
+#endif  // BUILDFLAG(ENABLE_OFFLINE_PAGES)
+
 // 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 {
 
 bool IsChromeHomeEnabled() {
 #if defined(OS_ANDROID)
   return base::FeatureList::IsEnabled(chrome::android::kChromeHomeFeature);
 #else
   return false;
 #endif
 }
 
-#if defined(OS_ANDROID)
+#if BUILDFLAG(ENABLE_OFFLINE_PAGES)
 
 bool IsRecentTabProviderEnabled() {
   return base::FeatureList::IsEnabled(
              ntp_snippets::kRecentOfflineTabSuggestionsFeature) &&
          base::FeatureList::IsEnabled(
              offline_pages::kOffliningRecentPagesFeature);
 }
 
 void RegisterRecentTabProvider(OfflinePageModel* offline_page_model,
                                RequestCoordinator* request_coordinator,
                                ContentSuggestionsService* service,
                                PrefService* pref_service) {
   offline_pages::DownloadUIAdapter* ui_adapter = offline_pages::
       RecentTabsUIAdapterDelegate::GetOrCreateRecentTabsUIAdapter(
           offline_page_model, request_coordinator);
   auto provider = base::MakeUnique<RecentTabSuggestionsProvider>(
       service, ui_adapter, pref_service);
   service->RegisterProvider(std::move(provider));
 }
 
+#endif  // BUILDFLAG(ENABLE_OFFLINE_PAGES)
+
+#if defined(OS_ANDROID)
+
 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));
 }
@@ skipping 114 matching lines @@
       GetInstance()->GetServiceForBrowserContext(profile, false));
 }
 
 ContentSuggestionsServiceFactory::ContentSuggestionsServiceFactory()
     : BrowserContextKeyedServiceFactory(
           "ContentSuggestionsService",
           BrowserContextDependencyManager::GetInstance()) {
   DependsOn(BookmarkModelFactory::GetInstance());
   DependsOn(HistoryServiceFactory::GetInstance());
   DependsOn(LargeIconServiceFactory::GetInstance());
-#if defined(OS_ANDROID)
+#if BUILDFLAG(ENABLE_OFFLINE_PAGES)
   DependsOn(OfflinePageModelFactory::GetInstance());
-#endif  // OS_ANDROID
+  DependsOn(offline_pages::PrefetchServiceFactory::GetInstance());
+#endif  // BUILDFLAG(ENABLE_OFFLINE_PAGES)
   DependsOn(ProfileOAuth2TokenServiceFactory::GetInstance());
   DependsOn(ProfileSyncServiceFactory::GetInstance());
   DependsOn(SigninManagerFactory::GetInstance());
 }
 
 ContentSuggestionsServiceFactory::~ContentSuggestionsServiceFactory() = default;
 
 KeyedService* ContentSuggestionsServiceFactory::BuildServiceInstanceFor(
     content::BrowserContext* context) const {
 #if CONTENT_SUGGESTIONS_ENABLED
@@ skipping 24 matching lines @@
   favicon::LargeIconService* large_icon_service =
       LargeIconServiceFactory::GetForBrowserContext(profile);
   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, large_icon_service,
       pref_service, std::move(category_ranker), std::move(user_classifier),
       std::move(scheduler));
 
-#if defined(OS_ANDROID)
+#if BUILDFLAG(ENABLE_OFFLINE_PAGES)
   OfflinePageModel* offline_page_model =
       OfflinePageModelFactory::GetForBrowserContext(profile);
   if (IsRecentTabProviderEnabled()) {
     RequestCoordinator* request_coordinator =
         RequestCoordinatorFactory::GetForBrowserContext(profile);
     RegisterRecentTabProvider(offline_page_model, request_coordinator, service,
                               pref_service);
   }
 
+  offline_pages::PrefetchService* prefetch_service =
+      offline_pages::PrefetchServiceFactory::GetForBrowserContext(profile);
+  prefetch_service->ObserveContentSuggestionsService(service);
+#endif  // BUILDFLAG(ENABLE_OFFLINE_PAGES)
+
+#if defined(OS_ANDROID)
   bool show_asset_downloads =
       !IsChromeHomeEnabled() &&
       base::FeatureList::IsEnabled(features::kAssetDownloadSuggestionsFeature);
   bool show_offline_page_downloads =
       !IsChromeHomeEnabled() &&
       base::FeatureList::IsEnabled(
           features::kOfflinePageDownloadSuggestionsFeature);
   if (show_asset_downloads || show_offline_page_downloads) {
     DownloadManager* download_manager =
         content::BrowserContext::GetDownloadManager(profile);
     DownloadCoreService* download_core_service =
         DownloadCoreServiceFactory::GetForBrowserContext(profile);
     DownloadHistory* download_history =
         download_core_service->GetDownloadHistory();
     RegisterDownloadsProvider(
         show_offline_page_downloads ? offline_page_model : nullptr,
         show_asset_downloads ? download_manager : nullptr, download_history,
         service, pref_service);
   }
-
-  offline_pages::SuggestedArticlesObserver::ObserveContentSuggestionsService(
-      profile, service);
 #endif  // OS_ANDROID
 
   // |bookmark_model| can be null in tests.
   BookmarkModel* bookmark_model =
       BookmarkModelFactory::GetForBrowserContext(profile);
   if (base::FeatureList::IsEnabled(ntp_snippets::kBookmarkSuggestionsFeature) &&
       bookmark_model && !IsChromeHomeEnabled()) {
     RegisterBookmarkProvider(bookmark_model, service);
   }
 
@@ skipping 22 matching lines @@
         ProfileSyncServiceFactory::GetSyncServiceForBrowserContext(profile);
     RegisterForeignSessionsProvider(sync_service, service, pref_service);
   }
 
   return service;
 
 #else
   return nullptr;
 #endif  // CONTENT_SUGGESTIONS_ENABLED
 }