Refactored DeviceStatusCollector to enable truely asynchronous status queries

chrome/browser/chromeos/policy/status_uploader.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 <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 158 matching lines @@
   // If a video or audio capture stream is opened, set a flag so we disallow
   // upload of potentially sensitive data.
   if (state == content::MEDIA_REQUEST_STATE_OPENING &&
       (stream_type == content::MEDIA_DEVICE_AUDIO_CAPTURE ||
        stream_type == content::MEDIA_DEVICE_VIDEO_CAPTURE)) {
     has_captured_media_ = true;
   }
 }
 
 void StatusUploader::UploadStatus() {
-  // Submit the responses of the asynchronous calls to collector_
-  // in a small ref-counted state tracker class, so that we can
-  //   a) track that both responses fired and
-  //   b) quick subsequent calls to UploadStatus() won't mess up state.
-  scoped_refptr<StatusGetter> getter(
-      new StatusGetter(weak_factory_.GetWeakPtr()));
-
-  // Note that the two base::Binds keep references to getter,
-  // so getter stays alive until both callbacks are called.
-  collector_->GetDeviceStatusAsync(
-      base::Bind(&StatusGetter::OnDeviceStatusReceived, getter));
-
-  collector_->GetDeviceSessionStatusAsync(
-      base::Bind(&StatusGetter::OnSessionStatusReceived, getter));
-}
-
-StatusUploader::StatusGetter::StatusGetter(
-    const base::WeakPtr<StatusUploader>& uploader)
-    : uploader_(uploader),
-      device_status_response_received_(false),
-      session_status_response_received_(false) {}
-
-StatusUploader::StatusGetter::~StatusGetter() {}
-
-void StatusUploader::StatusGetter::OnDeviceStatusReceived(
-    std::unique_ptr<em::DeviceStatusReportRequest> device_status) {
-  DCHECK(!device_status_response_received_);
-  device_status_ = std::move(device_status);
-  device_status_response_received_ = true;
-  CheckDone();
-}
-
-void StatusUploader::StatusGetter::OnSessionStatusReceived(
-    std::unique_ptr<em::SessionStatusReportRequest> session_status) {
-  DCHECK(!session_status_response_received_);
-  session_status_ = std::move(session_status);
-  session_status_response_received_ = true;
-  CheckDone();
-}
-
-void StatusUploader::StatusGetter::CheckDone() {
-  // Did we receive BOTH responses?
-  if (device_status_response_received_ && session_status_response_received_) {
-    // Notify the uploader if it's still alive
-    StatusUploader* uploader = uploader_.get();
-    if (uploader) {
-      uploader->OnStatusReceived(std::move(device_status_),
-                                 std::move(session_status_));
-      // Reset just to make sure this doesn't get called multiple times
-      uploader_.reset();
-    }
-  }
+  // Gather status in the background.
+  collector_->GetDeviceAndSessionStatusAsync(base::Bind(
+      &StatusUploader::OnStatusReceived, weak_factory_.GetWeakPtr()));
 }
 
 void StatusUploader::OnStatusReceived(
     std::unique_ptr<em::DeviceStatusReportRequest> device_status,
     std::unique_ptr<em::SessionStatusReportRequest> session_status) {
   bool have_device_status = device_status != nullptr;
   bool have_session_status = session_status != nullptr;
   if (!have_device_status && !have_session_status) {
     CHROMEOS_SYSLOG(WARNING)
         << "Skipping status upload because no data to upload";
@@ skipping 22 matching lines @@
 
   // If the upload was successful, tell the collector so it can clear its cache
   // of pending items.
   if (success)
     collector_->OnSubmittedSuccessfully();
 
   ScheduleNextStatusUpload();
 }
 
 }  // namespace policy