Split GCMDriver into platform-specific implementations

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 "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.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 "content/public/browser/browser_context.h"
 
 namespace gcm {
 
 namespace {
 
-class FakeGCMDriver : public GCMDriver {
+class CustomFakeGCMDriver : public FakeGCMDriver {
  public:
-  explicit FakeGCMDriver(FakeGCMProfileService* service);
-  virtual ~FakeGCMDriver();
+  explicit CustomFakeGCMDriver(FakeGCMProfileService* service);
+  virtual ~CustomFakeGCMDriver();
 
-  // GCMDriver overrides.
-  virtual void Shutdown() OVERRIDE;
-  virtual void AddAppHandler(const std::string& app_id,
-                             GCMAppHandler* handler) OVERRIDE;
-  virtual void RemoveAppHandler(const std::string& app_id) OVERRIDE;
+  // GCMDriver overrides:
   virtual void Register(const std::string& app_id,
                         const std::vector<std::string>& sender_ids,
                         const RegisterCallback& callback) OVERRIDE;
   virtual void Unregister(const std::string& app_id,
                           const UnregisterCallback& callback) OVERRIDE;
   virtual void Send(const std::string& app_id,
                     const std::string& receiver_id,
                     const GCMClient::OutgoingMessage& message,
                     const SendCallback& callback) OVERRIDE;
 
  private:
   FakeGCMProfileService* service_;
 
-  DISALLOW_COPY_AND_ASSIGN(FakeGCMDriver);
+  DISALLOW_COPY_AND_ASSIGN(CustomFakeGCMDriver);
 };
 
-FakeGCMDriver::FakeGCMDriver(FakeGCMProfileService* service)
+CustomFakeGCMDriver::CustomFakeGCMDriver(FakeGCMProfileService* service)
     : service_(service) {
 }
 
-FakeGCMDriver::~FakeGCMDriver() {
+CustomFakeGCMDriver::~CustomFakeGCMDriver() {
 }
 
-void FakeGCMDriver::Shutdown() {
-}
-
-void FakeGCMDriver::AddAppHandler(const std::string& app_id,
-                                  GCMAppHandler* handler) {
-}
-
-void FakeGCMDriver::RemoveAppHandler(const std::string& app_id) {
-}
-
-void FakeGCMDriver::Register(const std::string& app_id,
+void CustomFakeGCMDriver::Register(const std::string& app_id,
                              const std::vector<std::string>& sender_ids,
                              const RegisterCallback& callback) {
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&FakeGCMProfileService::RegisterFinished,
                  base::Unretained(service_),
                  app_id,
                  sender_ids,
                  callback));
 }
 
-void FakeGCMDriver::Unregister(const std::string& app_id,
+void CustomFakeGCMDriver::Unregister(const std::string& app_id,
                                const UnregisterCallback& callback) {
   base::MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(
           &FakeGCMProfileService::UnregisterFinished,
           base::Unretained(service_),
           app_id,
           callback));
 }
 
-void FakeGCMDriver::Send(const std::string& app_id,
+void CustomFakeGCMDriver::Send(const std::string& app_id,
                          const std::string& receiver_id,
                          const GCMClient::OutgoingMessage& message,
                          const SendCallback& callback) {
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&FakeGCMProfileService::SendFinished,
                  base::Unretained(service_),
                  app_id,
                  receiver_id,
                  message,
                  callback));
 }
 
 }  // namespace
 
 // static
 KeyedService* FakeGCMProfileService::Build(content::BrowserContext* context) {
   Profile* profile = static_cast<Profile*>(context);
   FakeGCMProfileService* service = new FakeGCMProfileService(profile);
-  service->SetDriverForTesting(new FakeGCMDriver(service));
+  service->SetDriverForTesting(new CustomFakeGCMDriver(service));
   return service;
 }
 
 FakeGCMProfileService::FakeGCMProfileService(Profile* profile)
     : collect_(false) {}
 
 FakeGCMProfileService::~FakeGCMProfileService() {}
 
 void FakeGCMProfileService::RegisterFinished(
     const std::string& app_id,
@@ skipping 31 matching lines @@
 
   callback.Run(message.id, GCMClient::SUCCESS);
 }
 
 void FakeGCMProfileService::AddExpectedUnregisterResponse(
     GCMClient::Result result) {
   unregister_responses_.push_back(result);
 }
 
 }  // namespace gcm