[GCM] Move the manifest key checking logic to gcm.register function

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>
 
@@ skipping 13 matching lines @@
 
 const size_t kMaximumMessageSize = 4096;  // in bytes.
 const char kCollapseKey[] = "collapse_key";
 const char kGoogDotRestrictedPrefix[] = "goog.";
 const char kGoogleRestrictedPrefix[] = "google";
 
 // Error messages.
 const char kInvalidParameter[] =
     "Function was called with invalid parameters.";
 const char kNotSignedIn[] = "Profile was not signed in.";
+const char kCertificateMissing[] = "Manifest key was missing.";
 const char kAsyncOperationPending[] =
     "Asynchronous operation is pending.";
 const char kNetworkError[] = "Network error occurred.";
 const char kServerError[] = "Server error occurred.";
 const char kTtlExceeded[] = "Time-to-live exceeded.";
 const char kUnknownError[] = "Unknown error occurred.";
 
 std::string SHA1HashHexString(const std::string& str) {
   std::string hash = base::SHA1HashString(str);
   return base::HexEncode(hash.data(), hash.size());
 }
 
 const char* GcmResultToError(gcm::GCMClient::Result result) {
   switch (result) {
     case gcm::GCMClient::SUCCESS:
       return "";
     case gcm::GCMClient::INVALID_PARAMETER:
       return kInvalidParameter;
     case gcm::GCMClient::NOT_SIGNED_IN:
       return kNotSignedIn;
+    case gcm::GCMClient::CERTIFICATE_MISSING:
+      return kCertificateMissing;
     case gcm::GCMClient::ASYNC_OPERATION_PENDING:
       return kAsyncOperationPending;
     case gcm::GCMClient::NETWORK_ERROR:
       return kNetworkError;
     case gcm::GCMClient::SERVER_ERROR:
       return kServerError;
     case gcm::GCMClient::TTL_EXCEEDED:
       return kTtlExceeded;
     case gcm::GCMClient::UNKNOWN_ERROR:
       return kUnknownError;
@@ skipping 24 matching lines @@
 
 bool GcmApiFunction::RunImpl() {
   if (!IsGcmApiEnabled())
     return false;
 
   return DoWork();
 }
 
 bool GcmApiFunction::IsGcmApiEnabled() const {
   return gcm::GCMProfileService::IsGCMEnabled(
-             Profile::FromBrowserContext(context())) &&
-         !GetExtension()->public_key().empty();
+             Profile::FromBrowserContext(context()));
 }
 
 gcm::GCMProfileService* GcmApiFunction::GCMProfileService() const {
   return gcm::GCMProfileServiceFactory::GetForProfile(
       Profile::FromBrowserContext(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());
 
+  if (GetExtension()->public_key().empty()) {
+    CompleteFunctionWithResult(std::string(),
+                               gcm::GCMClient::CERTIFICATE_MISSING);
+    return false;
+  }
+
   GCMProfileService()->Register(
       GetExtension()->id(),
       params->sender_ids,
       SHA1HashHexString(GetExtension()->public_key()),
       base::Bind(&GcmRegisterFunction::CompleteFunctionWithResult, this));
 
   return true;
 }
 
 void GcmRegisterFunction::CompleteFunctionWithResult(
@@ skipping 91 matching lines @@
 
   scoped_ptr<Event> event(new Event(
       api::gcm::OnSendError::kEventName,
       api::gcm::OnSendError::Create(error).Pass(),
       profile_));
   ExtensionSystem::Get(profile_)->event_router()->DispatchEventToExtension(
       app_id, event.Pass());
 }
 
 }  // namespace extensions