Support getting and deleting token for Instance ID.

google_apis/gcm/engine/gcm_store.h

 // 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.
 
 #ifndef GOOGLE_APIS_GCM_ENGINE_GCM_STORE_H_
 #define GOOGLE_APIS_GCM_ENGINE_GCM_STORE_H_
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include <google/protobuf/message_lite.h>
 
 #include "base/basictypes.h"
 #include "base/callback_forward.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "google_apis/gcm/base/gcm_export.h"
 #include "google_apis/gcm/engine/account_mapping.h"
-#include "google_apis/gcm/engine/registration_info.h"
 
 namespace gcm {
 
 class MCSMessage;
 
 // A GCM data store interface. GCM Store will handle persistence portion of RMQ,
 // as well as store device and user checkin information.
 class GCM_EXPORT GCMStore {
  public:
   // Map of message id to message data for outgoing messages.
   typedef std::map<std::string, linked_ptr<google::protobuf::MessageLite> >
       OutgoingMessageMap;
 
   // List of account mappings.
   typedef std::vector<AccountMapping> AccountMappings;
 
   // Container for Load(..) results.
   struct GCM_EXPORT LoadResult {
     LoadResult();
     ~LoadResult();
 
     void Reset();
 
     bool success;
     uint64 device_android_id;
     uint64 device_security_token;
-    RegistrationInfoMap registrations;
+    std::map<std::string, std::string> registrations;
     std::vector<std::string> incoming_messages;
     OutgoingMessageMap outgoing_messages;
     std::map<std::string, std::string> gservices_settings;
     std::string gservices_digest;
     base::Time last_checkin_time;
     std::set<std::string> last_checkin_accounts;
     AccountMappings account_mappings;
     base::Time last_token_fetch_time;
     std::map<std::string, int> heartbeat_intervals;
     std::map<std::string, std::string> instance_id_data;
@@ skipping 15 matching lines @@
 
   // Clears the GCM store of all data.
   virtual void Destroy(const UpdateCallback& callback) = 0;
 
   // Sets this device's messaging credentials.
   virtual void SetDeviceCredentials(uint64 device_android_id,
                                     uint64 device_security_token,
                                     const UpdateCallback& callback) = 0;
 
   // Registration info.
-  virtual void AddRegistration(const std::string& app_id,
-                               const linked_ptr<RegistrationInfo>& registration,
+  virtual void AddRegistration(const std::string& serialized_key,

[Nicolas Zea, 2015/05/15 20:37:01]

Does it make sense to just pass in something equivalent to a RegistrationInfo,
which encapsulate both the app id/sender id or instance id information? Having
this be an arbitrary key/value string pair seems too generic.

[jianli, 2015/05/21 00:41:15]

We've already passed a serialized string from store front-end to back-end for
registrations to workaround the bug that linked_ptr is not thread-safe.  We
could try to bring something equivalent to RegistrationInfo, but we need to make
a couple copies which are not efficient. So it seems to me that it might be
better to keep serialization/deserliazation logic in GCMClient layer, instead of
making GCMStore more complicated.

[Nicolas Zea, 2015/05/21 21:07:51]

Fair enough. Could we give these more precise names though? For example keep
app_id and make serialized_value serialized_registration?

[jianli, 2015/05/21 23:11:24]

I can't just make app_id key for registrations since it does not work for
persisting InstanceID token records. For each app, there could be multiple token
records that are identified by pair of authorized entity and scope. So the key
to store InstanceID token records is indeed <app_id, authorized_entity, scope>.
I've updated the comment.

+                               const std::string& serialized_value,
                                const UpdateCallback& callback) = 0;
-  virtual void RemoveRegistration(const std::string& app_id,
+  virtual void RemoveRegistration(const std::string& serialized_key,
                                   const UpdateCallback& callback) = 0;
 
   // Unacknowledged incoming message handling.
   virtual void AddIncomingMessage(const std::string& persistent_id,
                                   const UpdateCallback& callback) = 0;
   virtual void RemoveIncomingMessage(const std::string& persistent_id,
                                      const UpdateCallback& callback) = 0;
   virtual void RemoveIncomingMessages(const PersistentIdList& persistent_ids,
                                       const UpdateCallback& callback) = 0;
 
@@ skipping 49 matching lines @@
   virtual void RemoveInstanceIDData(const std::string& app_id,
                                     const UpdateCallback& callback) = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(GCMStore);
 };
 
 }  // namespace gcm
 
 #endif  // GOOGLE_APIS_GCM_ENGINE_GCM_STORE_H_