Add delay when scheduling next status upload

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"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/sequenced_task_runner.h"
 #include "chrome/browser/chromeos/policy/device_local_account.h"
 #include "chrome/browser/chromeos/policy/device_status_collector.h"
 #include "chromeos/settings/cros_settings_names.h"
 #include "chromeos/settings/cros_settings_provider.h"
 #include "components/policy/core/common/cloud/cloud_policy_client.h"
 #include "components/policy/core/common/cloud/device_management_service.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/media_request_state.h"
 #include "content/public/common/media_stream_request.h"
 #include "ui/base/user_activity/user_activity_detector.h"
 
 namespace {
+// Minimum delay between two consecutive uploads
 const int kMinUploadDelayMs = 60 * 1000;  // 60 seconds
+// Minimum delay after scheduling an upload
+const int kMinUploadScheduleDelayMs = 60 * 1000;  // 60 seconds
 }  // namespace
 
 namespace policy {
 
 const int64_t StatusUploader::kDefaultUploadDelayMs =
     3 * 60 * 60 * 1000;  // 3 hours
 
 StatusUploader::StatusUploader(
     CloudPolicyClient* client,
     std::unique_ptr<DeviceStatusCollector> collector,
@@ skipping 23 matching lines @@
   // server.
   upload_frequency_observer_ =
       chromeos::CrosSettings::Get()->AddSettingsObserver(
           chromeos::kReportUploadFrequency,
           base::Bind(&StatusUploader::RefreshUploadFrequency,
                      base::Unretained(this)));
 
   // Update the upload frequency from settings.
   RefreshUploadFrequency();
 
-  // Immediately schedule our next status upload (last_upload_ is set to the
-  // start of the epoch, so this will trigger an update in the immediate
-  // future).
+  // 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() {
   // Calculate when to fire off the next update (if it should have already
-  // happened, this yields a TimeDelta of 0).
+  // happened, this yields a TimeDelta of kMinUploadScheduleDelayMs).
   base::TimeDelta delay = std::max(
       (last_upload_ + upload_frequency_) - base::Time::NowFromSystemTime(),
-      base::TimeDelta());
+      base::TimeDelta::FromMilliseconds(kMinUploadScheduleDelayMs));
   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 10 matching lines @@
   if (settings->GetInteger(chromeos::kReportUploadFrequency, &frequency)) {
     LOG(WARNING) << "Changing status upload frequency from "
                  << upload_frequency_ << " to "
                  << base::TimeDelta::FromMilliseconds(frequency);
     upload_frequency_ = base::TimeDelta::FromMilliseconds(
         std::max(kMinUploadDelayMs, frequency));
   }
 
   // Schedule a new upload with the new frequency - only do this if we've
   // already performed the initial upload, because we want the initial upload
-  // to happen immediately on startup and not get cancelled by settings changes.
+  // to happen in a minute after startup and not get cancelled by settings
+  // changes.
   if (!last_upload_.is_null())
     ScheduleNextStatusUpload();
 }
 
 bool StatusUploader::IsSessionDataUploadAllowed() {
   // Check if we're in an auto-launched kiosk session.
   std::unique_ptr<DeviceLocalAccount> account =
       collector_->GetAutoLaunchedKioskSessionInfo();
   if (!account)
     return false;
@@ skipping 54 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