Signup for GCM upstream notifications

chrome/browser/chromeos/policy/heartbeat_scheduler.cc

 // Copyright (c) 2015 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 "chrome/browser/chromeos/policy/heartbeat_scheduler.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #include "chrome/common/chrome_switches.h"
 #include "components/gcm_driver/gcm_driver.h"
 
 namespace {
 const int kMinHeartbeatIntervalMs = 30 * 1000;  // 30 seconds
 const int kMaxHeartbeatIntervalMs = 24 * 60 * 60 * 1000;  // 24 hours
 
 // Our sender ID we send up with all of our GCM messages.
 const char* kHeartbeatGCMAppID = "com.google.chromeos.monitoring";
 
 // The default destination we send our GCM messages to.
 const char* kHeartbeatGCMDestinationID = "1013309121859";
 const char* kHeartbeatGCMSenderSuffix = "@google.com";
 
-const char* kMonitoringMessageTypeKey = "type";
+// Destination of upstream notification sign up message.
+const char* kUpstreamNotificationSignUpDestinationID =
+    "https://gcm.googleapis.com/gcm/gcm.event_tracker";
+
+// A bit mask, listening events of upstream notification.
+const char* kUpstreamNotificationSignUpListeningEvents =
+    "7";  // START | DISCONNECTED | HEARTBEAT
+
+const char* kGcmMessageTypeKey = "type";
 const char* kHeartbeatTimestampKey = "timestamp";
 const char* kHeartbeatDomainNameKey = "domain_name";
 const char* kHeartbeatDeviceIDKey = "device_id";
 const char* kHeartbeatTypeValue = "hb";
+const char* kUpstreamNotificationNotifyKey = "notify";
 
 // If we get an error registering with GCM, try again in two minutes.
 const int64 kRegistrationRetryDelayMs = 2 * 60 * 1000;
 
+const char* kHeartbeatSchedulerScope =
+    "policy.heartbeat_scheduler.upstream_notification";
+
 // Returns the destination ID for GCM heartbeats.
 std::string GetDestinationID() {
   std::string receiver_id = kHeartbeatGCMDestinationID;
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kMonitoringDestinationID)) {
     receiver_id = base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
         switches::kMonitoringDestinationID);
   }
   return receiver_id;
 }
@@ skipping 156 matching lines @@
   if (chromeos::CrosSettingsProvider::TRUSTED != settings->PrepareTrustedValues(
           base::Bind(&HeartbeatScheduler::RefreshHeartbeatSettings,
                      weak_factory_.GetWeakPtr()))) {
     return;
   }
 
   // CrosSettings are trusted - update our cached settings (we cache the
   // value because CrosSettings can become untrusted at arbitrary times and we
   // want to use the last trusted value).
   int frequency;
