Add support for GCM subtypes to desktop Instance ID implementation

components/gcm_driver/registration_info.cc

 // Copyright 2015 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 "components/gcm_driver/registration_info.h"
 
 #include <stddef.h>
 
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 
 namespace gcm {
 
 namespace {
-const char kInsanceIDSerializationPrefix[] = "iid-";
-const int kInsanceIDSerializationPrefixLength =
-    sizeof(kInsanceIDSerializationPrefix) / sizeof(char) - 1;
+const char kInstanceIDSerializationPrefix[] = "iid-";
+const int kInstanceIDSerializationPrefixLength =
+    sizeof(kInstanceIDSerializationPrefix) / sizeof(char) - 1;
+
+const char kInstanceIDUseSubtypePrefix[] = "use_subtype,";
+const int kInstanceIDUseSubtypePrefixLength =
+    sizeof(kInstanceIDUseSubtypePrefix) / sizeof(char) - 1;
 }  // namespace
 
 // static
 std::unique_ptr<RegistrationInfo> RegistrationInfo::BuildFromString(
     const std::string& serialized_key,
     const std::string& serialized_value,
     std::string* registration_id) {
   std::unique_ptr<RegistrationInfo> registration;
 
-  if (base::StartsWith(serialized_key, kInsanceIDSerializationPrefix,
+  if (base::StartsWith(serialized_key, kInstanceIDSerializationPrefix,
                        base::CompareCase::SENSITIVE))
     registration.reset(new InstanceIDTokenInfo);
   else
     registration.reset(new GCMRegistrationInfo);
 
   if (!registration->Deserialize(serialized_key,
                                  serialized_value,
                                  registration_id)) {
     registration.reset();
   }
@@ skipping 113 matching lines @@
 }
 
 InstanceIDTokenInfo::~InstanceIDTokenInfo() {
 }
 
 RegistrationInfo::RegistrationType InstanceIDTokenInfo::GetType() const {
   return INSTANCE_ID_TOKEN;
 }
 
 std::string InstanceIDTokenInfo::GetSerializedKey() const {
-  DCHECK(authorized_entity.find(',') == std::string::npos &&
+  DCHECK(app_id.find(',') == std::string::npos &&
+         authorized_entity.find(',') == std::string::npos &&
          scope.find(',') == std::string::npos);
 
   // Multiple registrations are supported for Instance ID. So the key is based
   // on the combination of (app_id, authorized_entity, scope).
 
   // Adds a prefix to differentiate easily with GCM registration key.
-  std::string key(kInsanceIDSerializationPrefix);
+  std::string key(kInstanceIDSerializationPrefix);
   key += app_id;
   key += ",";
   key += authorized_entity;
   key += ",";
   key += scope;
   return key;
 }
 
 std::string InstanceIDTokenInfo::GetSerializedValue(
     const std::string& registration_id) const {
-  return registration_id;
+  DCHECK(!base::StartsWith(registration_id, kInstanceIDUseSubtypePrefix,
+                           base::CompareCase::SENSITIVE));
+  return (use_subtype ? kInstanceIDUseSubtypePrefix : std::string()) +
+         registration_id;
 }
 
 bool InstanceIDTokenInfo::Deserialize(
     const std::string& serialized_key,
     const std::string& serialized_value,
     std::string* registration_id) {
   if (serialized_key.empty() || serialized_value.empty())
     return false;
 
-  if (!base::StartsWith(serialized_key, kInsanceIDSerializationPrefix,
+  if (!base::StartsWith(serialized_key, kInstanceIDSerializationPrefix,
                         base::CompareCase::SENSITIVE))
     return false;
 
   std::vector<std::string> fields = base::SplitString(
-      serialized_key.substr(kInsanceIDSerializationPrefixLength),
-      ",", base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
+      serialized_key.substr(kInstanceIDSerializationPrefixLength), ",",
+      base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
   if (fields.size() != 3 || fields[0].empty() ||
       fields[1].empty() || fields[2].empty()) {
     return false;
   }
   app_id = fields[0];
   authorized_entity = fields[1];
   scope = fields[2];
 
-  // Registration ID is same as the serialized value;
-  if (registration_id)
-    *registration_id = serialized_value;
+  // Serialized value is registration ID, with a prefix if |use_subtype|.
+  use_subtype = base::StartsWith(serialized_value, kInstanceIDUseSubtypePrefix,
+                                 base::CompareCase::SENSITIVE);
+  if (registration_id) {
+    *registration_id =
+        use_subtype ? serialized_value.substr(kInstanceIDUseSubtypePrefixLength)
+                    : serialized_value;
+  }
 
   return true;
 }
 
 bool RegistrationInfoComparer::operator()(
     const linked_ptr<RegistrationInfo>& a,
     const linked_ptr<RegistrationInfo>& b) const {
   DCHECK(a.get() && b.get());
 
   // For GCMRegistrationInfo, the comparison is based on app_id only.
-  // For InstanceIDTokenInfo, the comparison is bsaed on
+  // For InstanceIDTokenInfo, the comparison is based on
   // <app_id, authorized_entity, scope>.
   if (a->app_id < b->app_id)
     return true;
   if (a->app_id > b->app_id)
     return false;
 
   InstanceIDTokenInfo* iid_a =
       InstanceIDTokenInfo::FromRegistrationInfo(a.get());
   InstanceIDTokenInfo* iid_b =
     InstanceIDTokenInfo::FromRegistrationInfo(b.get());
@@ skipping 19 matching lines @@
 bool ExistsGCMRegistrationInMap(const RegistrationInfoMap& map,
                                 const std::string& app_id) {
   std::unique_ptr<GCMRegistrationInfo> gcm_registration(
       new GCMRegistrationInfo);
   gcm_registration->app_id = app_id;
   return map.count(
       make_linked_ptr<RegistrationInfo>(gcm_registration.release())) > 0;
 }
 
 }  // namespace gcm