Support getting and deleting token for Instance ID.

google_apis/gcm/engine/gcm_store_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 "google_apis/gcm/engine/gcm_store_impl.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
@@ skipping 172 matching lines @@
           scoped_refptr<base::SequencedTaskRunner> foreground_runner,
           scoped_ptr<Encryptor> encryptor);
 
   // Blocking implementations of GCMStoreImpl methods.
   void Load(const LoadCallback& callback);
   void Close();
   void Destroy(const UpdateCallback& callback);
   void SetDeviceCredentials(uint64 device_android_id,
                             uint64 device_security_token,
                             const UpdateCallback& callback);
-  void AddRegistration(const std::string& app_id,
-                       const std::string& serialized_registration,
+  void AddRegistration(const std::string& serialized_key,
+                       const std::string& serialized_value,
                        const UpdateCallback& callback);
-  void RemoveRegistration(const std::string& app_id,
+  void RemoveRegistration(const std::string& serialized_key,
                           const UpdateCallback& callback);
   void AddIncomingMessage(const std::string& persistent_id,
                           const UpdateCallback& callback);
   void RemoveIncomingMessages(const PersistentIdList& persistent_ids,
                               const UpdateCallback& callback);
   void AddOutgoingMessage(const std::string& persistent_id,
                           const MCSMessage& message,
                           const UpdateCallback& callback);
   void RemoveOutgoingMessages(
       const PersistentIdList& persistent_ids,
@@ skipping 30 matching lines @@
   void SetValue(const std::string& key,
                 const std::string& value,
                 const UpdateCallback& callback);
 
  private:
   friend class base::RefCountedThreadSafe<Backend>;
   ~Backend();
 
   LoadStatus OpenStoreAndLoadData(LoadResult* result);
   bool LoadDeviceCredentials(uint64* android_id, uint64* security_token);
-  bool LoadRegistrations(RegistrationInfoMap* registrations);
+  bool LoadRegistrations(std::map<std::string, std::string>* registrations);
   bool LoadIncomingMessages(std::vector<std::string>* incoming_messages);
   bool LoadOutgoingMessages(OutgoingMessageMap* outgoing_messages);
   bool LoadLastCheckinInfo(base::Time* last_checkin_time,
                            std::set<std::string>* accounts);
   bool LoadGServicesSettings(std::map<std::string, std::string>* settings,
                              std::string* digest);
   bool LoadAccountMappingInfo(AccountMappings* account_mappings);
   bool LoadLastTokenFetchTime(base::Time* last_token_fetch_time);
   bool LoadHeartbeatIntervals(std::map<std::string, int>* heartbeat_intervals);
   bool LoadInstanceIDData(std::map<std::string, std::string>* instance_id_data);
@@ skipping 152 matching lines @@
   }
   if (s.ok()) {
     foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, true));
     return;
   }
   LOG(ERROR) << "LevelDB put failed: " << s.ToString();
   foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, false));
 }
 
 void GCMStoreImpl::Backend::AddRegistration(
-    const std::string& app_id,
-    const std::string& serialized_registration,
+    const std::string& serialized_key,
+    const std::string& serialized_value,
     const UpdateCallback& callback) {
-  DVLOG(1) << "Saving registration info for app: " << app_id;
+  DVLOG(1) << "Saving registration info for app: " << serialized_key;
   if (!db_.get()) {
     LOG(ERROR) << "GCMStore db doesn't exist.";
     foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, false));
     return;
   }
   leveldb::WriteOptions write_options;
   write_options.sync = true;
 
-  std::string key = MakeRegistrationKey(app_id);
-  const leveldb::Status status = db_->Put(write_options,
-                                          MakeSlice(key),
-                                          MakeSlice(serialized_registration));
-  if (status.ok()) {
-    foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, true));
-    return;
-  }
-  LOG(ERROR) << "LevelDB put failed: " << status.ToString();
-  foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, false));
+  std::string key = MakeRegistrationKey(serialized_key);

[Nicolas Zea, 2015/05/14 05:02:47]

Should this be using a new leveldb key prefix?

[jianli, 2015/05/14 19:18:14]

We don't want to do that since we still want to make GCM registrations work same
as before. Here registrations mean both GCM registrations and InstanceID tokens.

+  const leveldb::Status status = db_->Put(
+      write_options,
+      MakeSlice(MakeRegistrationKey(serialized_key)),

[Nicolas Zea, 2015/05/14 05:02:47]

reuse |key|?

[jianli, 2015/05/14 19:18:14]

Done.

+      MakeSlice(serialized_value));
+  if (!status.ok())
+    LOG(ERROR) << "LevelDB put failed: " << status.ToString();
+  foreground_task_runner_->PostTask(
+      FROM_HERE, base::Bind(callback, status.ok()));
 }
 
