Send GCM id to DMServer

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
@@ skipping 134 matching lines @@
     case gcm::GCMClient::ASYNC_OPERATION_PENDING:
     case gcm::GCMClient::TTL_EXCEEDED:
     default:
       NOTREACHED() << "Unexpected GCMDriver::Register() result: " << result;
       break;
   }
 }
 
 HeartbeatScheduler::HeartbeatScheduler(
     gcm::GCMDriver* driver,
+    policy::CloudPolicyClient* cloud_policy_client,
     const std::string& enrollment_domain,
     const std::string& device_id,
     const scoped_refptr<base::SequencedTaskRunner>& task_runner)
     : task_runner_(task_runner),
       enrollment_domain_(enrollment_domain),
       device_id_(device_id),
       heartbeat_enabled_(false),
-      heartbeat_interval_(base::TimeDelta::FromMilliseconds(
-          kDefaultHeartbeatIntervalMs)),
+      heartbeat_interval_(
+          base::TimeDelta::FromMilliseconds(kDefaultHeartbeatIntervalMs)),
+      cloud_policy_client_(cloud_policy_client),
       gcm_driver_(driver),
       weak_factory_(this) {
   // If no GCMDriver (e.g. this is loaded as part of an unrelated unit test)
   // do nothing as no heartbeats can be sent.
   if (!gcm_driver_)
     return;
 
   heartbeat_frequency_observer_ =
       chromeos::CrosSettings::Get()->AddSettingsObserver(
           chromeos::kHeartbeatFrequency,
           base::Bind(&HeartbeatScheduler::RefreshHeartbeatSettings,
                      base::Unretained(this)));
 
   heartbeat_enabled_observer_ =
       chromeos::CrosSettings::Get()->AddSettingsObserver(
           chromeos::kHeartbeatEnabled,
           base::Bind(&HeartbeatScheduler::RefreshHeartbeatSettings,
                      base::Unretained(this)));
 
   // Update the heartbeat frequency from settings. This will trigger a
   // heartbeat as appropriate once the settings have been refreshed.
   RefreshHeartbeatSettings();
 }
 
+void HeartbeatScheduler::SetCloudPolicyClientForTesting(
+    policy::CloudPolicyClient* client) {
+  cloud_policy_client_ = client;
+}
+
 void HeartbeatScheduler::RefreshHeartbeatSettings() {
   // Attempt to fetch the current value of the reporting settings.
   // If trusted values are not available, register this function to be called
   // back when they are available.
   chromeos::CrosSettings* settings = chromeos::CrosSettings::Get();
   if (chromeos::CrosSettingsProvider::TRUSTED != settings->PrepareTrustedValues(
           base::Bind(&HeartbeatScheduler::RefreshHeartbeatSettings,
                      weak_factory_.GetWeakPtr()))) {
     return;
   }
@@ skipping 84 matching lines @@
   task_runner_->PostDelayedTask(
       FROM_HERE, heartbeat_callback_.callback(), delay);
 }
 
 void HeartbeatScheduler::OnRegistrationComplete(
     const std::string& registration_id) {
   DCHECK(!registration_id.empty());
   registration_helper_.reset();
   registration_id_ = registration_id;
 
+  if (cloud_policy_client_) {
+    cloud_policy_client_->UpdateGcmIdMapping(

[Andrew T Wilson (Slow), 2015/08/03 13:52:26]

Log a bug and add a TODO() here to avoid unnecessary calls to update the GcmId
if it hasn't changed.

[binjin, 2015/08/03 17:54:25]

Done.

+        registration_id,
+        base::Bind(&HeartbeatScheduler::OnGcmIdMappingRequestSent,
+                   base::Unretained(this)));

[Andrew T Wilson (Slow), 2015/08/03 13:52:26]

Use a weak pointer here instead of Unretained().

[binjin, 2015/08/03 17:54:25]

Done.

+  }
+
   // 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;
@@ skipping 55 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::OnGcmIdMappingRequestSent(bool status) {
+  latest_gcm_id_mapping_succeeded_ = status;

[Andrew T Wilson (Slow), 2015/08/03 13:52:26]

Why do we bother having a callback here at all? We don't really care if our
request succeeds or not (no need to track it in
latest_gcm_id_mapping_succeeded). At the most, we might log something, and
that's it.

[binjin, 2015/08/03 17:54:25]

Okay, removed the latest_gcm_id_mapping_succeeded in this CL, leaving the
callback for logging purpose.

+  if (!status)
+    LOG(WARNING) << "Failed to send GCM id to DM server";

[Andrew T Wilson (Slow), 2015/08/03 13:52:26]

Use LOG_IF() instead of if() { LOG() }

[binjin, 2015/08/03 17:54:25]

Done.

+}
+
 }  // namespace policy