Remote fetch device status (attributes and logs) command

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 66 matching lines @@
   // Schedule our next status upload in a minute (last_upload_ is set to the
   // start of the epoch, so this will trigger an update in
   // kMinUploadScheduleDelayMs from now).
   ScheduleNextStatusUpload();
 }
 
 StatusUploader::~StatusUploader() {
   MediaCaptureDevicesDispatcher::GetInstance()->RemoveObserver(this);
 }
 
-void StatusUploader::ScheduleNextStatusUpload() {
+void StatusUploader::ScheduleNextStatusUpload(bool immediately) {
   // Calculate when to fire off the next update (if it should have already
   // happened, this yields a TimeDelta of kMinUploadScheduleDelayMs).
   base::TimeDelta delay = std::max(
       (last_upload_ + upload_frequency_) - base::Time::NowFromSystemTime(),
       base::TimeDelta::FromMilliseconds(kMinUploadScheduleDelayMs));
+  // If we want an immediate status upload, set delay to 0.
+  if (immediately)
+    delay = base::TimeDelta();
   upload_callback_.Reset(base::Bind(&StatusUploader::UploadStatus,

[Andrew T Wilson (Slow), 2017/03/20 16:33:10]

My main concern here is that we could have a status upload in progress already
(i.e. what happens if this is called after an existing call to UploadStatus()
has already been invoked, but before OnStatusReceived() is invoked)? Does the
status collector gracefully handle two calls to GetDeviceAndSessionStatusAsync()
in parallel? 

[Ivan Šandrk, 2017/03/20 17:48:53]

I think it should actually be safe, but I haven't really looked. I've added a
bool flag to guard against this case. WDYT?

                                     base::Unretained(this)));
   task_runner_->PostDelayedTask(FROM_HERE, upload_callback_.callback(), delay);
 }
 
 void StatusUploader::RefreshUploadFrequency() {
   // 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(
@@ skipping 61 matching lines @@
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   // 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::ScheduleNextStatusUploadImmediately() {
+  ScheduleNextStatusUpload(true);
+}
+
 void StatusUploader::UploadStatus() {
   // 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;
@@ skipping 27 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