[GCM] Move registration info persistence from extension state store to GCM store

google_apis/gcm/gcm_client_impl.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 "google_apis/gcm/gcm_client_impl.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 97 matching lines @@
     return DATA_MESSAGE;
   return UNKNOWN;
 }
 
 }  // namespace
 
 GCMClientImpl::GCMClientImpl()
     : state_(UNINITIALIZED),
       clock_(new base::DefaultClock()),
       url_request_context_getter_(NULL),
-      pending_registrations_deleter_(&pending_registrations_),
-      pending_unregistrations_deleter_(&pending_unregistrations_),
+      pending_registration_requests_deleter_(&pending_registration_requests_),
+      pending_unregistration_requests_deleter_(
+          &pending_unregistration_requests_),
       weak_ptr_factory_(this) {
 }
 
 GCMClientImpl::~GCMClientImpl() {
 }
 
 void GCMClientImpl::Initialize(
     const checkin_proto::ChromeBuildProto& chrome_build_proto,
     const base::FilePath& path,
     const std::vector<std::string>& account_ids,
@@ skipping 26 matching lines @@
 }
 
 void GCMClientImpl::OnLoadCompleted(scoped_ptr<GCMStore::LoadResult> result) {
   DCHECK_EQ(LOADING, state_);
 
   if (!result->success) {
     ResetState();
     return;
   }
 
+  registrations_ = result->registrations;
+
   device_checkin_info_.android_id = result->device_android_id;
   device_checkin_info_.secret = result->device_security_token;
   InitializeMCSClient(result.Pass());
   if (!device_checkin_info_.IsValid()) {
     device_checkin_info_.Reset();
     state_ = INITIAL_DEVICE_CHECKIN;
     StartCheckin(device_checkin_info_);
     return;
   }
 
@@ skipping 101 matching lines @@
       // TODO(fgorski): Reset the checkin timer.
     }
   }
 }
 
 void GCMClientImpl::SetDeviceCredentialsCallback(bool success) {
   // TODO(fgorski): This is one of the signals that store needs a rebuild.
   DCHECK(success);
 }
 
