[GCM] API update to allow only a single sender in registration

chrome/browser/services/gcm/gcm_profile_service.cc

 // Copyright (c) 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/services/gcm/gcm_profile_service.h"
 
 #include <string>
 #include <vector>
 
 #include "base/base64.h"
@@ skipping 28 matching lines @@
 #include "google_apis/gcm/protocol/android_checkin.pb.h"
 #include "net/url_request/url_request_context_getter.h"
 
 using extensions::Extension;
 
 namespace gcm {
 
 namespace {
 
 const char kRegistrationKey[] = "gcm.registration";
-const char kSendersKey[] = "senders";
+const char kSenderKey[] = "sender";
 const char kRegistrationIDKey[] = "reg_id";
 
 checkin_proto::ChromeBuildProto_Platform GetPlatform() {
 #if defined(OS_WIN)
   return checkin_proto::ChromeBuildProto_Platform_PLATFORM_WIN;
 #elif defined(OS_MACOSX)
   return checkin_proto::ChromeBuildProto_Platform_PLATFORM_MAC;
 #elif defined(OS_CHROMEOS)
   return checkin_proto::ChromeBuildProto_Platform_PLATFORM_CROS;
 #elif defined(OS_LINUX)
@@ skipping 200 matching lines @@
   // Called on IO thread.
   void Initialize(scoped_ptr<GCMClientFactory> gcm_client_factory,
                   const base::FilePath& store_path,
                   const std::vector<std::string>& account_ids,
                   const scoped_refptr<net::URLRequestContextGetter>&
                       url_request_context_getter);
   void Reset();
   void Load(const base::WeakPtr<GCMProfileService>& service);
   void CheckOut();
   void Register(const std::string& app_id,
-                const std::vector<std::string>& sender_ids,
+                const std::string& sender_id,
                 const std::string& cert);
   void Unregister(const std::string& app_id);
   void Send(const std::string& app_id,
             const std::string& receiver_id,
             const GCMClient::OutgoingMessage& message);
 
   // For testing purpose. Can be called from UI thread. Use with care.
   GCMClient* gcm_client_for_testing() const { return gcm_client_.get(); }
 
  private:
@@ skipping 149 matching lines @@
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 
   gcm_client_->CheckOut();
 
   // Note that we still need to keep GCMClient instance alive since the profile
   // might be signed in again.
 }
 
 void GCMProfileService::IOWorker::Register(
     const std::string& app_id,
-    const std::vector<std::string>& sender_ids,
+    const std::string& sender_id,
     const std::string& cert) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 
-  gcm_client_->Register(app_id, cert, sender_ids);
+  gcm_client_->Register(app_id, cert, sender_id);
 }
 
 void GCMProfileService::IOWorker::Unregister(const std::string& app_id) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 
   gcm_client_->Unregister(app_id);
 }
 
 void GCMProfileService::IOWorker::Send(
     const std::string& app_id,
     const std::string& receiver_id,
     const GCMClient::OutgoingMessage& message) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 
   gcm_client_->Send(app_id, receiver_id, message);
 }
 
 GCMProfileService::RegistrationInfo::RegistrationInfo() {
 }
 
 GCMProfileService::RegistrationInfo::~RegistrationInfo() {
 }
 
 bool GCMProfileService::RegistrationInfo::IsValid() const {
-  return !sender_ids.empty() && !registration_id.empty();
+  return !sender_id.empty() && !registration_id.empty();
 }
 
 // static
 GCMProfileService::GCMEnabledState GCMProfileService::GetGCMEnabledState(
     Profile* profile) {
   const base::Value* gcm_enabled_value =
       profile->GetPrefs()->GetUserPrefValue(prefs::kGCMChannelEnabled);
   if (!gcm_enabled_value)
     return ENABLED_FOR_APPS;
 
@@ skipping 73 matching lines @@
                  account_ids,
                  url_request_context_getter));
 
   // Load from the GCM store and initiate the GCM check-in if the rollout signal
   // indicates yes.
   if (GetGCMEnabledState(profile_) == ALWAYS_ENABLED)
     EnsureLoaded();
 }
 
 void GCMProfileService::Register(const std::string& app_id,
-                                 const std::vector<std::string>& sender_ids,
+                                 const std::string& sender_id,
                                  const std::string& cert,
                                  RegisterCallback callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  DCHECK(!app_id.empty() && !sender_ids.empty() && !callback.is_null());
+  DCHECK(!app_id.empty() && !sender_id.empty() && !callback.is_null());
 
   // Ensure that check-in has been done.
   EnsureLoaded();
 
   // If the profile was not signed in, bail out.
   if (username_.empty()) {
     callback.Run(std::string(), GCMClient::NOT_SIGNED_IN);
     return;
   }
 
   // If previous register operation is still in progress, bail out.
   if (register_callbacks_.find(app_id) != register_callbacks_.end()) {
     callback.Run(std::string(), GCMClient::ASYNC_OPERATION_PENDING);
     return;
   }
 
   register_callbacks_[app_id] = callback;
 
   EnsureAppReady(app_id);
 
   // Delay the register operation until GCMClient is ready.
   if (!delayed_task_controller_->CanRunTaskWithoutDelay(app_id)) {
     delayed_task_controller_->AddTask(
         app_id,
         base::Bind(&GCMProfileService::DoRegister,
                    weak_ptr_factory_.GetWeakPtr(),
                    app_id,
-                   sender_ids,
+                   sender_id,
                    cert));
     return;
   }
 
-  DoRegister(app_id, sender_ids, cert);
+  DoRegister(app_id, sender_id, cert);
 }
 
 void GCMProfileService::DoRegister(const std::string& app_id,
-                                   const std::vector<std::string>& sender_ids,
+                                   const std::string& sender_id,
                                    const std::string& cert) {
   std::map<std::string, RegisterCallback>::iterator callback_iter =
       register_callbacks_.find(app_id);
   if (callback_iter == register_callbacks_.end()) {
     // The callback could have been removed when the app is uninstalled.
     return;
   }
 
-  // Normalize the sender IDs by making them sorted.
-  std::vector<std::string> normalized_sender_ids = sender_ids;
-  std::sort(normalized_sender_ids.begin(), normalized_sender_ids.end());
-
   // If the same sender ids is provided, return the cached registration ID
   // directly.
   RegistrationInfoMap::const_iterator registration_info_iter =
       registration_info_map_.find(app_id);
   if (registration_info_iter != registration_info_map_.end() &&
-      registration_info_iter->second.sender_ids == normalized_sender_ids) {
+      registration_info_iter->second.sender_id == sender_id) {
     RegisterCallback callback = callback_iter->second;
     register_callbacks_.erase(callback_iter);
     callback.Run(registration_info_iter->second.registration_id,
                  GCMClient::SUCCESS);
     return;
   }
 
   // Cache the sender IDs. The registration ID will be filled when the
   // registration completes.
   RegistrationInfo registration_info;
-  registration_info.sender_ids = normalized_sender_ids;
+  registration_info.sender_id = sender_id;
   registration_info_map_[app_id] = registration_info;
 
   // Save the IDs of all registered apps such that we know what to remove from
   // the the app's state store when the profile is signed out.
   WriteRegisteredAppIDs();
 
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(&GCMProfileService::IOWorker::Register,
                  io_worker_,
                  app_id,
-                 normalized_sender_ids,
+                 sender_id,
                  cert));
 }
 
 void GCMProfileService::Send(const std::string& app_id,
                              const std::string& receiver_id,
                              const GCMClient::OutgoingMessage& message,
                              SendCallback callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   DCHECK(!app_id.empty() && !receiver_id.empty() && !callback.is_null());
 
@@ skipping 332 matching lines @@
 
 void GCMProfileService::WriteRegistrationInfo(const std::string& app_id) {
   extensions::StateStore* storage =
       extensions::ExtensionSystem::Get(profile_)->state_store();
   DCHECK(storage);
 
   RegistrationInfoMap::const_iterator registration_info_iter =
       registration_info_map_.find(app_id);
   if (registration_info_iter == registration_info_map_.end())
     return;
+
   const RegistrationInfo& registration_info = registration_info_iter->second;
-
-  scoped_ptr<base::ListValue> senders_list(new base::ListValue());
-  for (std::vector<std::string>::const_iterator senders_iter =
-           registration_info.sender_ids.begin();
-       senders_iter != registration_info.sender_ids.end();
-       ++senders_iter) {
-    senders_list->AppendString(*senders_iter);
-  }
-
   scoped_ptr<base::DictionaryValue> registration_info_dict(
       new base::DictionaryValue());
-  registration_info_dict->Set(kSendersKey, senders_list.release());
+  registration_info_dict->SetString(kSenderKey,

[jianli, 2014/03/03 21:29:31]

Do we want to make it be compatible with future multiple registration support?

[fgorski, 2014/03/03 23:14:16]

Done. Modified the write and read code to simply store a dictionary of 
sender_id -> registration_id mappings. The reading will assume multiple entries,
but exit after reading one.

+                                    registration_info.sender_id);
   registration_info_dict->SetString(kRegistrationIDKey,
                                     registration_info.registration_id);
 
   storage->SetExtensionValue(
       app_id, kRegistrationKey, registration_info_dict.PassAs<base::Value>());
 }
 
 void GCMProfileService::ReadRegistrationInfo(const std::string& app_id) {
   delayed_task_controller_->AddApp(app_id);
 
@@ skipping 28 matching lines @@
 bool GCMProfileService::ParsePersistedRegistrationInfo(
     scoped_ptr<base::Value> value,
     RegistrationInfo* registration_info) {
   base::DictionaryValue* dict = NULL;
   if (!value.get() || !value->GetAsDictionary(&dict))
     return false;
 
   if (!dict->GetString(kRegistrationIDKey, &registration_info->registration_id))
     return false;
 
-  const base::ListValue* senders_list = NULL;
-  if (!dict->GetList(kSendersKey, &senders_list) || !senders_list->GetSize())
+  if (!dict->GetString(kSenderKey, &registration_info->sender_id))
     return false;
-  for (size_t i = 0; i < senders_list->GetSize(); ++i) {
-    std::string sender;
-    if (!senders_list->GetString(i, &sender))
-      return false;
-    registration_info->sender_ids.push_back(sender);
-  }
 
   return true;
 }
 
 // static
 const char* GCMProfileService::GetPersistentRegisterKeyForTesting() {
   return kRegistrationKey;
 }
 
 }  // namespace gcm