Extract Profile-independent GCMService from GCMProfileService

chrome/browser/invalidation/gcm_invalidation_bridge.cc

 // Copyright 2014 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 "base/bind.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/browser/invalidation/gcm_invalidation_bridge.h"
-#include "chrome/browser/services/gcm/gcm_profile_service.h"
+#include "chrome/browser/services/gcm/gcm_service.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "google_apis/gaia/identity_provider.h"
 
 namespace invalidation {
 namespace {
 // For 3rd party developers SenderId should come from application dashboard when
@@ skipping 120 matching lines @@
 }
 
 void GCMInvalidationBridge::Core::OnIncomingMessage(
     const std::string& message,
     const std::string& echo_token) {
   DCHECK(!message_callback_.is_null());
   message_callback_.Run(message, echo_token);
 }
 
 GCMInvalidationBridge::GCMInvalidationBridge(
-    gcm::GCMProfileService* gcm_profile_service,
+    gcm::GCMService* gcm_service,
     IdentityProvider* identity_provider)
     : OAuth2TokenService::Consumer("gcm_network_channel"),
-      gcm_profile_service_(gcm_profile_service),
+      gcm_service_(gcm_service),
       identity_provider_(identity_provider),
       subscribed_for_incoming_messages_(false),
       weak_factory_(this) {}
 
 GCMInvalidationBridge::~GCMInvalidationBridge() {
   if (subscribed_for_incoming_messages_)
-    gcm_profile_service_->RemoveAppHandler(kInvalidationsAppId);
+    gcm_service_->RemoveAppHandler(kInvalidationsAppId);
 }
 
 scoped_ptr<syncer::GCMNetworkChannelDelegate>
 GCMInvalidationBridge::CreateDelegate() {
   DCHECK(CalledOnValidThread());
   scoped_ptr<syncer::GCMNetworkChannelDelegate> core(new Core(
       weak_factory_.GetWeakPtr(), base::ThreadTaskRunnerHandle::Get()));
   return core.Pass();
 }
 
@@ skipping 65 matching lines @@
   OAuth2TokenService::ScopeSet scopes;
   scopes.insert(GaiaConstants::kChromeSyncOAuth2Scope);
   identity_provider_->GetTokenService()->InvalidateToken(
       identity_provider_->GetActiveAccountId(), scopes, token);
 }
 
 void GCMInvalidationBridge::Register(
     syncer::GCMNetworkChannelDelegate::RegisterCallback callback) {
   DCHECK(CalledOnValidThread());
   // No-op if GCMClient is disabled.
-  if (gcm_profile_service_ == NULL)
+  if (gcm_service_ == NULL)
     return;
 
   std::vector<std::string> sender_ids;
   sender_ids.push_back(kInvalidationsSenderId);
-  gcm_profile_service_->Register(
-      kInvalidationsAppId,
-      sender_ids,
-      base::Bind(&GCMInvalidationBridge::RegisterFinished,
-                 weak_factory_.GetWeakPtr(),
-                 callback));
+  gcm_service_->Register(kInvalidationsAppId,
+                         sender_ids,
+                         base::Bind(&GCMInvalidationBridge::RegisterFinished,
+                                    weak_factory_.GetWeakPtr(),
+                                    callback));
 }
 
 void GCMInvalidationBridge::RegisterFinished(
     syncer::GCMNetworkChannelDelegate::RegisterCallback callback,
     const std::string& registration_id,
     gcm::GCMClient::Result result) {
   DCHECK(CalledOnValidThread());
   core_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&GCMInvalidationBridge::Core::RegisterFinished,
                  core_,
                  callback,
                  registration_id,
                  result));
 }
 
 void GCMInvalidationBridge::SubscribeForIncomingMessages() {
   // No-op if GCMClient is disabled.
-  if (gcm_profile_service_ == NULL)
+  if (gcm_service_ == NULL)
     return;
 
   DCHECK(!subscribed_for_incoming_messages_);
-  gcm_profile_service_->AddAppHandler(kInvalidationsAppId, this);
+  gcm_service_->AddAppHandler(kInvalidationsAppId, this);
   subscribed_for_incoming_messages_ = true;
 }
 
 void GCMInvalidationBridge::ShutdownHandler() {
   // Nothing to do.
 }
 
 void GCMInvalidationBridge::OnMessage(
     const std::string& app_id,
     const gcm::GCMClient::IncomingMessage& message) {
@@ skipping 22 matching lines @@
 }
 
 void GCMInvalidationBridge::OnSendError(
     const std::string& app_id,
     const gcm::GCMClient::SendErrorDetails& send_error_details) {
   // cacheinvalidation doesn't send messages over GCM.
   NOTREACHED();
 }
 
 }  // namespace invalidation