-void GCMStoreImpl::Backend::RemoveRegistration(const std::string& app_id,
-                                               const UpdateCallback& callback) {
+void GCMStoreImpl::Backend::RemoveRegistration(
+    const std::string& serialized_key,
+    const UpdateCallback& callback) {
   if (!db_.get()) {
     LOG(ERROR) << "GCMStore db doesn't exist.";
     foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, false));
     return;
   }
   leveldb::WriteOptions write_options;
   write_options.sync = true;
 
-  leveldb::Status status =
-      db_->Delete(write_options, MakeSlice(MakeRegistrationKey(app_id)));
-  if (status.ok()) {
-    foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, true));
-    return;
-  }
-  LOG(ERROR) << "LevelDB remove failed: " << status.ToString();
-  foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, false));
+  leveldb::Status status = db_->Delete(
+      write_options, MakeSlice(MakeRegistrationKey(serialized_key)));
+  if (!status.ok())
+    LOG(ERROR) << "LevelDB remove failed: " << status.ToString();
+  foreground_task_runner_->PostTask(
+      FROM_HERE, base::Bind(callback, status.ok()));
 }
 
 void GCMStoreImpl::Backend::AddIncomingMessage(const std::string& persistent_id,
                                                const UpdateCallback& callback) {
   DVLOG(1) << "Saving incoming message with id " << persistent_id;
   if (!db_.get()) {
     LOG(ERROR) << "GCMStore db doesn't exist.";
     foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, false));
     return;
   }
@@ skipping 423 matching lines @@
   if (s.IsNotFound()) {
     DVLOG(1) << "No credentials found.";
     return true;
   }
 
   LOG(ERROR) << "Error reading credentials from store.";
   return false;
 }
 
 bool GCMStoreImpl::Backend::LoadRegistrations(
-    RegistrationInfoMap* registrations) {
+    std::map<std::string, std::string>* registrations) {
   leveldb::ReadOptions read_options;
   read_options.verify_checksums = true;
 
   scoped_ptr<leveldb::Iterator> iter(db_->NewIterator(read_options));
   for (iter->Seek(MakeSlice(kRegistrationKeyStart));
        iter->Valid() && iter->key().ToString() < kRegistrationKeyEnd;
        iter->Next()) {
     leveldb::Slice s = iter->value();
     if (s.size() <= 1) {
       LOG(ERROR) << "Error reading registration with key " << s.ToString();
       return false;
     }
     std::string app_id = ParseRegistrationKey(iter->key().ToString());
-    linked_ptr<RegistrationInfo> registration(new RegistrationInfo);
-    if (!registration->ParseFromString(iter->value().ToString())) {
-      LOG(ERROR) << "Failed to parse registration with app id " << app_id;
-      return false;
-    }
     DVLOG(1) << "Found registration with app id " << app_id;
-    (*registrations)[app_id] = registration;
+    (*registrations)[app_id] = iter->value().ToString();
   }
 
   return true;
 }
 
 bool GCMStoreImpl::Backend::LoadIncomingMessages(
     std::vector<std::string>* incoming_messages) {
   leveldb::ReadOptions read_options;
   read_options.verify_checksums = true;
 
@@ skipping 239 matching lines @@
   blocking_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&GCMStoreImpl::Backend::SetDeviceCredentials,
                  backend_,
                  device_android_id,
                  device_security_token,
                  callback));
 }
 
 void GCMStoreImpl::AddRegistration(
-    const std::string& app_id,
-    const linked_ptr<RegistrationInfo>& registration,
+    const std::string& serialized_key,
+    const std::string& serialized_value,
     const UpdateCallback& callback) {
-  std::string serialized_registration = registration->SerializeAsString();
   blocking_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&GCMStoreImpl::Backend::AddRegistration,
                  backend_,
-                 app_id,
-                 serialized_registration,
+                 serialized_key,
+                 serialized_value,
                  callback));
 }
 
 void GCMStoreImpl::RemoveRegistration(const std::string& app_id,
                                           const UpdateCallback& callback) {
   blocking_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&GCMStoreImpl::Backend::RemoveRegistration,
                  backend_,
                  app_id,
@@ skipping 242 matching lines @@
            removed_message_counts.begin();
        iter != removed_message_counts.end(); ++iter) {
     DCHECK_NE(app_message_counts_.count(iter->first), 0U);
     app_message_counts_[iter->first] -= iter->second;
     DCHECK_GE(app_message_counts_[iter->first], 0);
   }
   callback.Run(true);
 }
 
 }  // namespace gcm