Define PushMessagingApplicationId and replace ad-hoc code.

chrome/browser/services/gcm/push_messaging_service_impl.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 "chrome/browser/services/gcm/push_messaging_service_impl.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_util.h"
 #include "chrome/browser/content_settings/permission_request_id.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/push_messaging_permission_context.h"
 #include "chrome/browser/services/gcm/push_messaging_permission_context_factory.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "components/gcm_driver/gcm_driver.h"
 #include "components/pref_registry/pref_registry_syncable.h"
+#include "content/public/browser/push_messaging_application_id.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 
 namespace gcm {
 
 namespace {
-const char kAppIdPrefix[] = "push:";
 const int kMaxRegistrations = 1000000;
 }  // namespace
 
 // static
 void PushMessagingServiceImpl::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterIntegerPref(
       prefs::kPushMessagingRegistrationCount,
       0,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
@@ skipping 16 matching lines @@
           0) {
     return;
   }
   // Create the GCMProfileService, and hence instantiate this class.
   GCMProfileService* gcm_service =
       gcm::GCMProfileServiceFactory::GetForProfile(profile);
   PushMessagingServiceImpl* push_service =
       static_cast<PushMessagingServiceImpl*>(
           gcm_service->push_messaging_service());
   // Register ourselves as an app handler.
-  gcm_service->driver()->AddAppHandler(kAppIdPrefix, push_service);
+  gcm_service->driver()->AddAppHandler(
+      content::kPushMessagingApplicationIdPrefix, push_service);
 }
 
 PushMessagingServiceImpl::PushMessagingServiceImpl(
     GCMProfileService* gcm_profile_service,
     Profile* profile)
     : gcm_profile_service_(gcm_profile_service),
       profile_(profile),
       weak_factory_(this) {
 }
 
 PushMessagingServiceImpl::~PushMessagingServiceImpl() {
   // TODO(johnme): If it's possible for this to be destroyed before GCMDriver,
   // then we should call RemoveAppHandler.
 }
 
 bool PushMessagingServiceImpl::CanHandle(const std::string& app_id) const {
-  // TODO(mvanouwerkerk): Finalize and centralize format of Push API app_id.
-  return StartsWithASCII(app_id, kAppIdPrefix, true);
+  return content::PushMessagingApplicationId::Parse(app_id).is_valid();
 }
 
 void PushMessagingServiceImpl::ShutdownHandler() {
   // TODO(johnme): Do any necessary cleanup.
 }
 
 void PushMessagingServiceImpl::OnMessage(
     const std::string& app_id,
     const GCMClient::IncomingMessage& message) {
   // The Push API only exposes a single string of data in the push event fired
   // on the Service Worker. When developers send messages using GCM to the Push
   // API, they must pass a single key-value pair, where the key is "data" and
   // the value is the string they want to be passed to their Service Worker.
   // For example, they could send the following JSON using the HTTPS GCM API:
   // {
   //     "registration_ids": ["FOO", "BAR"],
   //     "data": {
   //         "data": "BAZ",
   //     },
   //     "delay_while_idle": true,
   // }
   // TODO(johnme): Make sure this is clearly documented for developers.
+  content::PushMessagingApplicationId application_id =
+      content::PushMessagingApplicationId::Parse(app_id);
+  DCHECK(application_id.is_valid());
   GCMClient::MessageData::const_iterator it = message.data.find("data");
-  if (it != message.data.end()) {
+  if (application_id.is_valid() && it != message.data.end()) {
     const std::string& data ALLOW_UNUSED = it->second;
     // TODO(mvanouwerkerk): Fire push event with data on the Service Worker
     // corresponding to app_id (and remove ALLOW_UNUSED above).
   } else {
     // Drop the message, as it is invalid.
     // TODO(mvanouwerkerk): Show a warning in the developer console of the
     // Service Worker corresponding to app_id.
     // TODO(johnme): Add diagnostic observers (e.g. UMA and an internals page)
     // to know when bad things happen.
   }
@@ skipping 26 matching lines @@
     RegisterEnd(
         app_id,
         callback,
         std::string(),
         content::PUSH_MESSAGING_STATUS_REGISTRATION_FAILED_LIMIT_REACHED);
     return;
   }
 
   // If this is registering for the first time then the driver does not have
   // this as an app handler and registration would fail.
-  if (gcm_profile_service_->driver()->GetAppHandler(kAppIdPrefix) != this)
-    gcm_profile_service_->driver()->AddAppHandler(kAppIdPrefix, this);
+  if (gcm_profile_service_->driver()->GetAppHandler(
+          content::kPushMessagingApplicationIdPrefix) != this)
+    gcm_profile_service_->driver()->AddAppHandler(
+        content::kPushMessagingApplicationIdPrefix, this);
 
   content::RenderFrameHost* render_frame_host =
       content::RenderFrameHost::FromID(renderer_id, render_frame_id);
 
   // The frame doesn't exist any more, or we received a bad frame id.
   if (!render_frame_host)
     return;
 
   content::WebContents* web_contents =
       content::WebContents::FromRenderFrameHost(render_frame_host);
@@ skipping 88 matching lines @@
       base::Bind(&PushMessagingServiceImpl::DidRegister,
                  weak_factory_.GetWeakPtr(),
                  app_id,
                  register_callback));
 }
 
 // TODO(johnme): Unregister should decrement the pref, and call
 // RemoveAppHandler if the count drops to zero.
 
 }  // namespace gcm