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 <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/sequenced_task_runner.h"
 #include "base/sys_info.h"
 #include "base/syslog_logging.h"
 #include "chrome/browser/chromeos/policy/device_local_account.h"
 #include "chrome/browser/chromeos/policy/device_status_collector.h"
@@ skipping 59 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) {
+  // Don't schedule a new status upload if there's a status upload in progress
+  // (it will be scheduled once the current one completes).
+  if (status_upload_in_progress_)

[Andrew T Wilson (Slow), 2017/03/21 18:03:42]

Log something here, as this is a weird exceptional case I think.

[Ivan Šandrk, 2017/03/22 20:20:01]

Done.

+    return;
+
   // 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,
                                     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();
@@ skipping 62 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() {
+  status_upload_in_progress_ = true;
   // 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) {
     SYSLOG(INFO) << "Skipping status upload because no data to upload";
     // Don't have any status to upload - just set our timer for next time.
     last_upload_ = base::Time::NowFromSystemTime();
+    status_upload_in_progress_ = false;
     ScheduleNextStatusUpload();
     return;
   }
 
   SYSLOG(INFO) << "Starting status upload: have_device_status = "
                << have_device_status;
   client_->UploadDeviceStatus(device_status.get(), session_status.get(),
                               base::Bind(&StatusUploader::OnUploadCompleted,
                                          weak_factory_.GetWeakPtr()));
 }
 
 void StatusUploader::OnUploadCompleted(bool success) {
   // Set the last upload time, regardless of whether the upload was successful
   // or not (we don't change the time of the next upload based on whether this
   // upload succeeded or not - if a status upload fails, we just skip it and
   // wait until it's time to try again.
   if (success) {
     SYSLOG(INFO) << "Status upload successful";
   } else {
     SYSLOG(ERROR) << "Error uploading status: " << client_->status();
   }
   last_upload_ = base::Time::NowFromSystemTime();
+  status_upload_in_progress_ = false;
 
   // If the upload was successful, tell the collector so it can clear its cache
   // of pending items.
   if (success)
     collector_->OnSubmittedSuccessfully();
 
   ScheduleNextStatusUpload();
 }
 
 }  // namespace policy