[GCM] Be more aggressive about triggering heartbeats when waking from sleep

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/location.h"
 #include "base/metrics/histogram.h"
 #include "base/power_monitor/power_monitor.h"
 #include "base/thread_task_runner_handle.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 int kCellHeartbeatDefaultMs = 1000 * 60 * 28;  // 28 minutes.
 // The default heartbeat when on WiFi (also used for ethernet).
 const int kWifiHeartbeatDefaultMs = 1000 * 60 * 15;  // 15 minutes.
 // The default heartbeat ack interval.
 const int kHeartbeatAckDefaultMs = 1000 * 60 * 1;  // 1 minute.
 // Minimum allowed client default heartbeat interval.
 const int kMinClientHeartbeatIntervalMs = 1000 * 60 * 2;  // 2 minutes.
+// Minimum time spent sleeping before we force a new heartbeat.
+const int kMinSuspendTimeMs = 1000 * 10; // 10 seconds.
 
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
 // 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.  Only needed on linux because the other OSes provide a standard
 // way to be notified of system suspend and resume events.
 const int kHeartbeatMissedCheckMs = 1000 * 60 * 5;  // 5 minutes.
 #endif  // defined(OS_LINUX) && !defined(OS_CHROMEOS)
 
 }  // namespace
@@ skipping 73 matching lines @@
       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::OnSuspend() {
+  // The system is going to sleep. Record the time, so on resume we know how
+  // much time the machine was suspended.
+  suspend_time_ = base::Time::Now();
+}
+
 void HeartbeatManager::OnResume() {
-  CheckForMissedHeartbeat();
+  // The system just resumed from sleep. It's likely that the connection to
+  // MCS was silently lost during that time, even if a heartbeat is not yet
+  // due. Force a heartbeat to detect if the connection is still good.
+  base::TimeDelta elapsed = base::Time::Now() - suspend_time_;
+  UMA_HISTOGRAM_LONG_TIMES("GCM.SuspendTime", elapsed);
+
+  // Make sure a minimum amount of time has passed before forcing a heartbeat to
+  // avoid any tight loop scenarios.
+  if (elapsed > base::TimeDelta::FromMilliseconds(kMinSuspendTimeMs))
+    OnHeartbeatTriggered();
 }
 
 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.";
     ResetConnection(ConnectionFactory::HEARTBEAT_FAILURE);
     return;
@@ skipping 125 matching lines @@
       interval <= max_heartbeat_interval;
 }
 
 void HeartbeatManager::ResetConnection(
     ConnectionFactory::ConnectionResetReason reason) {
   Stop();
   trigger_reconnect_callback_.Run(reason);
 }
 
 }  // namespace gcm