-  if (settings->GetInteger(chromeos::kHeartbeatFrequency, &frequency))
+  if (settings->GetInteger(chromeos::kHeartbeatFrequency, &frequency)) {
     heartbeat_interval_ = EnsureValidHeartbeatInterval(
         base::TimeDelta::FromMilliseconds(frequency));
+  }
+
+  gcm_driver_->AddHeartbeatInterval(kHeartbeatSchedulerScope,
+                                    heartbeat_interval_.InMilliseconds());
 
   bool enabled;
   if (settings->GetBoolean(chromeos::kHeartbeatEnabled, &enabled))
     heartbeat_enabled_ = enabled;
 
   if (!heartbeat_enabled_) {
     // Heartbeats are no longer enabled - cancel our callback and any
     // outstanding registration attempts and disconnect from GCM so the
     // connection can be shut down. If heartbeats are re-enabled later, we
     // will re-register with GCM.
     heartbeat_callback_.Cancel();
     ShutdownGCM();
   } else {
     // Schedule a new upload with the new frequency.
     ScheduleNextHeartbeat();
   }
 
   DVLOG(1) << "heartbeat enabled: " << heartbeat_enabled_;
   DVLOG(1) << "heartbeat frequency: " << heartbeat_interval_;
 }
 
 void HeartbeatScheduler::ShutdownGCM() {
   registration_helper_.reset();
   registration_id_.clear();
   if (registered_app_handler_) {
     registered_app_handler_ = false;
+    gcm_driver_->RemoveHeartbeatInterval(kHeartbeatSchedulerScope);
     gcm_driver_->RemoveAppHandler(kHeartbeatGCMAppID);
+    gcm_driver_->RemoveConnectionObserver(this);
   }
 }
 
 base::TimeDelta HeartbeatScheduler::EnsureValidHeartbeatInterval(
     const base::TimeDelta& interval) {
   const base::TimeDelta min = base::TimeDelta::FromMilliseconds(
       kMinHeartbeatIntervalMs);
   const base::TimeDelta max = base::TimeDelta::FromMilliseconds(
       kMaxHeartbeatIntervalMs);
   if (interval < min) {
@@ skipping 12 matching lines @@
   if (!heartbeat_enabled_)
     return;
 
   if (registration_id_.empty()) {
     // We are not registered with the GCM service yet, so kick off registration.
     if (!registration_helper_) {
       // Add ourselves as an AppHandler - this is required in order to setup
       // a GCM connection.
       registered_app_handler_ = true;
       gcm_driver_->AddAppHandler(kHeartbeatGCMAppID, this);
+      gcm_driver_->AddConnectionObserver(this);
       registration_helper_.reset(new HeartbeatRegistrationHelper(
           gcm_driver_, task_runner_));
       registration_helper_->Register(
           base::Bind(&HeartbeatScheduler::OnRegistrationComplete,
                      weak_factory_.GetWeakPtr()));
     }
     return;
   }
 
   // Calculate when to fire off the next update (if it should have already
@@ skipping 14 matching lines @@
   registration_helper_.reset();
   registration_id_ = registration_id;
 
   if (cloud_policy_client_) {
     // TODO(binjin): Avoid sending the same GCM id to the server.
     // See http://crbug.com/516375
     cloud_policy_client_->UpdateGcmId(
         registration_id,
         base::Bind(&HeartbeatScheduler::OnGcmIdUpdateRequestSent,
                    weak_factory_.GetWeakPtr()));
+    SignUpUpstreamNotification();
   }
 
   // Now that GCM registration is complete, start sending heartbeats.
   ScheduleNextHeartbeat();
 }
 
 void HeartbeatScheduler::SendHeartbeat() {
   DCHECK(!registration_id_.empty());
   if (!gcm_driver_ || !heartbeat_enabled_)
     return;
 
   gcm::OutgoingMessage message;
   message.time_to_live = heartbeat_interval_.InSeconds();
   // Just use the current timestamp as the message ID - if the user changes the
   // time and we send a message with the same ID that we previously used, no
   // big deal (the new message will replace the old, which is the behavior we
   // want anyway, per:
   // https://developer.chrome.com/apps/cloudMessaging#send_messages
   message.id = base::Int64ToString(
       base::Time::NowFromSystemTime().ToInternalValue());
-  message.data[kMonitoringMessageTypeKey] = kHeartbeatTypeValue;
+  message.data[kGcmMessageTypeKey] = kHeartbeatTypeValue;
   message.data[kHeartbeatTimestampKey] = base::Int64ToString(
       base::Time::NowFromSystemTime().ToJavaTime());
   message.data[kHeartbeatDomainNameKey] = enrollment_domain_;
   message.data[kHeartbeatDeviceIDKey] = device_id_;
   gcm_driver_->Send(kHeartbeatGCMAppID,
                     GetDestinationID() + kHeartbeatGCMSenderSuffix,
                     message,
                     base::Bind(&HeartbeatScheduler::OnHeartbeatSent,
                                weak_factory_.GetWeakPtr()));
 }
 
+void HeartbeatScheduler::SignUpUpstreamNotification() {
+  DCHECK(gcm_driver_);
+
+  if (registration_id_.empty())
+    return;
+
+  gcm::OutgoingMessage message;
+  message.id =
+      base::Int64ToString(base::Time::NowFromSystemTime().ToInternalValue());
+  message.data[kGcmMessageTypeKey] = kUpstreamNotificationSignUpListeningEvents;
+  message.data[kUpstreamNotificationNotifyKey] =
+      GetDestinationID() + kHeartbeatGCMSenderSuffix;
+  gcm_driver_->Send(kHeartbeatGCMAppID,
+                    kUpstreamNotificationSignUpDestinationID, message,
+                    base::Bind(&HeartbeatScheduler::OnUpstreamNotificationSent,
+                               weak_factory_.GetWeakPtr()));
+}
+
 void HeartbeatScheduler::OnHeartbeatSent(const std::string& message_id,
                                          gcm::GCMClient::Result result) {
   DVLOG(1) << "Monitoring heartbeat sent - result = " << result;
   // Don't care if the result was successful or not - just schedule the next
   // heartbeat.
   DLOG_IF(ERROR, result != gcm::GCMClient::SUCCESS) <<
       "Error sending monitoring heartbeat: " << result;
   last_heartbeat_ = base::Time::NowFromSystemTime();
   ScheduleNextHeartbeat();
 }
 
+void HeartbeatScheduler::OnUpstreamNotificationSent(
+    const std::string& message_id,
+    gcm::GCMClient::Result result) {
+  DVLOG(1) << "Upstream notification signup message sent - result = " << result;
+  DLOG_IF(ERROR, result != gcm::GCMClient::SUCCESS)
+      << "Error sending upstream notification signup message: " << result;
+}
+
 HeartbeatScheduler::~HeartbeatScheduler() {
   ShutdownGCM();
 }
 
 void HeartbeatScheduler::ShutdownHandler() {
   // This should never be called, because BrowserProcessImpl::StartTearDown()
   // should shutdown the BrowserPolicyConnector (which destroys this object)
   // before the GCMDriver. Our goal is to make sure that this object is always
   // shutdown before GCMDriver is shut down, rather than trying to handle the
   // case when GCMDriver goes away.
@@ skipping 14 matching lines @@
     const std::string& app_id,
     const gcm::GCMClient::SendErrorDetails& details) {
   // Ignore send errors - we already are notified above in OnHeartbeatSent().
 }
 
 void HeartbeatScheduler::OnSendAcknowledged(const std::string& app_id,
                                             const std::string& message_id) {
   DVLOG(1) << "Heartbeat sent with message_id: " << message_id;
 }
 
+void HeartbeatScheduler::OnConnected(const net::IPEndPoint&) {
+  SignUpUpstreamNotification();
+}
+
 void HeartbeatScheduler::OnGcmIdUpdateRequestSent(bool success) {
   // TODO(binjin): Handle the failure, probably by exponential backoff.
   LOG_IF(WARNING, !success) << "Failed to send GCM id to DM server";
 }
 
 }  // namespace policy