Extract Profile-independent GCMService from GCMProfileService

chrome/browser/extensions/api/gcm/gcm_api.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/extensions/api/gcm/gcm_api.h"
 
 #include <algorithm>
 #include <map>
 #include <vector>
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/services/gcm/gcm_profile_service.h"
 #include "chrome/browser/services/gcm/gcm_profile_service_factory.h"
+#include "chrome/browser/services/gcm/gcm_service.h"
 #include "chrome/common/extensions/api/gcm.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/extension.h"
 
 namespace {
 
 const size_t kMaximumMessageSize = 4096;  // in bytes.
 const char kCollapseKey[] = "collapse_key";
 const char kGoogDotRestrictedPrefix[] = "goog.";
 const char kGoogleRestrictedPrefix[] = "google";
@@ skipping 63 matching lines @@
   Profile* profile = Profile::FromBrowserContext(browser_context());
 
   // GCM is not supported in incognito mode.
   if (profile->IsOffTheRecord())
     return false;
 
   return gcm::GCMProfileService::GetGCMEnabledState(profile) !=
       gcm::GCMProfileService::ALWAYS_DISABLED;
 }
 
-gcm::GCMProfileService* GcmApiFunction::GCMProfileService() const {
+gcm::GCMService* GcmApiFunction::GCMService() const {

[jianli, 2014/04/17 00:33:19]

GCMProfileServiceFactory::GetForProfile returns GCMProfileService. There is no
need to convert it to GCMService. Since gcm API is tied with a profile, we might
call certain GCMProfileService's functionality from here in the future.

[bartfab (slow), 2014/04/17 14:20:01]

Done.

   return gcm::GCMProfileServiceFactory::GetForProfile(
       Profile::FromBrowserContext(browser_context()));
 }
 
 GcmRegisterFunction::GcmRegisterFunction() {}
 
 GcmRegisterFunction::~GcmRegisterFunction() {}
 
 bool GcmRegisterFunction::DoWork() {
   scoped_ptr<api::gcm::Register::Params> params(
       api::gcm::Register::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
-  GCMProfileService()->Register(
+  GCMService()->Register(
       GetExtension()->id(),
       params->sender_ids,
       base::Bind(&GcmRegisterFunction::CompleteFunctionWithResult, this));
 
   return true;
 }
 
 void GcmRegisterFunction::CompleteFunctionWithResult(
     const std::string& registration_id,
     gcm::GCMClient::Result result) {
   SetResult(new base::StringValue(registration_id));
   SetError(GcmResultToError(result));
   SendResponse(gcm::GCMClient::SUCCESS == result);
 }
 
 GcmUnregisterFunction::GcmUnregisterFunction() {}
 
 GcmUnregisterFunction::~GcmUnregisterFunction() {}
 
 bool GcmUnregisterFunction::DoWork() {
-  GCMProfileService()->Unregister(
+  GCMService()->Unregister(
       GetExtension()->id(),
       base::Bind(&GcmUnregisterFunction::CompleteFunctionWithResult, this));
 
   return true;
 }
 
 void GcmUnregisterFunction::CompleteFunctionWithResult(
     gcm::GCMClient::Result result) {
   SetError(GcmResultToError(result));
   SendResponse(gcm::GCMClient::SUCCESS == result);
 }
 
 GcmSendFunction::GcmSendFunction() {}
 
 GcmSendFunction::~GcmSendFunction() {}
 
 bool GcmSendFunction::DoWork() {
   scoped_ptr<api::gcm::Send::Params> params(
       api::gcm::Send::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   EXTENSION_FUNCTION_VALIDATE(
       ValidateMessageData(params->message.data.additional_properties));
 
   gcm::GCMClient::OutgoingMessage outgoing_message;
   outgoing_message.id = params->message.message_id;
   outgoing_message.data = params->message.data.additional_properties;
   if (params->message.time_to_live.get())
     outgoing_message.time_to_live = *params->message.time_to_live;
 
-  GCMProfileService()->Send(
+  GCMService()->Send(
       GetExtension()->id(),
       params->message.destination_id,
       outgoing_message,
       base::Bind(&GcmSendFunction::CompleteFunctionWithResult, this));
 
   return true;
 }
 
 void GcmSendFunction::CompleteFunctionWithResult(
     const std::string& message_id,
@@ skipping 79 matching lines @@
 
 void GcmJsEventRouter::OnListenerAdded(const EventListenerInfo& details) {
   if (gcm::GCMProfileService::GetGCMEnabledState(profile_) ==
       gcm::GCMProfileService::ALWAYS_DISABLED) {
     return;
   }
   gcm::GCMProfileServiceFactory::GetForProfile(profile_)->Start();
 }
 
 }  // namespace extensions