Refactored DeviceStatusCollector to enable truely asynchronous status queries

chrome/browser/chromeos/policy/status_uploader_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/status_uploader.h"
 
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/test/test_simple_task_runner.h"
@@ skipping 35 matching lines @@
 namespace em = enterprise_management;
 
 namespace {
 
 class MockDeviceStatusCollector : public policy::DeviceStatusCollector {
  public:
   explicit MockDeviceStatusCollector(PrefService* local_state)
       : DeviceStatusCollector(
             local_state,
             nullptr,
-            policy::DeviceStatusCollector::LocationUpdateRequester(),
             policy::DeviceStatusCollector::VolumeInfoFetcher(),
             policy::DeviceStatusCollector::CPUStatisticsFetcher(),
             policy::DeviceStatusCollector::CPUTempFetcher()) {}
 
-  MOCK_METHOD1(
-      GetDeviceStatusAsync,
-      void(const policy::DeviceStatusCollector::DeviceStatusCallback&));
-  MOCK_METHOD1(
-      GetDeviceSessionStatusAsync,
-      void(const policy::DeviceStatusCollector::DeviceSessionStatusCallback&));
+  MOCK_METHOD1(GetDeviceAndSessionStatusAsync,
+               void(const policy::DeviceStatusCollector::StatusCallback&));
 
   // Explicit mock implementation declared here, since gmock::Invoke can't
   // handle returning non-moveable types like scoped_ptr.
   std::unique_ptr<policy::DeviceLocalAccount> GetAutoLaunchedKioskSessionInfo()
       override {
     return base::MakeUnique<policy::DeviceLocalAccount>(
         policy::DeviceLocalAccount::TYPE_KIOSK_APP, "account_id", "app_id",
         "update_url");
   }
 };
@@ skipping 23 matching lines @@
   void TearDown() override {
     content::RunAllBlockingPoolTasksUntilIdle();
   }
 
   // Given a pending task to upload status, mocks out a server response.
   void RunPendingUploadTaskAndCheckNext(const StatusUploader& uploader,
                                         base::TimeDelta expected_delay) {
     // Running the task should pass two callbacks into GetDeviceStatusAsync
     // and GetDeviceSessionStatusAsync. We'll grab these two callbacks.
     EXPECT_TRUE(task_runner_->HasPendingTask());
-    DeviceStatusCollector::DeviceStatusCallback ds_callback;
-    DeviceStatusCollector::DeviceSessionStatusCallback ss_callback;
-    EXPECT_CALL(*collector_ptr_, GetDeviceStatusAsync(_))
-        .WillOnce(SaveArg<0>(&ds_callback));
-    EXPECT_CALL(*collector_ptr_, GetDeviceSessionStatusAsync(_))
-        .WillOnce(SaveArg<0>(&ss_callback));
+    DeviceStatusCollector::StatusCallback status_callback;
+    EXPECT_CALL(*collector_ptr_, GetDeviceAndSessionStatusAsync(_))
+        .WillOnce(SaveArg<0>(&status_callback));
     task_runner_->RunPendingTasks();
     testing::Mock::VerifyAndClearExpectations(&device_management_service_);
 
     // Send some "valid" (read: non-nullptr) to the device/session callbacks
     // in order to simulate valid status data.
     std::unique_ptr<em::DeviceStatusReportRequest> device_status =
         base::MakeUnique<em::DeviceStatusReportRequest>();
     std::unique_ptr<em::SessionStatusReportRequest> session_status =
         base::MakeUnique<em::SessionStatusReportRequest>();
 
     // Running the session and device callbacks should trigger
     // CloudPolicyClient::UploadDeviceStatus.
     CloudPolicyClient::StatusCallback callback;
     EXPECT_CALL(client_, UploadDeviceStatus(_, _, _))
         .WillOnce(SaveArg<2>(&callback));
-    ds_callback.Run(std::move(device_status));
-    ss_callback.Run(std::move(session_status));
+    status_callback.Run(std::move(device_status), std::move(session_status));
     testing::Mock::VerifyAndClearExpectations(&device_management_service_);
 
     // Make sure no status upload is queued up yet (since an upload is in
     // progress).
     EXPECT_FALSE(task_runner_->HasPendingTask());
 
     // Now invoke the response.
     callback.Run(true);
 
     // Now that the previous request was satisfied, a task to do the next
@@ skipping 64 matching lines @@
   EXPECT_EQ(1U, task_runner_->NumPendingTasks());
 }
 
 TEST_F(StatusUploaderTest, ResetTimerAfterFailedStatusCollection) {
   StatusUploader uploader(&client_, std::move(collector_), task_runner_);
 
   // Running the queued task should pass two callbacks into GetDeviceStatusAsync
   // and GetDeviceSessionStatusAsync. We'll grab these two callbacks and send
   // nullptrs to them in order to simulate failure to get status.
   EXPECT_EQ(1U, task_runner_->NumPendingTasks());
-  DeviceStatusCollector::DeviceStatusCallback ds_callback;
-  DeviceStatusCollector::DeviceSessionStatusCallback ss_callback;
-  EXPECT_CALL(*collector_ptr_, GetDeviceStatusAsync(_))
-      .WillOnce(SaveArg<0>(&ds_callback));
-  EXPECT_CALL(*collector_ptr_, GetDeviceSessionStatusAsync(_))
-      .WillOnce(SaveArg<0>(&ss_callback));
+  DeviceStatusCollector::StatusCallback status_callback;
+  EXPECT_CALL(*collector_ptr_, GetDeviceAndSessionStatusAsync(_))
+      .WillOnce(SaveArg<0>(&status_callback));
   task_runner_->RunPendingTasks();
   testing::Mock::VerifyAndClearExpectations(&device_management_service_);
 
   // Running the session and device callbacks should trigger
   // StatusUploader::OnStatusReceived, which in turn should recognize the
   // failure to get status and queue another status upload.
   std::unique_ptr<em::DeviceStatusReportRequest> invalid_device_status;
-  ds_callback.Run(std::move(invalid_device_status));
-  EXPECT_EQ(0U, task_runner_->NumPendingTasks());  // Not yet...
-
   std::unique_ptr<em::SessionStatusReportRequest> invalid_session_status;
-  ss_callback.Run(std::move(invalid_session_status));
-  EXPECT_EQ(1U, task_runner_->NumPendingTasks());  // but now!
+  status_callback.Run(std::move(invalid_device_status),
+                      std::move(invalid_session_status));
+  EXPECT_EQ(1U, task_runner_->NumPendingTasks());
 
   // Check the delay of the queued upload
   const base::TimeDelta expected_delay = base::TimeDelta::FromMilliseconds(
       StatusUploader::kDefaultUploadDelayMs);
   CheckPendingTaskDelay(uploader, expected_delay);
 }
 
 TEST_F(StatusUploaderTest, ChangeFrequency) {
   StatusUploader uploader(&client_, std::move(collector_), task_runner_);
   // Change the frequency. The new frequency should be reflected in the timing
@@ skipping 39 matching lines @@
   // Now mock video capture, and no session data should be allowed.
   MediaCaptureDevicesDispatcher::GetInstance()->OnMediaRequestStateChanged(
       0, 0, 0, GURL("http://www.google.com"),
       content::MEDIA_DEVICE_VIDEO_CAPTURE,
       content::MEDIA_REQUEST_STATE_OPENING);
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(uploader.IsSessionDataUploadAllowed());
 }
 
 }  // namespace policy