Link GCM heartbeat with wake on wifi preference

google_apis/gcm/engine/heartbeat_manager.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/heartbeat_manager.h"
 
+#include "base/callback.h"
 #include "base/metrics/histogram.h"
+#include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "google_apis/gcm/protocol/mcs.pb.h"
 #include "net/base/network_change_notifier.h"
 
 namespace gcm {
 
 namespace {
 // The default heartbeat when on a mobile or unknown network .
 const int64 kCellHeartbeatDefaultMs = 1000 * 60 * 28;  // 28 minutes.
 // The default heartbeat when on WiFi (also used for ethernet).
 const int64 kWifiHeartbeatDefaultMs = 1000 * 60 * 15;  // 15 minutes.
 // The default heartbeat ack interval.
 const int64 kHeartbeatAckDefaultMs = 1000 * 60 * 1;  // 1 minute.
 // The period at which to check if the heartbeat time has passed. Used to
 // protect against platforms where the timer is delayed by the system being
 // suspended.
 const int kHeartbeatMissedCheckMs = 1000 * 60 * 5;  // 5 minutes.
 }  // namespace
 
-HeartbeatManager::HeartbeatManager(scoped_ptr<base::Timer> heartbeat_timer)
+HeartbeatManager::HeartbeatManager()
     : waiting_for_ack_(false),
       heartbeat_interval_ms_(0),
       server_interval_ms_(0),
-      heartbeat_timer_(heartbeat_timer.Pass()),
+      heartbeat_timer_(new base::Timer(true /* retain_user_task */,
+                                       false /* is_repeating */)),
       weak_ptr_factory_(this) {}
 
 HeartbeatManager::~HeartbeatManager() {}
 
 void HeartbeatManager::Start(
     const base::Closure& send_heartbeat_callback,
     const base::Closure& trigger_reconnect_callback) {
   DCHECK(!send_heartbeat_callback.is_null());
   DCHECK(!trigger_reconnect_callback.is_null());
   send_heartbeat_callback_ = send_heartbeat_callback;
@@ skipping 31 matching lines @@
   server_interval_ms_ = config.interval_ms();
 }
 
 base::TimeTicks HeartbeatManager::GetNextHeartbeatTime() const {
   if (heartbeat_timer_->IsRunning())
     return heartbeat_timer_->desired_run_time();
   else
     return base::TimeTicks();
 }
 
+void HeartbeatManager::UpdateHeartbeatTimer(scoped_ptr<base::Timer> timer) {
+  bool was_running = heartbeat_timer_->IsRunning();
+  base::TimeDelta remaining_delay =
+      heartbeat_timer_->desired_run_time() - base::TimeTicks::Now();
+  base::Closure timer_task(heartbeat_timer_->user_task());
+
+  heartbeat_timer_->Stop();
+  heartbeat_timer_ = timer.Pass();
+
+  if (was_running)
+    heartbeat_timer_->Start(FROM_HERE, remaining_delay, timer_task);
+}
+
 void HeartbeatManager::OnHeartbeatTriggered() {
   // Reset the weak pointers used for heartbeat checks.
   weak_ptr_factory_.InvalidateWeakPtrs();
 
   if (waiting_for_ack_) {
     LOG(WARNING) << "Lost connection to MCS, reconnecting.";
     Stop();
     trigger_reconnect_callback_.Run();
     return;
   }
@@ skipping 60 matching lines @@
 
   // Otherwise check again later.
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&HeartbeatManager::CheckForMissedHeartbeat,
                  weak_ptr_factory_.GetWeakPtr()),
       base::TimeDelta::FromMilliseconds(kHeartbeatMissedCheckMs));
 }
 
 }  // namespace gcm