Send GCM id to DMServer

chrome/browser/chromeos/policy/heartbeat_scheduler_unittest.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 "base/strings/string_number_conversions.h"
 #include "base/test/test_simple_task_runner.h"
 #include "chrome/browser/chromeos/settings/scoped_cros_settings_test_helper.h"
 #include "chromeos/settings/cros_settings_names.h"
 #include "components/gcm_driver/fake_gcm_driver.h"
+#include "components/policy/core/common/cloud/cloud_policy_client.h"
+#include "components/policy/core/common/cloud/mock_cloud_policy_client.h"
 #include "content/public/test/test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::SaveArg;
 
 namespace {
 const char* const kFakeEnrollmentDomain = "example.com";
 const char* const kFakeDeviceId = "fake_device_id";
 const char* const kHeartbeatGCMAppID = "com.google.chromeos.monitoring";
+const char* const kRegistrationId = "registration_id";
+const char* const kDMToken = "fake_dm_token";
 
 class MockGCMDriver : public testing::StrictMock<gcm::FakeGCMDriver> {
  public:
   MockGCMDriver() {
   }
 
   ~MockGCMDriver() override {
   }
 
   MOCK_METHOD2(RegisterImpl,
                void(const std::string&, const std::vector<std::string>&));
   MOCK_METHOD3(SendImpl,
                void(const std::string&,
                     const std::string&,
                     const gcm::OutgoingMessage& message));
 
   // Helper function to complete a registration previously started by
   // Register().
   void CompleteRegistration(const std::string& app_id,
                             gcm::GCMClient::Result result) {
-    RegisterFinished(app_id, "registration_id", result);
+    RegisterFinished(app_id, kRegistrationId, result);
   }
 
   // Helper function to complete a send operation previously started by
   // Send().
   void CompleteSend(const std::string& app_id,
                     const std::string& message_id,
                     gcm::GCMClient::Result result) {
     SendFinished(app_id, message_id, result);
   }
 };
 
 class HeartbeatSchedulerTest : public testing::Test {
  public:
   HeartbeatSchedulerTest()
       : task_runner_(new base::TestSimpleTaskRunner()),
-        scheduler_(
-            &gcm_driver_, kFakeEnrollmentDomain, kFakeDeviceId, task_runner_) {
-  }
+        scheduler_(&gcm_driver_,
+                   nullptr,
+                   kFakeEnrollmentDomain,
+                   kFakeDeviceId,
+                   task_runner_) {}
 
   void SetUp() override {
     settings_helper_.ReplaceProvider(chromeos::kHeartbeatEnabled);
   }
 
   void TearDown() override {
     content::RunAllBlockingPoolTasksUntilIdle();
   }
 
   void CheckPendingTaskDelay(base::Time last_heartbeat,
@@ skipping 143 matching lines @@
             message.time_to_live);
 
   // Check the values in the message payload.
   EXPECT_EQ("hb", message.data["type"]);
   int64 timestamp;
   EXPECT_TRUE(base::StringToInt64(message.data["timestamp"], &timestamp));
   EXPECT_EQ(kFakeEnrollmentDomain, message.data["domain_name"]);
   EXPECT_EQ(kFakeDeviceId, message.data["device_id"]);
 }
 
+TEST_F(HeartbeatSchedulerTest, SendGcmIdMappingUpdate) {
+  // Verifies that GCM id mapping update was sent after GCM registration.
+  policy::MockCloudPolicyClient cloud_policy_client;
+  cloud_policy_client.SetDMToken(kDMToken);
+  policy::CloudPolicyClient::StatusCallback callback;
+  EXPECT_CALL(cloud_policy_client, UpdateGcmIdMapping(kRegistrationId, _))
+      .WillOnce(SaveArg<1>(&callback));
+
+  scheduler_.SetCloudPolicyClientForTesting(&cloud_policy_client);
+
+  EXPECT_FALSE(scheduler_.latest_gcm_id_mapping_succeeded());
+
+  // Enable heartbests.
+  EXPECT_CALL(gcm_driver_, RegisterImpl(kHeartbeatGCMAppID, _));
+  EXPECT_CALL(gcm_driver_, SendImpl(kHeartbeatGCMAppID, _, _));
+  settings_helper_.SetBoolean(chromeos::kHeartbeatEnabled, true);
+  gcm_driver_.CompleteRegistration(kHeartbeatGCMAppID, gcm::GCMClient::SUCCESS);
+  task_runner_->RunPendingTasks();
+
+  // Verifies that CloudPolicyClient get the update request, and call the
+  // callback with success flag.
+  testing::Mock::VerifyAndClearExpectations(&cloud_policy_client);
+  callback.Run(true);
+
+  EXPECT_TRUE(scheduler_.latest_gcm_id_mapping_succeeded());

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

Don't think these checks of latest_gcm_id_mapping_succeeded() are useful - I
think we should get rid of that API/member variable entirely, and just make sure
that a completed registration calls client::UpdateGcmIdMapping().

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

Done.

+}
+
 }  // namespace