Support getting and deleting token for Instance ID.

components/gcm_driver/gcm_client_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 "components/gcm_driver/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 49 matching lines @@
 
 enum ResetStoreError {
   DESTROYING_STORE_FAILED,
   INFINITE_STORE_RESET,
   // NOTE: always keep this entry at the end. Add new value only immediately
   // above this line. Make sure to update the corresponding histogram enum
   // accordingly.
   RESET_STORE_ERROR_COUNT
 };
 
+const char kGCMScope[] = "GCM";
 const int kMaxRegistrationRetries = 5;
 const char kMessageTypeDataMessage[] = "gcm";
 const char kMessageTypeDeletedMessagesKey[] = "deleted_messages";
 const char kMessageTypeKey[] = "message_type";
 const char kMessageTypeSendErrorKey[] = "send_error";
 const char kSendErrorMessageIdKey[] = "google.message_id";
 const char kSendMessageFromValue[] = "gcm@chrome.com";
 const int64 kDefaultUserSerialNumber = 0LL;
 
 GCMClient::Result ToGCMClientResult(MCSClient::MessageSendStatus status) {
@@ skipping 82 matching lines @@
 MessageType DecodeMessageType(const std::string& value) {
   if (kMessageTypeDeletedMessagesKey == value)
     return DELETED_MESSAGES;
   if (kMessageTypeSendErrorKey == value)
     return SEND_ERROR;
   if (kMessageTypeDataMessage == value)
     return DATA_MESSAGE;
   return UNKNOWN;
 }
 
+std::string SerializeInstanceIDData(const std::string& instance_id,
+                                    const std::string& extra_data) {
+  DCHECK(!instance_id.empty() && !extra_data.empty());
+  DCHECK(instance_id.find(',') == std::string::npos);
+  return instance_id + "," + extra_data;
+}
+
+bool DeserializeInstanceIDData(const std::string& serialized_data,
+                               std::string* instance_id,
+                               std::string* extra_data) {
+  DCHECK(instance_id && extra_data);
+  std::size_t pos = serialized_data.find(',');
+  if (pos == std::string::npos)
+    return false;
+  *instance_id = serialized_data.substr(0, pos);
+  *extra_data = serialized_data.substr(pos + 1);
+  return !instance_id->empty() && !extra_data->empty();
+}
+
 void RecordOutgoingMessageToUMA(
     const gcm::GCMClient::OutgoingMessage& message) {
   OutgoingMessageTTLCategory ttl_category;
   if (message.time_to_live == 0)
     ttl_category = TTL_ZERO;
   else if (message.time_to_live <= 60 )
     ttl_category = TTL_LESS_THAN_OR_EQUAL_TO_ONE_MINUTE;
   else if (message.time_to_live <= 60 * 60)
     ttl_category = TTL_LESS_THAN_OR_EQUAL_TO_ONE_HOUR;
   else if (message.time_to_live <= 24 * 60 * 60)
@@ skipping 146 matching lines @@
 
 void GCMClientImpl::OnLoadCompleted(scoped_ptr<GCMStore::LoadResult> result) {
   DCHECK_EQ(LOADING, state_);
 
   if (!result->success) {
     ResetStore();
     return;
   }
   gcm_store_reset_ = false;
 
-  registrations_ = result->registrations;
   device_checkin_info_.android_id = result->device_android_id;
   device_checkin_info_.secret = result->device_security_token;
   device_checkin_info_.last_checkin_accounts = result->last_checkin_accounts;
   // A case where there were previously no accounts reported with checkin is
   // considered to be the same as when the list of accounts is empty. It enables
   // scheduling a periodic checkin for devices with no signed in users
   // immediately after restart, while keeping |accounts_set == false| delays the
   // checkin until the list of accounts is set explicitly.
   if (result->last_checkin_accounts.size() == 0)
     device_checkin_info_.accounts_set = true;
   last_checkin_time_ = result->last_checkin_time;
   gservices_settings_.UpdateFromLoadResult(*result);
-  instance_id_data_ = result->instance_id_data;
+
+  for (auto iter = result->registrations.begin();
+       iter != result->registrations.end();
+       ++iter) {
+    std::string registration_id;
+    scoped_ptr<RegistrationInfo> registration =
+        RegistrationInfo::BuildFromString(
+            iter->first, iter->second, &registration_id);
+    // TODO(jianli): Add UMA to track the error case.
+    if (registration.get())
+      registrations_[make_linked_ptr(registration.release())] = registration_id;
+  }
+
+  for (auto iter = result->instance_id_data.begin();
+       iter != result->instance_id_data.end();
+       ++iter) {
+    std::string instance_id;
+    std::string extra_data;
+    if (DeserializeInstanceIDData(iter->second, &instance_id, &extra_data))
+      instance_id_data_[iter->first] = std::make_pair(instance_id, extra_data);
+  }
+
   load_result_ = result.Pass();
   state_ = LOADED;
 
   // Don't initiate the GCM connection when GCM is in delayed start mode and
   // not any standalone app has registered GCM yet.
   if (start_mode_ == DELAYED_START && !HasStandaloneRegisteredApp())
     return;
 
   StartGCM();
 }
@@ skipping 163 matching lines @@
       base::Bind(&GCMClientImpl::IgnoreWriteResultCallback,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void GCMClientImpl::UpdateHeartbeatTimer(scoped_ptr<base::Timer> timer) {
   DCHECK(mcs_client_);
   mcs_client_->UpdateHeartbeatTimer(timer.Pass());
 }
 
 void GCMClientImpl::AddInstanceIDData(const std::string& app_id,
-                                      const std::string& instance_id_data) {
-  instance_id_data_[app_id] = instance_id_data;
+                                      const std::string& instance_id,
+                                      const std::string& extra_data) {
+  instance_id_data_[app_id] = std::make_pair(instance_id, extra_data);
   gcm_store_->AddInstanceIDData(
       app_id,
-      instance_id_data,
+      SerializeInstanceIDData(instance_id, extra_data),
       base::Bind(&GCMClientImpl::IgnoreWriteResultCallback,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void GCMClientImpl::RemoveInstanceIDData(const std::string& app_id) {
   instance_id_data_.erase(app_id);
   gcm_store_->RemoveInstanceIDData(
       app_id,
       base::Bind(&GCMClientImpl::IgnoreWriteResultCallback,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
-std::string GCMClientImpl::GetInstanceIDData(const std::string& app_id) {
+void GCMClientImpl::GetInstanceIDData(const std::string& app_id,
+                                      std::string* instance_id,
+                                      std::string* extra_data) {
+  DCHECK(instance_id && extra_data);
+
   auto iter = instance_id_data_.find(app_id);
   if (iter == instance_id_data_.end())
-    return std::string();
-  return iter->second;
+    return;
+  *instance_id = iter->second.first;
+  *extra_data = iter->second.second;
 }
 
 void GCMClientImpl::AddHeartbeatInterval(const std::string& scope,
                                          int interval_ms) {
   DCHECK(mcs_client_);
   mcs_client_->AddHeartbeatInterval(scope, interval_ms);
 }
 
 void GCMClientImpl::RemoveHeartbeatInterval(const std::string& scope) {
   DCHECK(mcs_client_);
@@ skipping 147 matching lines @@
   delegate_->OnDisconnected();
   mcs_client_.reset();
   checkin_request_.reset();
   // Delete all of the pending registration and unregistration requests.
   STLDeleteValues(&pending_registration_requests_);
   STLDeleteValues(&pending_unregistration_requests_);
   state_ = INITIALIZED;
   gcm_store_->Close();
 }
 
-void GCMClientImpl::Register(const std::string& app_id,
-                             const std::vector<std::string>& sender_ids) {
+void GCMClientImpl::Register(
+    const linked_ptr<RegistrationInfo>& registration_info) {
   DCHECK_EQ(state_, READY);
 
-  // If the same sender ids is provided, return the cached registration ID
-  // directly.
+  // Find and use the cached registration ID.
   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;
+      registrations_.find(registration_info);
+  if (registrations_iter != registrations_.end()) {
+    bool matched = true;
+
+    // For GCM registration, we also match the sender IDs since multiple
+    // registrations are not supported.
+    const GCMRegistrationInfo* gcm_registration_info =
+        GCMRegistrationInfo::FromRegistrationInfo(registration_info.get());
+    if (gcm_registration_info) {
+      const GCMRegistrationInfo* cached_gcm_registration_info =
+          GCMRegistrationInfo::FromRegistrationInfo(
+              registrations_iter->first.get());
+      DCHECK(cached_gcm_registration_info);
+      if (cached_gcm_registration_info &&
+          gcm_registration_info->sender_ids !=
+              cached_gcm_registration_info->sender_ids) {
+        matched = false;
+      }
+    }
+
+    if (matched) {
+      delegate_->OnRegisterFinished(
+          registration_info, registrations_iter->second, SUCCESS);
+      return;
+    }
   }
 
-  RegistrationRequest::RequestInfo request_info(
-      device_checkin_info_.android_id,
-      device_checkin_info_.secret,
-      app_id,
-      sender_ids);
-  DCHECK_EQ(0u, pending_registration_requests_.count(app_id));
-
   RegistrationRequest* registration_request =
-      new RegistrationRequest(gservices_settings_.GetRegistrationURL(),
-                              request_info,
-                              GetGCMBackoffPolicy(),
-                              base::Bind(&GCMClientImpl::OnRegisterCompleted,
-                                         weak_ptr_factory_.GetWeakPtr(),
-                                         app_id,
-                                         sender_ids),
-                              kMaxRegistrationRetries,
-                              url_request_context_getter_,
-                              &recorder_);
-  pending_registration_requests_[app_id] = registration_request;
+      new RegistrationRequest(
+          gservices_settings_.GetRegistrationURL(),
+          BuildRegistrationRequestInfo(*registration_info).Pass(),
+          GetGCMBackoffPolicy(),
+          base::Bind(&GCMClientImpl::OnRegisterCompleted,
+                     weak_ptr_factory_.GetWeakPtr(),
+                     registration_info),
+          kMaxRegistrationRetries,
+          url_request_context_getter_,
+          &recorder_);
+  pending_registration_requests_[registration_info] = registration_request;
   registration_request->Start();
 }
 
 void GCMClientImpl::OnRegisterCompleted(
-    const std::string& app_id,
-    const std::vector<std::string>& sender_ids,
+    const linked_ptr<RegistrationInfo>& registration_info,
     RegistrationRequest::Status status,
     const std::string& registration_id) {
   DCHECK(delegate_);
 
   Result result;
   PendingRegistrationRequests::iterator iter =
-      pending_registration_requests_.find(app_id);
+      pending_registration_requests_.find(registration_info);
   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.
-    linked_ptr<RegistrationInfo> registration(new RegistrationInfo);
-    registration->sender_ids = sender_ids;
-    registration->registration_id = registration_id;
-    registrations_[app_id] = registration;
+    registrations_[registration_info] = registration_id;
 
     // Save it in the persistent store.
     gcm_store_->AddRegistration(
-        app_id,
-        registration,
+        registration_info->GetSerializedKey(),
+        registration_info->GetSerializedValue(registration_id),
         base::Bind(&GCMClientImpl::UpdateRegistrationCallback,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   delegate_->OnRegisterFinished(
-      app_id, result == SUCCESS ? registration_id : std::string(), result);
+      registration_info,
+      result == SUCCESS ? registration_id : std::string(),
+      result);
 
   if (iter != pending_registration_requests_.end()) {
     delete iter->second;
     pending_registration_requests_.erase(iter);
   }
 }
 
-void GCMClientImpl::Unregister(const std::string& app_id) {
+void GCMClientImpl::Unregister(
+    const linked_ptr<RegistrationInfo>& registration_info) {
   DCHECK_EQ(state_, READY);
-  if (pending_unregistration_requests_.count(app_id) == 1)
+  if (pending_unregistration_requests_.count(registration_info) == 1)
     return;
 
   // Remove from the cache and persistent store.
-  registrations_.erase(app_id);
+  registrations_.erase(registration_info);
   gcm_store_->RemoveRegistration(
-      app_id,
+      registration_info->GetSerializedKey(),
       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(
       gservices_settings_.GetRegistrationURL(),
-      request_info,
+      BuildUnregistrationRequestInfo(*registration_info).Pass(),
       GetGCMBackoffPolicy(),
       base::Bind(&GCMClientImpl::OnUnregisterCompleted,
                  weak_ptr_factory_.GetWeakPtr(),
-                 app_id),
+                 registration_info),
       url_request_context_getter_,
       &recorder_);
-  pending_unregistration_requests_[app_id] = unregistration_request;
+  pending_unregistration_requests_[registration_info] = unregistration_request;
   unregistration_request->Start();
 }
 
 void GCMClientImpl::OnUnregisterCompleted(
-    const std::string& app_id,
+    const linked_ptr<RegistrationInfo>& registration_info,
     UnregistrationRequest::Status status) {
-  DVLOG(1) << "Unregister completed for app: " << app_id
+  DVLOG(1) << "Unregister completed for app: " << registration_info->app_id
            << " with " << (status ? "success." : "failure.");
   delegate_->OnUnregisterFinished(
-      app_id,
+      registration_info,
       status == UnregistrationRequest::SUCCESS ? SUCCESS : SERVER_ERROR);
 
   PendingUnregistrationRequests::iterator iter =
-      pending_unregistration_requests_.find(app_id);
+      pending_unregistration_requests_.find(registration_info);
   if (iter == pending_unregistration_requests_.end())
     return;
 
   delete iter->second;
   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);
@@ skipping 41 matching lines @@
     case GCMClientImpl::INITIAL_DEVICE_CHECKIN:
       return "INITIAL_DEVICE_CHECKIN";
     case GCMClientImpl::READY:
       return "READY";
     default:
       NOTREACHED();
       return std::string();
   }
 }
 
+scoped_ptr<RegistrationRequest::RequestInfo>
+GCMClientImpl::BuildRegistrationRequestInfo(
+    const RegistrationInfo& registration_info) const {
+  scoped_ptr<RegistrationRequest::RequestInfo> request_info;
+
+  const GCMRegistrationInfo* gcm_registration_info =
+      GCMRegistrationInfo::FromRegistrationInfo(&registration_info);
+  if (gcm_registration_info) {
+    scoped_ptr<RegistrationRequest::GCMRequestInfo> gcm_request_info(
+        new RegistrationRequest::GCMRequestInfo);
+    gcm_request_info->set_sender_ids(gcm_registration_info->sender_ids);
+    request_info = gcm_request_info.Pass();
+  }
+
+  const InstanceIDTokenInfo* instance_id_token_info =
+      InstanceIDTokenInfo::FromRegistrationInfo(&registration_info);
+  if (instance_id_token_info) {
+    auto instance_id_iter = instance_id_data_.find(registration_info.app_id);
+    DCHECK(instance_id_iter != instance_id_data_.end());
+
+    scoped_ptr<RegistrationRequest::InstanceIDRequestInfo>
+        instance_id_token_request_info(
+            new RegistrationRequest::InstanceIDRequestInfo);
+    instance_id_token_request_info->set_instance_id(instance_id_iter->first);
+    instance_id_token_request_info->set_authorized_entity(
+        instance_id_token_info->authorized_entity);
+    instance_id_token_request_info->set_scope(instance_id_token_info->scope);
+    instance_id_token_request_info->set_options(
+        instance_id_token_info->options);
+    request_info = instance_id_token_request_info.Pass();
+  }
+
+  DCHECK(request_info.get());
+
+  request_info->set_chrome_version(chrome_build_info_.version);
+  request_info->set_android_id(device_checkin_info_.android_id);
+  request_info->set_security_token(device_checkin_info_.secret);
+  request_info->set_app_id(registration_info.app_id);
+  return request_info.Pass();
+}
+
+scoped_ptr<UnregistrationRequest::RequestInfo>
+GCMClientImpl::BuildUnregistrationRequestInfo(
+    const RegistrationInfo& registration_info) const {
+  scoped_ptr<UnregistrationRequest::RequestInfo> request_info;
+
+  const GCMRegistrationInfo* gcm_registration_info =
+      GCMRegistrationInfo::FromRegistrationInfo(&registration_info);
+  if (gcm_registration_info)
+    request_info.reset(new UnregistrationRequest::GCMRequestInfo);
+
+  const InstanceIDTokenInfo* instance_id_token_info =
+      InstanceIDTokenInfo::FromRegistrationInfo(&registration_info);
+  if (instance_id_token_info) {
+    auto instance_id_iter = instance_id_data_.find(registration_info.app_id);
+    DCHECK(instance_id_iter != instance_id_data_.end());
+
+    scoped_ptr<UnregistrationRequest::InstanceIDRequestInfo>
+        instance_id_token_request_info(
+            new UnregistrationRequest::InstanceIDRequestInfo);
+    instance_id_token_request_info->set_instance_id(instance_id_iter->first);
+    instance_id_token_request_info->set_authorized_entity(
+        instance_id_token_info->authorized_entity);
+    instance_id_token_request_info->set_scope(instance_id_token_info->scope);
+    request_info = instance_id_token_request_info.Pass();
+  }
+
+  DCHECK(request_info.get());
+
+  request_info->set_chrome_version(chrome_build_info_.version);
+  request_info->set_android_id(device_checkin_info_.android_id);
+  request_info->set_security_token(device_checkin_info_.secret);
+  request_info->set_app_id(registration_info.app_id);
+  return request_info.Pass();
+}
+
 void GCMClientImpl::SetRecording(bool recording) {
   recorder_.SetRecording(recording);
 }
 
 void GCMClientImpl::ClearActivityLogs() {
   recorder_.Clear();
 }
 
 GCMClient::GCMStatistics GCMClientImpl::GetStatistics() const {
   GCMClient::GCMStatistics stats;
   stats.gcm_client_created = true;
   stats.is_recording = recorder_.is_recording();
   stats.gcm_client_state = GetStateString();
   stats.connection_client_created = mcs_client_.get() != NULL;
   if (connection_factory_.get())
     stats.connection_state = connection_factory_->GetConnectionStateString();
   if (mcs_client_.get()) {
     stats.send_queue_size = mcs_client_->GetSendQueueSize();
     stats.resend_queue_size = mcs_client_->GetResendQueueSize();
   }
   if (device_checkin_info_.android_id > 0)
     stats.android_id = device_checkin_info_.android_id;
   recorder_.CollectActivities(&stats.recorded_activities);
 
   for (RegistrationInfoMap::const_iterator it = registrations_.begin();
        it != registrations_.end(); ++it) {
-    stats.registered_app_ids.push_back(it->first);
+    stats.registered_app_ids.push_back(it->first->app_id);
   }
   return stats;
 }
 
 void GCMClientImpl::OnActivityRecorded() {
   delegate_->OnActivityRecorded();
 }
 
 void GCMClientImpl::OnConnected(const GURL& current_server,
                                 const net::IPEndPoint& ip_endpoint) {
@@ skipping 97 matching lines @@
       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();
+  std::string sender = data_message_stanza.from();
 
   // Drop the message when the app is not registered for the sender of the
   // message.
-  RegistrationInfoMap::iterator iter = registrations_.find(app_id);
-  bool not_registered =
-      iter == registrations_.end() ||
-      std::find(iter->second->sender_ids.begin(),
-                iter->second->sender_ids.end(),
-                data_message_stanza.from()) == iter->second->sender_ids.end();
-  recorder_.RecordDataMessageReceived(app_id, data_message_stanza.from(),
-      data_message_stanza.ByteSize(), !not_registered,
+  bool registered = false;
+
+  // First, find among all GCM registrations.
+  scoped_ptr<GCMRegistrationInfo> gcm_registration(new GCMRegistrationInfo);
+  gcm_registration->app_id = app_id;
+  auto gcm_registration_iter = registrations_.find(
+      make_linked_ptr<RegistrationInfo>(gcm_registration.release()));
+  if (gcm_registration_iter != registrations_.end()) {
+    GCMRegistrationInfo* cached_gcm_registration =
+        GCMRegistrationInfo::FromRegistrationInfo(
+            gcm_registration_iter->first.get());
+    if (cached_gcm_registration &&
+        std::find(cached_gcm_registration->sender_ids.begin(),
+                  cached_gcm_registration->sender_ids.end(),
+                  sender) != cached_gcm_registration->sender_ids.end()) {
+      registered = true;
+    }
+  }
+
+  // Then, find among all InstanceID registrations.
+  if (!registered) {
+    scoped_ptr<InstanceIDTokenInfo> instance_id_token(new InstanceIDTokenInfo);
+    instance_id_token->app_id = app_id;
+    instance_id_token->authorized_entity = sender;
+    instance_id_token->scope = kGCMScope;
+    auto instance_id_token_iter = registrations_.find(
+        make_linked_ptr<RegistrationInfo>(instance_id_token.release()));
+    if (instance_id_token_iter != registrations_.end())
+      registered = true;
+  }
+
+  recorder_.RecordDataMessageReceived(app_id, sender,
+      data_message_stanza.ByteSize(), registered,
       GCMStatsRecorder::DATA_MESSAGE);
-  if (not_registered) {
+  if (!registered)
     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(app_id, incoming_message);
 }
 
 void GCMClientImpl::HandleIncomingSendError(
@@ skipping 17 matching lines @@
   delegate_->OnMessageSendError(data_message_stanza.category(),
                                 send_error_details);
 }
 
 bool GCMClientImpl::HasStandaloneRegisteredApp() const {
   if (registrations_.empty())
     return false;
   // Note that account mapper is not counted as a standalone app since it is
   // automatically started when other app uses GCM.
   return registrations_.size() > 1 ||
-         !registrations_.count(kGCMAccountMapperAppId);
+         !ExistsGCMRegistrationInMap(registrations_, kGCMAccountMapperAppId);
 }
 
 }  // namespace gcm