Persist Instance ID data to GCM store.

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 30 matching lines @@
   OPENING_STORE_FAILED,
   LOADING_DEVICE_CREDENTIALS_FAILED,
   LOADING_REGISTRATION_FAILED,
   LOADING_INCOMING_MESSAGES_FAILED,
   LOADING_OUTGOING_MESSAGES_FAILED,
   LOADING_LAST_CHECKIN_INFO_FAILED,
   LOADING_GSERVICE_SETTINGS_FAILED,
   LOADING_ACCOUNT_MAPPING_FAILED,
   LOADING_LAST_TOKEN_TIME_FAILED,
   LOADING_HEARTBEAT_INTERVALS_FAILED,
+  LOADING_INSTANCE_ID_DATA_FAILED,
 
   // NOTE: always keep this entry at the end. Add new status types only
   // immediately above this line. Make sure to update the corresponding
   // histogram enum accordingly.
   LOAD_STATUS_COUNT
 };
 
 // Limit to the number of outstanding messages per app.
 const int kMessagesPerAppLimit = 20;
 
@@ skipping 39 matching lines @@
 // Used for limiting iteration.
 const char kAccountKeyEnd[] = "account2-";
 // Lowest lexicographically ordered heartbeat key.
 // Used for prefixing account information.
 const char kHeartbeatKeyStart[] = "heartbeat1-";
 // Key guaranteed to be higher than all heartbeat keys.
 // Used for limiting iteration.
 const char kHeartbeatKeyEnd[] = "heartbeat2-";
 // Key used for last token fetch time.
 const char kLastTokenFetchTimeKey[] = "last_token_fetch_time";
+// Lowest lexicographically ordered app ids.
+// Used for prefixing app id.
+const char kInstanceIDKeyStart[] = "iid1-";
+// Key guaranteed to be higher than all app ids.
+// Used for limiting iteration.
+const char kInstanceIDKeyEnd[] = "iid2-";
 
 std::string MakeRegistrationKey(const std::string& app_id) {
   return kRegistrationKeyStart + app_id;
 }
 
 std::string ParseRegistrationKey(const std::string& key) {
   return key.substr(arraysize(kRegistrationKeyStart) - 1);
 }
 
 std::string MakeIncomingKey(const std::string& persistent_id) {
@@ skipping 25 matching lines @@
 }
 
 std::string MakeHeartbeatKey(const std::string& scope) {
   return kHeartbeatKeyStart + scope;
 }
 
 std::string ParseHeartbeatKey(const std::string& key) {
   return key.substr(arraysize(kHeartbeatKeyStart) - 1);
 }
 
+std::string MakeInstanceIDKey(const std::string& app_id) {
+  return kInstanceIDKeyStart + app_id;
+}
+
+std::string ParseInstanceIDKey(const std::string& key) {
+  return key.substr(arraysize(kInstanceIDKeyStart) - 1);
+}
+
 // Note: leveldb::Slice keeps a pointer to the data in |s|, which must therefore
 // outlive the slice.
 // For example: MakeSlice(MakeOutgoingKey(x)) is invalid.
 leveldb::Slice MakeSlice(const base::StringPiece& s) {
   return leveldb::Slice(s.begin(), s.size());
 }
 
 }  // namespace
 
 class GCMStoreImpl::Backend
@@ skipping 42 matching lines @@
                          const UpdateCallback& callback);
   void RemoveAccountMapping(const std::string& account_id,
                             const UpdateCallback& callback);
   void SetLastTokenFetchTime(const base::Time& time,
                              const UpdateCallback& callback);
   void AddHeartbeatInterval(const std::string& scope,
                             int interval_ms,
                             const UpdateCallback& callback);
   void RemoveHeartbeatInterval(const std::string& scope,
                                const UpdateCallback& callback);
+  void AddInstanceIDData(const std::string& app_id,
+                         const std::string& instance_id_data,
+                         const UpdateCallback& callback);
+  void RemoveInstanceIDData(const std::string& app_id,
+                            const UpdateCallback& callback);
   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 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);
 
   const base::FilePath path_;
   scoped_refptr<base::SequencedTaskRunner> foreground_task_runner_;
   scoped_ptr<Encryptor> encryptor_;
 
   scoped_ptr<leveldb::DB> db_;
 };
 
 GCMStoreImpl::Backend::Backend(
     const base::FilePath& path,
@@ skipping 43 matching lines @@
   if (!LoadGServicesSettings(&result->gservices_settings,
                              &result->gservices_digest)) {
     return load_status = LOADING_GSERVICE_SETTINGS_FAILED;
   }
   if (!LoadAccountMappingInfo(&result->account_mappings))
     return LOADING_ACCOUNT_MAPPING_FAILED;
   if (!LoadLastTokenFetchTime(&result->last_token_fetch_time))
     return LOADING_LAST_TOKEN_TIME_FAILED;
   if (!LoadHeartbeatIntervals(&result->heartbeat_intervals))
     return LOADING_HEARTBEAT_INTERVALS_FAILED;
+  if (!LoadInstanceIDData(&result->instance_id_data))
+    return LOADING_INSTANCE_ID_DATA_FAILED;
 
   return LOADING_SUCCEEDED;
 }
 
 void GCMStoreImpl::Backend::Load(const LoadCallback& callback) {
   scoped_ptr<LoadResult> result(new LoadResult());
   LoadStatus load_status = OpenStoreAndLoadData(result.get());
   UMA_HISTOGRAM_ENUMERATION("GCM.LoadStatus", load_status, LOAD_STATUS_COUNT);
   if (load_status != LOADING_SUCCEEDED) {
     result->Reset();
@@ skipping 290 matching lines @@
 
   leveldb::WriteOptions write_options;
   write_options.sync = true;
   const leveldb::Status s = db_->Write(write_options, &write_batch);
 
   if (!s.ok())
     LOG(ERROR) << "LevelDB set last checkin info failed: " << s.ToString();
   foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, s.ok()));
 }
 