+void GCMClientImpl::UpdateRegistrationCallback(bool success) {
+  // TODO(fgorski): This is one of the signals that store needs a rebuild.
+  DCHECK(success);
+}
+
 void GCMClientImpl::Stop() {
   device_checkin_info_.Reset();
   mcs_client_.reset();
   checkin_request_.reset();
-  pending_registrations_.clear();
+  pending_registration_requests_.clear();
   state_ = INITIALIZED;
   gcm_store_->Close();
 }
 
 void GCMClientImpl::CheckOut() {
   Stop();
   gcm_store_->Destroy(base::Bind(&GCMClientImpl::OnGCMStoreDestroyed,
                                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void GCMClientImpl::Register(const std::string& app_id,
                              const std::vector<std::string>& sender_ids) {
   DCHECK_EQ(state_, READY);
+
+  // If the same sender ids is provided, return the cached registration ID
+  // directly.
+  RegistrationInfoMap::const_iterator registrations_iter =
+      registrations_.find(app_id);
+  if (registrations_iter != registrations_.end() &&
+      registrations_iter->second.sender_ids == sender_ids) {
+    delegate_->OnRegisterFinished(
+        app_id, registrations_iter->second.registration_id, SUCCESS);
+    return;
+  }
+
   RegistrationRequest::RequestInfo request_info(
       device_checkin_info_.android_id,
       device_checkin_info_.secret,
       app_id,
       sender_ids);
-  DCHECK_EQ(0u, pending_registrations_.count(app_id));
+  DCHECK_EQ(0u, pending_registration_requests_.count(app_id));
 
   RegistrationRequest* registration_request =
       new RegistrationRequest(request_info,
                               kDefaultBackoffPolicy,
                               base::Bind(&GCMClientImpl::OnRegisterCompleted,
                                          weak_ptr_factory_.GetWeakPtr(),
-                                         app_id),
+                                         app_id,
+                                         sender_ids),
                               kMaxRegistrationRetries,
                               url_request_context_getter_);
-  pending_registrations_[app_id] = registration_request;
+  pending_registration_requests_[app_id] = registration_request;
   registration_request->Start();
 }
 
-void GCMClientImpl::OnRegisterCompleted(const std::string& app_id,
-                                        RegistrationRequest::Status status,
-                                        const std::string& registration_id) {
+void GCMClientImpl::OnRegisterCompleted(
+    const std::string& app_id,
+    const std::vector<std::string>& sender_ids,
+    RegistrationRequest::Status status,
+    const std::string& registration_id) {
   DCHECK(delegate_);
 
   Result result;
-  PendingRegistrations::iterator iter = pending_registrations_.find(app_id);
-  if (iter == pending_registrations_.end())
+  PendingRegistrationRequests::iterator iter =
+      pending_registration_requests_.find(app_id);
+  if (iter == pending_registration_requests_.end())
     result = UNKNOWN_ERROR;
   else if (status == RegistrationRequest::INVALID_SENDER)
     result = INVALID_PARAMETER;
   else if (registration_id.empty())
     result = SERVER_ERROR;
   else
     result = SUCCESS;
 
+  if (result == SUCCESS) {
+    // Cache it.
+    RegistrationInfo registration;
+    registration.sender_ids = sender_ids;
+    registration.registration_id = registration_id;
+    registrations_[app_id] = registration;
+
+    // Save it in the persistent store.
+    gcm_store_->AddRegistration(
+        app_id,
+        registration,
+        base::Bind(&GCMClientImpl::UpdateRegistrationCallback,
+                   weak_ptr_factory_.GetWeakPtr()));
+  }
+
   delegate_->OnRegisterFinished(
       app_id, result == SUCCESS ? registration_id : std::string(), result);
 
-  if (iter != pending_registrations_.end()) {
+  if (iter != pending_registration_requests_.end()) {
     delete iter->second;
-    pending_registrations_.erase(iter);
+    pending_registration_requests_.erase(iter);
   }
 }
 
 void GCMClientImpl::Unregister(const std::string& app_id) {
   DCHECK_EQ(state_, READY);
-  if (pending_unregistrations_.count(app_id) == 1)
+  if (pending_unregistration_requests_.count(app_id) == 1)
     return;
 
+  // Remove from the cache and persistent store.
+  registrations_.erase(app_id);
+  gcm_store_->RemoveRegistration(
+      app_id,
+      base::Bind(&GCMClientImpl::UpdateRegistrationCallback,
+                 weak_ptr_factory_.GetWeakPtr()));
+
   UnregistrationRequest::RequestInfo request_info(
       device_checkin_info_.android_id,
       device_checkin_info_.secret,
       app_id);
 
   UnregistrationRequest* unregistration_request =
       new UnregistrationRequest(
           request_info,
           kDefaultBackoffPolicy,
           base::Bind(&GCMClientImpl::OnUnregisterCompleted,
                      weak_ptr_factory_.GetWeakPtr(),
                      app_id),
           url_request_context_getter_);
-  pending_unregistrations_[app_id] = unregistration_request;
+  pending_unregistration_requests_[app_id] = unregistration_request;
   unregistration_request->Start();
 }
 
 void GCMClientImpl::OnUnregisterCompleted(
     const std::string& app_id,
     UnregistrationRequest::Status status) {
   DVLOG(1) << "Unregister completed for app: " << app_id
            << " with " << (status ? "success." : "failure.");
   delegate_->OnUnregisterFinished(
       app_id,
       status == UnregistrationRequest::SUCCESS ? SUCCESS : SERVER_ERROR);
 
-  PendingUnregistrations::iterator iter = pending_unregistrations_.find(app_id);
-  if (iter == pending_unregistrations_.end())
+  PendingUnregistrationRequests::iterator iter =
+      pending_unregistration_requests_.find(app_id);
+  if (iter == pending_unregistration_requests_.end())
     return;
 
   delete iter->second;
-  pending_unregistrations_.erase(iter);
+  pending_unregistration_requests_.erase(iter);
 }
 
 void GCMClientImpl::OnGCMStoreDestroyed(bool success) {
   DLOG_IF(ERROR, !success) << "GCM store failed to be destroyed!";
   UMA_HISTOGRAM_BOOLEAN("GCM.StoreDestroySucceeded", success);
 }
 
 void GCMClientImpl::Send(const std::string& app_id,
                          const std::string& receiver_id,
                          const OutgoingMessage& message) {
@@ skipping 136 matching lines @@
     default:  // Treat default the same as UNKNOWN.
       DVLOG(1) << "Unknown message_type received. Message ignored. "
                << "App ID: " << data_message_stanza.category() << ".";
       break;
   }
 }
 
 void GCMClientImpl::HandleIncomingDataMessage(
     const mcs_proto::DataMessageStanza& data_message_stanza,
     MessageData& message_data) {
+  std::string app_id = data_message_stanza.category();
+
+  // Dropping the message when the app is not registered for the sender of the

[Nicolas Zea, 2014/03/21 19:52:40]

nit: Dropping -> Drop

+  // message.
+  RegistrationInfoMap::iterator iter = registrations_.find(app_id);
+  if (iter == registrations_.end() ||
+      std::find(iter->second.sender_ids.begin(),
+                iter->second.sender_ids.end(),
+                data_message_stanza.from()) == iter->second.sender_ids.end()) {
+    return;
+  }
+
   IncomingMessage incoming_message;
   incoming_message.sender_id = data_message_stanza.from();
   if (data_message_stanza.has_token())
     incoming_message.collapse_key = data_message_stanza.token();
   incoming_message.data = message_data;
-  delegate_->OnMessageReceived(data_message_stanza.category(),
-                               incoming_message);
+  delegate_->OnMessageReceived(app_id, incoming_message);
 }
 
 void GCMClientImpl::HandleIncomingSendError(
     const mcs_proto::DataMessageStanza& data_message_stanza,
     MessageData& message_data) {
   SendErrorDetails send_error_details;
   send_error_details.additional_data = message_data;
   send_error_details.result = SERVER_ERROR;
 
   MessageData::iterator iter =
       send_error_details.additional_data.find(kSendErrorMessageIdKey);
   if (iter != send_error_details.additional_data.end()) {
     send_error_details.message_id = iter->second;
     send_error_details.additional_data.erase(iter);
   }
 
   delegate_->OnMessageSendError(data_message_stanza.category(),
                                 send_error_details);
 }
 
 void GCMClientImpl::SetMCSClientForTesting(scoped_ptr<MCSClient> mcs_client) {
   mcs_client_ = mcs_client.Pass();
 }
 
 }  // namespace gcm