Make Web Push use InstanceID tokens instead of GCM registrations

chrome/browser/services/gcm/fake_gcm_profile_service.cc

 // Copyright 2013 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/services/gcm/fake_gcm_profile_service.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/profiles/profile.h"
 #include "components/gcm_driver/fake_gcm_client_factory.h"
-#include "components/gcm_driver/fake_gcm_driver.h"
-#include "components/gcm_driver/gcm_driver.h"
+#include "components/gcm_driver/instance_id/fake_gcm_driver_for_instance_id.h"
 #include "content/public/browser/browser_context.h"
 
 namespace gcm {
 
 namespace {
 
-class CustomFakeGCMDriver : public FakeGCMDriver {
+class CustomFakeGCMDriver : public instance_id::FakeGCMDriverForInstanceID {
  public:
   explicit CustomFakeGCMDriver(FakeGCMProfileService* service);
   ~CustomFakeGCMDriver() override;
 
   void OnRegisterFinished(const std::string& app_id,
                           const std::string& registration_id,
                           GCMClient::Result result);
   void OnUnregisterFinished(const std::string& app_id,
                             GCMClient::Result result);
   void OnSendFinished(const std::string& app_id,
                       const std::string& message_id,
                       GCMClient::Result result);
 
   void OnDispatchMessage(const std::string& app_id,
                          const IncomingMessage& message);
 
  protected:
-  // FakeGCMDriver overrides:
+  // FakeGCMDriverForInstanceID overrides:
   void RegisterImpl(const std::string& app_id,
                     const std::vector<std::string>& sender_ids) override;
   void UnregisterImpl(const std::string& app_id) override;
   void UnregisterWithSenderIdImpl(const std::string& app_id,
                                   const std::string& sender_id) override;
   void SendImpl(const std::string& app_id,
                 const std::string& receiver_id,
                 const OutgoingMessage& message) override;
 
  private:
   FakeGCMProfileService* service_;
 
   DISALLOW_COPY_AND_ASSIGN(CustomFakeGCMDriver);
 };
 
 CustomFakeGCMDriver::CustomFakeGCMDriver(FakeGCMProfileService* service)
-    : FakeGCMDriver(base::ThreadTaskRunnerHandle::Get()),
-      service_(service) {
-}
+    : instance_id::FakeGCMDriverForInstanceID(
+          base::ThreadTaskRunnerHandle::Get()),
+      service_(service) {}
 
 CustomFakeGCMDriver::~CustomFakeGCMDriver() {
 }
 
 void CustomFakeGCMDriver::RegisterImpl(
     const std::string& app_id,
     const std::vector<std::string>& sender_ids) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&FakeGCMProfileService::RegisterFinished,
                             base::Unretained(service_), app_id, sender_ids));
@@ skipping 121 matching lines @@
 }
 
 void FakeGCMProfileService::DispatchMessage(const std::string& app_id,
                                             const IncomingMessage& message) {
   CustomFakeGCMDriver* custom_driver =
       static_cast<CustomFakeGCMDriver*>(driver());
   custom_driver->OnDispatchMessage(app_id, message);
 }
 
 }  // namespace gcm