+void GCMStoreImpl::AddInstanceIDData(const std::string& app_id,
+                                     const std::string& instance_id_data,
+                                     const UpdateCallback& callback) {
+  blocking_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&GCMStoreImpl::Backend::AddInstanceIDData,
+                 backend_,
+                 app_id,
+                 instance_id_data,
+                 callback));
+}
+
+void GCMStoreImpl::RemoveInstanceIDData(const std::string& app_id,
+                                        const UpdateCallback& callback) {
+  blocking_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&GCMStoreImpl::Backend::RemoveInstanceIDData,
+                 backend_,
+                 app_id,
+                 callback));
+}
+
 void GCMStoreImpl::Backend::SetGServicesSettings(
     const std::map<std::string, std::string>& settings,
     const std::string& settings_digest,
     const UpdateCallback& callback) {
   leveldb::WriteBatch write_batch;
 
   // Remove all existing settings.
   leveldb::ReadOptions read_options;
   read_options.verify_checksums = true;
   scoped_ptr<leveldb::Iterator> iter(db_->NewIterator(read_options));
@@ skipping 130 matching lines @@
   leveldb::Status s =
       db_->Delete(write_options, MakeSlice(MakeHeartbeatKey(scope)));
 
   if (!s.ok()) {
     LOG(ERROR) << "LevelDB removal of heartbeat interval failed: "
                << s.ToString();
   }
   foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, s.ok()));
 }
 
+void GCMStoreImpl::Backend::AddInstanceIDData(
+    const std::string& app_id,
+    const std::string& instance_id_data,
+    const UpdateCallback& callback) {
+  DVLOG(1) << "Adding Instance ID data.";
+  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 = MakeInstanceIDKey(app_id);
+  const leveldb::Status status = db_->Put(write_options,
+                                          MakeSlice(key),
+                                          MakeSlice(instance_id_data));
+  if (status.ok()) {

[fgorski, 2015/05/08 17:12:33]

nit: see method above for a cleaner completion

if (!status.ok()) {
  log error;
}
PostTask(bind(callbakc, status.ok());

[jianli, 2015/05/08 20:56:01]

Done.

+    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));
+}
+
+void GCMStoreImpl::Backend::RemoveInstanceIDData(
+    const std::string& app_id,
+    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(MakeInstanceIDKey(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));
+}
+
 void GCMStoreImpl::Backend::SetValue(const std::string& key,
                                      const std::string& value,
                                      const UpdateCallback& callback) {
   DVLOG(1) << "Injecting a value to GCM Store for testing. Key: "
            << key << ", Value: " << value;
   if (!db_.get()) {
     LOG(ERROR) << "GCMStore db doesn't exist.";
     foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, false));
     return;
   }
@@ skipping 245 matching lines @@
       return false;
     }
     DVLOG(1) << "Found heartbeat interval with scope: " << scope
              << " interval: " << interval_ms << "ms.";
     (*heartbeat_intervals)[scope] = interval_ms;
   }
 
   return true;
 }
 
+bool GCMStoreImpl::Backend::LoadInstanceIDData(
+    std::map<std::string, std::string>* instance_id_data) {
+  leveldb::ReadOptions read_options;
+  read_options.verify_checksums = true;
+
+  scoped_ptr<leveldb::Iterator> iter(db_->NewIterator(read_options));
+  for (iter->Seek(MakeSlice(kInstanceIDKeyStart));
+       iter->Valid() && iter->key().ToString() < kInstanceIDKeyEnd;
+       iter->Next()) {
+    leveldb::Slice s = iter->value();
+    if (s.size() <= 1) {
+      LOG(ERROR) << "Error reading IID data with key " << s.ToString();
+      return false;
+    }
+    std::string app_id = ParseInstanceIDKey(iter->key().ToString());
+    DVLOG(1) << "Found IID data with app id " << app_id;
+    (*instance_id_data)[app_id] = s.ToString();
+  }
+
+  return true;
+}
+
 GCMStoreImpl::GCMStoreImpl(
     const base::FilePath& path,
     scoped_refptr<base::SequencedTaskRunner> blocking_task_runner,
     scoped_ptr<Encryptor> encryptor)
     : backend_(new Backend(path,
                            base::MessageLoopProxy::current(),
                            encryptor.Pass())),
       blocking_task_runner_(blocking_task_runner),
       weak_ptr_factory_(this) {
 }
@@ skipping 302 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