[GCM] Wiring heartbeat interval calls to GCMDriver

google_apis/gcm/engine/mcs_client.cc

 // Copyright 2013 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/mcs_client.h"
 
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 258 matching lines @@
 
     if (packet_info->tag == kDataMessageStanzaTag) {
       mcs_proto::DataMessageStanza* data_message =
           reinterpret_cast<mcs_proto::DataMessageStanza*>(
               packet_info->protobuf.get());
       CollapseKey collapse_key(*data_message);
       if (collapse_key.IsValid())
         collapse_key_map_[collapse_key] = packet_info;
     }
   }
+
+  // Establish if there is any custom client interval persisted from the last
+  // run and set it on the heartbeat manager.
+  custom_heartbeat_intervals_.swap(load_result->heartbeat_intervals);
+  int min_interval_ms = GetMinHeartbeatIntervalMs();
+  heartbeat_manager_.SetClientHeartbeatIntervalMs(min_interval_ms);
 }
 
 void MCSClient::Login(uint64 android_id, uint64 security_token) {
   DCHECK_EQ(state_, LOADED);
   DCHECK(android_id_ == 0 || android_id_ == android_id);
   DCHECK(security_token_ == 0 || security_token_ == security_token);
 
   if (android_id != android_id_ && security_token != security_token_) {
     DCHECK(android_id);
     DCHECK(security_token);
@@ skipping 84 matching lines @@
 void MCSClient::UpdateHeartbeatTimer(scoped_ptr<base::Timer> timer) {
   heartbeat_manager_.UpdateHeartbeatTimer(timer.Pass());
 }
 
 void MCSClient::AddHeartbeatInterval(const std::string& scope,
                                      int interval_ms) {
   if (!heartbeat_manager_.IsValidClientHeartbeatInterval(interval_ms))
     return;
 
   custom_heartbeat_intervals_[scope] = interval_ms;
-  // TODO(fgorski): Save in the gcm store as well.
+  gcm_store_->AddHeartbeatInterval(scope, interval_ms,
+                                   base::Bind(&MCSClient::OnGCMUpdateFinished,
+                                              weak_ptr_factory_.GetWeakPtr()));
 
-  int min_interval_ms = GetMinCustomHeartbeatInterval();
+  int min_interval_ms = GetMinHeartbeatIntervalMs();
   heartbeat_manager_.SetClientHeartbeatIntervalMs(min_interval_ms);
 }
 
 void MCSClient::RemoveHeartbeatInterval(const std::string& scope) {
   custom_heartbeat_intervals_.erase(scope);
-  int min_interval = GetMinCustomHeartbeatInterval();
+  gcm_store_->RemoveHeartbeatInterval(
+      scope, base::Bind(&MCSClient::OnGCMUpdateFinished,
+                        weak_ptr_factory_.GetWeakPtr()));
+
+  int min_interval = GetMinHeartbeatIntervalMs();
   heartbeat_manager_.SetClientHeartbeatIntervalMs(min_interval);
 }
 
-int MCSClient::GetMinCustomHeartbeatInterval() {
+int MCSClient::GetMinHeartbeatIntervalMs() {
   if (custom_heartbeat_intervals_.empty())
     return kNoCustomHeartbeat;
 
   int min_interval = custom_heartbeat_intervals_.begin()->second;
   for (std::map<std::string, int>::const_iterator it =
            custom_heartbeat_intervals_.begin();
        it != custom_heartbeat_intervals_.end();
        ++it) {
     if (it->second < min_interval)
       min_interval = it->second;
@@ skipping 544 matching lines @@
         reinterpret_cast<mcs_proto::DataMessageStanza*>(packet->protobuf.get());
     CollapseKey collapse_key(*data_message);
     if (collapse_key.IsValid())
       collapse_key_map_.erase(collapse_key);
   }
 
   return packet;
 }
 
 } // namespace gcm