[GCM] Adding handling of heartbeat intervals to the 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 29 matching lines @@
   RELOADING_OPEN_STORE,
   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,
 
   // 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 31 matching lines @@
 // Key used to indicate how many accounts were last checked in with this device.
 const char kLastCheckinAccountsKey[] = "last_checkin_accounts_count";
 // Key used to timestamp last checkin (marked with G services settings update).
 const char kLastCheckinTimeKey[] = "last_checkin_time";
 // Lowest lexicographically ordered account key.
 // Used for prefixing account information.
 const char kAccountKeyStart[] = "account1-";
 // Key guaranteed to be higher than all account keys.
 // 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";
 
 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);
 }
@@ skipping 19 matching lines @@
 }
 
 std::string MakeAccountKey(const std::string& account_id) {
   return kAccountKeyStart + account_id;
 }
 
 std::string ParseAccountKey(const std::string& key) {
   return key.substr(arraysize(kAccountKeyStart) - 1);
 }
 
+std::string MakeHeartbeatKey(const std::string& scope) {

[Nicolas Zea, 2015/05/04 17:45:28]

remind me, what is the scope derived from?

[fgorski, 2015/05/04 18:14:54]

It is simply a token uniquely identifying component requesting the custom
heartbeat interval.

+  return kHeartbeatKeyStart + scope;
+}
+
+std::string ParseHeartbeatKey(const std::string& key) {
+  return key.substr(arraysize(kHeartbeatKeyStart) - 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 37 matching lines @@
   void SetGServicesSettings(
       const std::map<std::string, std::string>& settings,
       const std::string& digest,
       const UpdateCallback& callback);
   void AddAccountMapping(const AccountMapping& account_mapping,
                          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 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);
 
   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 40 matching lines @@
                            &result->last_checkin_accounts)) {
     return LOADING_LAST_CHECKIN_INFO_FAILED;
   }
   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;
+    return LOADING_LAST_TOKEN_TIME_FAILED;
+  if (!LoadHeartbeatIntervals(&result->heartbeat_intervals))
+    return LOADING_HEARTBEAT_INTERVALS_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 394 matching lines @@
   const leveldb::Status s =
       db_->Put(write_options,
                MakeSlice(kLastTokenFetchTimeKey),
                MakeSlice(base::Int64ToString(time.ToInternalValue())));
 
   if (!s.ok())
     LOG(ERROR) << "LevelDB setting last token fetching time: " << s.ToString();
   foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, s.ok()));
 }
 
+void GCMStoreImpl::Backend::AddHeartbeatInterval(
+    const std::string& scope,
+    int interval_ms,
+    const UpdateCallback& callback) {
+  DVLOG(1) << "Saving a heartbeat interval: scope: " << scope
+           << " interval: " << interval_ms << "ms.";
+  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 data = base::IntToString(interval_ms);
+  std::string key = MakeHeartbeatKey(scope);
+  const leveldb::Status s =
+      db_->Put(write_options, MakeSlice(key), MakeSlice(data));
+  if (!s.ok())
+    LOG(ERROR) << "LevelDB adding heartbeat interval failed: " << s.ToString();
+  foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, s.ok()));
+}
+
+void GCMStoreImpl::Backend::RemoveHeartbeatInterval(
+    const std::string& scope,
+    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 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::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 221 matching lines @@
         "Failed to restore last token fetching time. Using default = 0.";
     time_internal = 0LL;
   }
 
   // In case we cannot read last token fetching time, we default it to 0.
   *last_token_fetch_time = base::Time::FromInternalValue(time_internal);
 
   return true;
 }
 
+bool GCMStoreImpl::Backend::LoadHeartbeatIntervals(
+    std::map<std::string, int>* heartbeat_intervals) {
+  leveldb::ReadOptions read_options;
+  read_options.verify_checksums = true;
+
+  scoped_ptr<leveldb::Iterator> iter(db_->NewIterator(read_options));
+  for (iter->Seek(MakeSlice(kHeartbeatKeyStart));
+       iter->Valid() && iter->key().ToString() < kHeartbeatKeyEnd;
+       iter->Next()) {
+    std::string scope = ParseHeartbeatKey(iter->key().ToString());
+    int interval_ms;
+    if (!base::StringToInt(iter->value().ToString(), &interval_ms)) {
+      DVLOG(1) << "Failed to parse heartbeat interval info with scope: "
+               << scope;
+      return false;
+    }
+    DVLOG(1) << "Found heartbeat interval with scope: " << scope
+             << " interval: " << interval_ms << "ms.";
+    (*heartbeat_intervals)[scope] = interval_ms;
+  }
+
+  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 210 matching lines @@
 void GCMStoreImpl::SetLastTokenFetchTime(const base::Time& time,
                                          const UpdateCallback& callback) {
   blocking_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&GCMStoreImpl::Backend::SetLastTokenFetchTime,
                  backend_,
                  time,
                  callback));
 }
 
+void GCMStoreImpl::AddHeartbeatInterval(const std::string& scope,
+                                        int interval_ms,
+                                        const UpdateCallback& callback) {
+  blocking_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&GCMStoreImpl::Backend::AddHeartbeatInterval,
+                 backend_,
+                 scope,
+                 interval_ms,
+                 callback));
+}
+
+void GCMStoreImpl::RemoveHeartbeatInterval(const std::string& scope,
+                                           const UpdateCallback& callback) {
+  blocking_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&GCMStoreImpl::Backend::RemoveHeartbeatInterval,
+                 backend_,
+                 scope,
+                 callback));
+}
+
 void GCMStoreImpl::SetValueForTesting(const std::string& key,
                                       const std::string& value,
                                       const UpdateCallback& callback) {
   blocking_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&GCMStoreImpl::Backend::SetValue,
                  backend_,
                  key,
                  value,
                  callback));
@@ skipping 50 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