Split prefetch gcm handler from token creation

The GCM handler doesn't need to create the GCM token. Splitting this interface
simplifies the code. Additionally, we can now always create the gcm handler,
even in reduced mode.

GetGCMToken() is now a global function, and still called only after browser start.

This is safer, because the handler is accessed by
another keyed service. Before this CL, there was no guarantee that the gcm handler
would be created before it's accessed by gcm_profile_service_factory.cc

Change-Id: I27ab837f4294f450ee11dfaa9a833ba90cf3c83a
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1690712
Commit-Queue: Dan H <harringtond@chromium.org>
Reviewed-by: Carlos Knippschild <carlosk@chromium.org>
Reviewed-by: Justin DeWitt <dewittj@chromium.org>
Cr-Commit-Position: refs/heads/master@{#706646}

chrome/browser/BUILD.gn

@@ -4691,6 +4691,8 @@ jumbo_split_static_library("browser") {
       "offline_pages/offliner_helper.h",
       "offline_pages/offliner_user_data.cc",
       "offline_pages/offliner_user_data.h",
+      "offline_pages/prefetch/gcm_token.cc",
+      "offline_pages/prefetch/gcm_token.h",
       "offline_pages/prefetch/offline_metrics_collector_impl.cc",
       "offline_pages/prefetch/offline_metrics_collector_impl.h",
       "offline_pages/prefetch/offline_prefetch_download_client.cc",
@@ -4698,8 +4700,6 @@ jumbo_split_static_library("browser") {
       "offline_pages/prefetch/prefetch_background_task_handler_impl.cc",
       "offline_pages/prefetch/prefetch_background_task_handler_impl.h",
       "offline_pages/prefetch/prefetch_background_task_scheduler.h",
-      "offline_pages/prefetch/prefetch_instance_id_proxy.cc",
-      "offline_pages/prefetch/prefetch_instance_id_proxy.h",
       "offline_pages/prefetch/prefetch_service_factory.cc",
       "offline_pages/prefetch/prefetch_service_factory.h",
       "offline_pages/prefetch/prefetched_pages_notifier.cc",

chrome/browser/offline_pages/prefetch/prefetch_instance_id_proxy.cc → chrome/browser/offline_pages/prefetch/gcm_token.cc

-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2019 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/offline_pages/prefetch/prefetch_instance_id_proxy.h"
+#include "chrome/browser/offline_pages/prefetch/gcm_token.h"
 
 #include <map>
 
 #include "base/bind.h"
 #include "base/callback.h"
+#include "base/logging.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/gcm/instance_id/instance_id_profile_service_factory.h"
 #include "components/gcm_driver/instance_id/instance_id.h"
@@ -23,50 +24,31 @@ namespace {
 
 const char kScopeGCM[] = "GCM";
 const char kProdSenderId[] = "864229763856";
-
 }  // namespace
 
 namespace offline_pages {
 
-PrefetchInstanceIDProxy::PrefetchInstanceIDProxy(
-    const std::string& app_id,
-    content::BrowserContext* context)
-    : app_id_(app_id), context_(context) {}
-
-PrefetchInstanceIDProxy::~PrefetchInstanceIDProxy() = default;
-
-void PrefetchInstanceIDProxy::GetGCMToken(
-    InstanceID::GetTokenCallback callback) {
+void GetGCMToken(content::BrowserContext* context,
+                 const std::string& app_id,
+                 instance_id::InstanceID::GetTokenCallback callback) {
   DCHECK(IsPrefetchingOfflinePagesEnabled());
-  if (!token_.empty()) {
-    base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE,
-        base::BindOnce(&PrefetchInstanceIDProxy::GotGCMToken,
-                       weak_factory_.GetWeakPtr(), std::move(callback), token_,
-                       InstanceID::SUCCESS));
+  // If the callback is canceled, |context| may not be alive anymore.
+  if (!callback.MaybeValid())
     return;
-  }
 
+  DCHECK(context);
   InstanceIDProfileService* service =
-      InstanceIDProfileServiceFactory::GetForProfile(context_);
+      InstanceIDProfileServiceFactory::GetForProfile(context);
   DCHECK(service);
 
-  InstanceID* instance_id = service->driver()->GetInstanceID(app_id_);
-  DCHECK(instance_id);
-
-  instance_id->GetToken(
-      kProdSenderId, kScopeGCM, std::map<std::string, std::string>(),
-      /*flags=*/{},
-      base::BindOnce(&PrefetchInstanceIDProxy::GotGCMToken,
-                     weak_factory_.GetWeakPtr(), std::move(callback)));
-}
+  InstanceID* instance_id = service->driver()->GetInstanceID(app_id);
+  if (!instance_id) {
+    DLOG(ERROR) << "GetInstanceID() returned null";
+    return;
+  }
 
-void PrefetchInstanceIDProxy::GotGCMToken(InstanceID::GetTokenCallback callback,
-                                          const std::string& token,
-                                          InstanceID::Result result) {
-  DVLOG(1) << "Got an Instance ID token for GCM: " << token
-           << " with result: " << result;
-  std::move(callback).Run(token, result);
+  instance_id->GetToken(kProdSenderId, kScopeGCM, /*options=*/{},
+                        /*flags=*/{}, std::move(callback));
 }
 
 }  // namespace offline_pages

chrome/browser/offline_pages/prefetch/gcm_token.h

+// Copyright 2019 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 CHROME_BROWSER_OFFLINE_PAGES_PREFETCH_GCM_TOKEN_H_
+#define CHROME_BROWSER_OFFLINE_PAGES_PREFETCH_GCM_TOKEN_H_
+
+#include <string>
+
+#include "base/memory/ref_counted.h"
+#include "base/memory/weak_ptr.h"
+#include "components/gcm_driver/instance_id/instance_id.h"
+#include "components/offline_pages/core/prefetch/prefetch_gcm_app_handler.h"
+
+namespace content {
+class BrowserContext;
+}
+
+namespace offline_pages {
+
+// Returns a GCM token to be used for prefetching.
+void GetGCMToken(content::BrowserContext* context,
+                 const std::string& app_id,
+                 instance_id::InstanceID::GetTokenCallback callback);
+
+}  // namespace offline_pages
+
+#endif  // CHROME_BROWSER_OFFLINE_PAGES_PREFETCH_GCM_TOKEN_H_

chrome/browser/offline_pages/prefetch/prefetch_instance_id_proxy_unittest.cc → chrome/browser/offline_pages/prefetch/gcm_token_unittest.cc

@@ -2,12 +2,13 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "chrome/browser/offline_pages/prefetch/prefetch_instance_id_proxy.h"
+#include "chrome/browser/offline_pages/prefetch/gcm_token.h"
 
 #include "base/bind.h"
 #include "base/run_loop.h"
 #include "base/test/scoped_feature_list.h"
 #include "base/test/task_environment.h"
+#include "build/build_config.h"
 #include "chrome/browser/gcm/gcm_profile_service_factory.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/gcm_driver/fake_gcm_profile_service.h"
@@ -42,14 +43,11 @@ class PrefetchInstanceIDProxyTest : public testing::Test {
   // Sync wrapper for async version.
   std::string GetToken();
 
-  PrefetchInstanceIDProxy* proxy() { return proxy_.get(); }
-
- private:
+ protected:
   void GetTokenCompleted(const std::string& token, InstanceID::Result result);
 
   content::BrowserTaskEnvironment task_environment_;
   TestingProfile profile_;
-  std::unique_ptr<PrefetchInstanceIDProxy> proxy_;
 
   gcm::FakeGCMProfileService* gcm_profile_service_;
 
@@ -71,7 +69,6 @@ class PrefetchInstanceIDProxyTest : public testing::Test {
 
 void PrefetchInstanceIDProxyTest::SetUp() {
   scoped_feature_list_.InitAndEnableFeature(kPrefetchingOfflinePagesFeature);
-  proxy_ = std::make_unique<PrefetchInstanceIDProxy>(kAppIdForTest, &profile_);
   gcm_profile_service_ = static_cast<gcm::FakeGCMProfileService*>(
       gcm::GCMProfileServiceFactory::GetInstance()->SetTestingFactoryAndUse(
           &profile_, base::BindRepeating(&gcm::FakeGCMProfileService::Build)));
@@ -95,8 +92,9 @@ std::string PrefetchInstanceIDProxyTest::GetToken() {
   token_.clear();
   result_ = InstanceID::UNKNOWN_ERROR;
 
-  proxy()->GetGCMToken(base::Bind(
-      &PrefetchInstanceIDProxyTest::GetTokenCompleted, base::Unretained(this)));
+  GetGCMToken(&profile_, kAppIdForTest,
+              base::Bind(&PrefetchInstanceIDProxyTest::GetTokenCompleted,
+                         base::Unretained(this)));
   WaitForAsyncOperation();
   return token_;
 }

chrome/browser/offline_pages/prefetch/prefetch_instance_id_proxy.h

-// Copyright 2017 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 CHROME_BROWSER_OFFLINE_PAGES_PREFETCH_PREFETCH_INSTANCE_ID_PROXY_H_
-#define CHROME_BROWSER_OFFLINE_PAGES_PREFETCH_PREFETCH_INSTANCE_ID_PROXY_H_
-
-#include <string>
-
-#include "base/memory/ref_counted.h"
-#include "base/memory/weak_ptr.h"
-#include "components/gcm_driver/instance_id/instance_id.h"
-#include "components/offline_pages/core/prefetch/prefetch_gcm_app_handler.h"
-
-namespace content {
-class BrowserContext;
-}
-
-namespace offline_pages {
-
-// A factory that can create prefetching InstanceID tokens from a
-// BrowserContext, requesting the InstanceIDProfileService on demand.
-class PrefetchInstanceIDProxy : public PrefetchGCMAppHandler::TokenFactory {
- public:
-  PrefetchInstanceIDProxy(const std::string& app_id,
-                          content::BrowserContext* context);
-  ~PrefetchInstanceIDProxy() override;
-
-  // PrefetchGCMAppHandler::TokenFactory implementation.
-  void GetGCMToken(instance_id::InstanceID::GetTokenCallback callback) override;
-
- private:
-  void GotGCMToken(instance_id::InstanceID::GetTokenCallback callback,
-                   const std::string& token,
-                   instance_id::InstanceID::Result result);
-  std::string app_id_;
-  std::string token_;
-
-  // Unowned, the owner should make sure that this class does not outlive the
-  // browser context.
-  content::BrowserContext* context_;
-
-  base::WeakPtrFactory<PrefetchInstanceIDProxy> weak_factory_{this};
-
-  DISALLOW_COPY_AND_ASSIGN(PrefetchInstanceIDProxy);
-};
-
-}  // namespace offline_pages
-
-#endif  // CHROME_BROWSER_OFFLINE_PAGES_PREFETCH_PREFETCH_INSTANCE_ID_PROXY_H_

chrome/browser/offline_pages/prefetch/prefetch_service_factory.cc

@@ -20,9 +20,9 @@
 #include "chrome/browser/net/system_network_context_manager.h"
 #include "chrome/browser/ntp_snippets/content_suggestions_service_factory.h"
 #include "chrome/browser/offline_pages/offline_page_model_factory.h"
+#include "chrome/browser/offline_pages/prefetch/gcm_token.h"
 #include "chrome/browser/offline_pages/prefetch/offline_metrics_collector_impl.h"
 #include "chrome/browser/offline_pages/prefetch/prefetch_background_task_handler_impl.h"
-#include "chrome/browser/offline_pages/prefetch/prefetch_instance_id_proxy.h"
 #include "chrome/browser/offline_pages/prefetch/thumbnail_fetcher_impl.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_key.h"
@@ -72,10 +72,6 @@ void SwitchToFullBrowserImageFetcher(PrefetchServiceImpl* prefetch_service,
 }
 
 void OnProfileCreated(PrefetchServiceImpl* prefetch_service, Profile* profile) {
-  auto gcm_app_handler = std::make_unique<PrefetchGCMAppHandler>(
-      std::make_unique<PrefetchInstanceIDProxy>(kPrefetchingOfflinePagesAppId,
-                                                profile));
-  prefetch_service->SetPrefetchGCMHandler(std::move(gcm_app_handler));
   if (IsPrefetchingOfflinePagesEnabled()) {
     // Trigger an update of the cached GCM token. This needs to be post tasked
     // because otherwise leads to circular dependency between
@@ -86,8 +82,9 @@ void OnProfileCreated(PrefetchServiceImpl* prefetch_service, Profile* profile) {
     base::PostTask(
         FROM_HERE,
         {content::BrowserThread::UI, base::TaskPriority::BEST_EFFORT},
-        base::BindOnce(&PrefetchServiceImpl::RefreshGCMToken,
-                       prefetch_service->GetWeakPtr()));
+        base::BindOnce(&GetGCMToken, profile, kPrefetchingOfflinePagesAppId,
+                       base::BindOnce(&PrefetchServiceImpl::GCMTokenReceived,
+                                      prefetch_service->GetWeakPtr())));
   }
 
   SwitchToFullBrowserImageFetcher(prefetch_service, profile->GetProfileKey());
@@ -184,6 +181,7 @@ std::unique_ptr<KeyedService> PrefetchServiceFactory::BuildServiceInstanceFor(
       std::move(prefetch_network_request_factory), offline_page_model,
       std::move(prefetch_store), std::move(suggested_articles_observer),
       std::move(prefetch_downloader), std::move(prefetch_importer),
+      std::make_unique<PrefetchGCMAppHandler>(),
       std::move(prefetch_background_task_handler), std::move(thumbnail_fetcher),
       image_fetcher, profile_key->GetPrefs());
 

chrome/test/BUILD.gn

@@ -3599,7 +3599,7 @@ test("unit_tests") {
     sources += [
       "../browser/offline_pages/offline_page_request_handler_unittest.cc",
       "../browser/offline_pages/offline_page_utils_unittest.cc",
-      "../browser/offline_pages/prefetch/prefetch_instance_id_proxy_unittest.cc",
+      "../browser/offline_pages/prefetch/gcm_token_unittest.cc",
     ]
   }
 

components/offline_pages/core/prefetch/prefetch_gcm_app_handler.cc

@@ -14,21 +14,13 @@ namespace offline_pages {
 const char kPrefetchingOfflinePagesAppId[] =
     "com.google.chrome.OfflinePagePrefetch";
 
-PrefetchGCMAppHandler::PrefetchGCMAppHandler(
-    std::unique_ptr<TokenFactory> token_factory)
-    : token_factory_(std::move(token_factory)) {}
-
+PrefetchGCMAppHandler::PrefetchGCMAppHandler() {}
 PrefetchGCMAppHandler::~PrefetchGCMAppHandler() = default;
 
 void PrefetchGCMAppHandler::SetService(PrefetchService* service) {
   prefetch_service_ = service;
 }
 
-void PrefetchGCMAppHandler::GetGCMToken(
-    instance_id::InstanceID::GetTokenCallback callback) {
-  token_factory_->GetGCMToken(std::move(callback));
-}
-
 void PrefetchGCMAppHandler::ShutdownHandler() {
   NOTIMPLEMENTED();
 }

components/offline_pages/core/prefetch/prefetch_gcm_app_handler.h

@@ -22,15 +22,7 @@ extern const char kPrefetchingOfflinePagesAppId[];
 class PrefetchGCMAppHandler : public gcm::GCMAppHandler,
                               public PrefetchGCMHandler {
  public:
-  class TokenFactory {
-   public:
-    virtual ~TokenFactory() = default;
-
-    virtual void GetGCMToken(
-        instance_id::InstanceID::GetTokenCallback callback) = 0;
-  };
-
-  explicit PrefetchGCMAppHandler(std::unique_ptr<TokenFactory> token_factory);
+  explicit PrefetchGCMAppHandler();
   ~PrefetchGCMAppHandler() override;
 
   // gcm::GCMAppHandler implementation.
@@ -50,12 +42,10 @@ class PrefetchGCMAppHandler : public gcm::GCMAppHandler,
   void SetService(PrefetchService* service) override;
   gcm::GCMAppHandler* AsGCMAppHandler() override;
   std::string GetAppId() const override;
-  void GetGCMToken(instance_id::InstanceID::GetTokenCallback callback) override;
 
  private:
   // Not owned, PrefetchService owns |this.
-  PrefetchService* prefetch_service_;
-  std::unique_ptr<TokenFactory> token_factory_;
+  PrefetchService* prefetch_service_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(PrefetchGCMAppHandler);
 };

components/offline_pages/core/prefetch/prefetch_gcm_app_handler_unittest.cc

@@ -9,40 +9,20 @@
 #include "base/bind.h"
 #include "base/test/task_environment.h"
 #include "components/gcm_driver/instance_id/instance_id.h"
+#include "components/offline_pages/core/prefetch/prefetch_service_impl.h"
 #include "components/offline_pages/core/prefetch/prefetch_service_test_taco.h"
 #include "components/offline_pages/core/prefetch/test_prefetch_dispatcher.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace offline_pages {
 
-class TestTokenFactory : public PrefetchGCMAppHandler::TokenFactory {
- public:
-  TestTokenFactory() = default;
-  ~TestTokenFactory() override = default;
-
-  void GetGCMToken(
-      instance_id::InstanceID::GetTokenCallback callback) override {
-    std::move(callback).Run(token, result);
-  }
-
-  instance_id::InstanceID::Result result = instance_id::InstanceID::SUCCESS;
-  std::string token = "default_token";
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(TestTokenFactory);
-};
-
 class PrefetchGCMAppHandlerTest : public testing::Test {
  public:
   PrefetchGCMAppHandlerTest() {
     auto dispatcher = std::make_unique<TestPrefetchDispatcher>();
     test_dispatcher_ = dispatcher.get();
 
-    auto token_factory = std::make_unique<TestTokenFactory>();
-    token_factory_ = token_factory.get();
-
-    auto gcm_app_handler =
-        std::make_unique<PrefetchGCMAppHandler>(std::move(token_factory));
+    auto gcm_app_handler = std::make_unique<PrefetchGCMAppHandler>();
     handler_ = gcm_app_handler.get();
 
     prefetch_service_taco_.reset(new PrefetchServiceTestTaco);
@@ -59,7 +39,6 @@ class PrefetchGCMAppHandlerTest : public testing::Test {
 
   TestPrefetchDispatcher* dispatcher() { return test_dispatcher_; }
   PrefetchGCMAppHandler* handler() { return handler_; }
-  TestTokenFactory* token_factory() { return token_factory_; }
 
  private:
   base::test::SingleThreadTaskEnvironment task_environment_;
@@ -69,8 +48,6 @@ class PrefetchGCMAppHandlerTest : public testing::Test {
   TestPrefetchDispatcher* test_dispatcher_;
   // Owned by the taco.
   PrefetchGCMAppHandler* handler_;
-  // Owned by the PrefetchGCMAppHandler.
-  TestTokenFactory* token_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(PrefetchGCMAppHandlerTest);
 };
@@ -94,14 +71,4 @@ TEST_F(PrefetchGCMAppHandlerTest, TestInvalidMessage) {
   EXPECT_EQ(0U, dispatcher()->operation_list.size());
 }
 
-TEST_F(PrefetchGCMAppHandlerTest, TestGetToken) {
-  std::string result_token;
-
-  handler()->GetGCMToken(base::BindOnce(
-      [](std::string* result_token, const std::string& token,
-         instance_id::InstanceID::Result result) { *result_token = token; },
-      &result_token));
-  EXPECT_EQ(token_factory()->token, result_token);
-}
-
 }  // namespace offline_pages

components/offline_pages/core/prefetch/prefetch_gcm_handler.h

@@ -15,11 +15,9 @@ class GCMAppHandler;
 
 namespace offline_pages {
 
-class PrefetchGCMHandler;
 class PrefetchService;
 
-// Main class and entry point for the Offline Pages Prefetching feature, that
-// controls the lifetime of all major subcomponents of the prefetching system.
+// Provides a GCM interface for PrefetchService.
 class PrefetchGCMHandler {
  public:
   PrefetchGCMHandler() = default;
@@ -34,11 +32,6 @@ class PrefetchGCMHandler {
 
   // The app ID to register with at the GCM layer.
   virtual std::string GetAppId() const = 0;
-
-  // Gets a token suitable for sending to Offline Page Service for notifications
-  // when work is completed.
-  virtual void GetGCMToken(
-      instance_id::InstanceID::GetTokenCallback callback) = 0;
 };
 
 }  // namespace offline_pages

components/offline_pages/core/prefetch/prefetch_service_impl.cc

@@ -36,6 +36,7 @@ PrefetchServiceImpl::PrefetchServiceImpl(
     std::unique_ptr<SuggestedArticlesObserver> suggested_articles_observer,
     std::unique_ptr<PrefetchDownloader> prefetch_downloader,
     std::unique_ptr<PrefetchImporter> prefetch_importer,
+    std::unique_ptr<PrefetchGCMHandler> gcm_handler,
     std::unique_ptr<PrefetchBackgroundTaskHandler>
         prefetch_background_task_handler,
     std::unique_ptr<ThumbnailFetcher> thumbnail_fetcher,
@@ -48,6 +49,7 @@ PrefetchServiceImpl::PrefetchServiceImpl(
       prefetch_store_(std::move(prefetch_store)),
       prefetch_downloader_(std::move(prefetch_downloader)),
       prefetch_importer_(std::move(prefetch_importer)),
+      prefetch_gcm_handler_(std::move(gcm_handler)),
       prefetch_background_task_handler_(
           std::move(prefetch_background_task_handler)),
       prefs_(prefs),
@@ -56,6 +58,7 @@ PrefetchServiceImpl::PrefetchServiceImpl(
       image_fetcher_(image_fetcher) {
   prefetch_dispatcher_->SetService(this);
   prefetch_downloader_->SetPrefetchService(this);
+  prefetch_gcm_handler_->SetService(this);
   if (suggested_articles_observer_)
     suggested_articles_observer_->SetPrefetchService(this);
 }
@@ -84,13 +87,7 @@ std::string PrefetchServiceImpl::GetCachedGCMToken() const {
   return prefetch_prefs::GetCachedPrefetchGCMToken(prefs_);
 }
 
-void PrefetchServiceImpl::RefreshGCMToken() {
-  DCHECK(prefetch_gcm_handler_);
-  prefetch_gcm_handler_->GetGCMToken(base::AdaptCallbackForRepeating(
-      base::BindOnce(&PrefetchServiceImpl::OnGCMTokenReceived, GetWeakPtr())));
-}
-
-void PrefetchServiceImpl::OnGCMTokenReceived(
+void PrefetchServiceImpl::GCMTokenReceived(
     const std::string& gcm_token,
     instance_id::InstanceID::Result result) {
   // TODO(dimich): Add UMA reporting on instance_id::InstanceID::Result.
@@ -159,13 +156,6 @@ PrefetchGCMHandler* PrefetchServiceImpl::GetPrefetchGCMHandler() {
   return prefetch_gcm_handler_.get();
 }
 
-void PrefetchServiceImpl::SetPrefetchGCMHandler(
-    std::unique_ptr<PrefetchGCMHandler> handler) {
-  DCHECK(!prefetch_gcm_handler_);
-  prefetch_gcm_handler_ = std::move(handler);
-  prefetch_gcm_handler_->SetService(this);
-}
-
 PrefetchNetworkRequestFactory*
 PrefetchServiceImpl::GetPrefetchNetworkRequestFactory() {
   return network_request_factory_.get();

components/offline_pages/core/prefetch/prefetch_service_impl.h

@@ -31,6 +31,7 @@ class PrefetchServiceImpl : public PrefetchService {
       std::unique_ptr<SuggestedArticlesObserver> suggested_articles_observer,
       std::unique_ptr<PrefetchDownloader> prefetch_downloader,
       std::unique_ptr<PrefetchImporter> prefetch_importer,
+      std::unique_ptr<PrefetchGCMHandler> gcm_handler,
       std::unique_ptr<PrefetchBackgroundTaskHandler> background_task_handler,
       std::unique_ptr<ThumbnailFetcher> thumbnail_fetcher,
       image_fetcher::ImageFetcher* image_fetcher_,
@@ -62,8 +63,8 @@ class PrefetchServiceImpl : public PrefetchService {
   PrefetchImporter* GetPrefetchImporter() override;
   PrefetchBackgroundTaskHandler* GetPrefetchBackgroundTaskHandler() override;
 
-  void SetPrefetchGCMHandler(std::unique_ptr<PrefetchGCMHandler> handler);
-  void RefreshGCMToken();
+  void GCMTokenReceived(const std::string& gcm_token,
+                        instance_id::InstanceID::Result result);
 
   // Thumbnail fetchers. With Feed, GetImageFetcher() is available
   // and GetThumbnailFetcher() is null.
@@ -83,11 +84,8 @@ class PrefetchServiceImpl : public PrefetchService {
   void ReplaceImageFetcher(image_fetcher::ImageFetcher* image_fetcher);
 
  private:
-  void OnGCMTokenReceived(const std::string& gcm_token,
-                          instance_id::InstanceID::Result result);
 
   OfflineEventLogger logger_;
-  std::unique_ptr<PrefetchGCMHandler> prefetch_gcm_handler_;
 
   std::unique_ptr<OfflineMetricsCollector> offline_metrics_collector_;
   std::unique_ptr<PrefetchDispatcher> prefetch_dispatcher_;
@@ -96,6 +94,7 @@ class PrefetchServiceImpl : public PrefetchService {
   std::unique_ptr<PrefetchStore> prefetch_store_;
   std::unique_ptr<PrefetchDownloader> prefetch_downloader_;
   std::unique_ptr<PrefetchImporter> prefetch_importer_;
+  std::unique_ptr<PrefetchGCMHandler> prefetch_gcm_handler_;
   std::unique_ptr<PrefetchBackgroundTaskHandler>
       prefetch_background_task_handler_;
   PrefService* prefs_;

components/offline_pages/core/prefetch/prefetch_service_test_taco.cc

@@ -121,7 +121,6 @@ void PrefetchServiceTestTaco::SetPrefetchDispatcher(
 void PrefetchServiceTestTaco::SetPrefetchGCMHandler(
     std::unique_ptr<PrefetchGCMHandler> gcm_handler) {
   CHECK(!prefetch_service_);
-  CHECK(gcm_handler);
   gcm_handler_ = std::move(gcm_handler);
 }
 
@@ -199,10 +198,9 @@ void PrefetchServiceTestTaco::CreatePrefetchService() {
       std::move(network_request_factory_), offline_page_model_.get(),
       std::move(prefetch_store_), std::move(suggested_articles_observer_),
       std::move(prefetch_downloader_), std::move(prefetch_importer_),
-      std::move(prefetch_background_task_handler_),
+      std::move(gcm_handler_), std::move(prefetch_background_task_handler_),
       std::move(thumbnail_fetcher_), thumbnail_image_fetcher_.get(),
       pref_service_.get());
-  service->SetPrefetchGCMHandler(std::move(gcm_handler_));
   prefetch_service_ = std::move(service);
 }
 

components/offline_pages/core/prefetch/test_prefetch_gcm_handler.cc

@@ -5,9 +5,6 @@
 #include "components/offline_pages/core/prefetch/test_prefetch_gcm_handler.h"
 
 namespace offline_pages {
-namespace {
-const char kToken[] = "an_instance_id_token";
-}
 
 TestPrefetchGCMHandler::TestPrefetchGCMHandler() = default;
 TestPrefetchGCMHandler::~TestPrefetchGCMHandler() = default;
@@ -20,10 +17,5 @@ std::string TestPrefetchGCMHandler::GetAppId() const {
   return "com.google.test.PrefetchAppId";
 }
 
-void TestPrefetchGCMHandler::GetGCMToken(
-    instance_id::InstanceID::GetTokenCallback callback) {
-  std::move(callback).Run(kToken, instance_id::InstanceID::Result::SUCCESS);
-}
-
 void TestPrefetchGCMHandler::SetService(PrefetchService* service) {}
 }  // namespace offline_pages

components/offline_pages/core/prefetch/test_prefetch_gcm_handler.h

@@ -21,7 +21,6 @@ class TestPrefetchGCMHandler : public PrefetchGCMHandler {
 
   gcm::GCMAppHandler* AsGCMAppHandler() override;
   std::string GetAppId() const override;
-  void GetGCMToken(instance_id::InstanceID::GetTokenCallback callback) override;
   void SetService(PrefetchService* service) override;
 };