AU: Throttle notifications based on progress; still notify if slow progress.

update_attempter.cc

 // Copyright (c) 2010 The Chromium OS 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 "update_engine/update_attempter.h"
 
 // From 'man clock_gettime': feature test macro: _POSIX_C_SOURCE >= 199309L
 #ifndef _POSIX_C_SOURCE
 #define _POSIX_C_SOURCE 199309L
 #endif  // _POSIX_C_SOURCE
 #include <time.h>
 
 #include <tr1/memory>
 #include <string>
 #include <vector>
 
 #include <glib.h>
 
 #include "metrics/metrics_library.h"
 #include "update_engine/dbus_service.h"
 #include "update_engine/download_action.h"
 #include "update_engine/filesystem_copier_action.h"
 #include "update_engine/libcurl_http_fetcher.h"
 #include "update_engine/omaha_request_action.h"
 #include "update_engine/omaha_request_params.h"
 #include "update_engine/omaha_response_handler_action.h"
 #include "update_engine/postinstall_runner_action.h"
 #include "update_engine/set_bootable_flag_action.h"
 
+using base::TimeDelta;
+using base::TimeTicks;
 using std::tr1::shared_ptr;
 using std::string;
 using std::vector;
 
 namespace chromeos_update_engine {
 
 const char* kUpdateCompletedMarker = "/tmp/update_engine_autoupdate_completed";
 
-namespace {
-// Returns true on success.
-bool GetCPUClockTime(struct timespec* out) {
-  return clock_gettime(CLOCK_REALTIME, out) == 0;
-}
-// Returns stop - start.
-struct timespec CPUClockTimeElapsed(const struct timespec& start,
-                                    const struct timespec& stop) {
-  CHECK(start.tv_sec >= 0);
-  CHECK(stop.tv_sec >= 0);
-  CHECK(start.tv_nsec >= 0);
-  CHECK(stop.tv_nsec >= 0);
-
-  const int64_t kOneBillion = 1000000000L;
-  const int64_t start64 = start.tv_sec * kOneBillion + start.tv_nsec;
-  const int64_t stop64 = stop.tv_sec * kOneBillion + stop.tv_nsec;
-
-  const int64_t result64 = stop64 - start64;
-
-  struct timespec ret;
-  ret.tv_sec = result64 / kOneBillion;
-  ret.tv_nsec = result64 % kOneBillion;
-
-  return ret;
-}
-bool CPUClockTimeGreaterThanHalfSecond(const struct timespec& spec) {
-  if (spec.tv_sec >= 1)
-    return true;
-  return (spec.tv_nsec > 500000000);
-}
-}
-
 const char* UpdateStatusToString(UpdateStatus status) {
   switch (status) {
     case UPDATE_STATUS_IDLE:
       return "UPDATE_STATUS_IDLE";
     case UPDATE_STATUS_CHECKING_FOR_UPDATE:
       return "UPDATE_STATUS_CHECKING_FOR_UPDATE";
     case UPDATE_STATUS_UPDATE_AVAILABLE:
       return "UPDATE_STATUS_UPDATE_AVAILABLE";
     case UPDATE_STATUS_DOWNLOADING:
       return "UPDATE_STATUS_DOWNLOADING";
@@ skipping 40 matching lines @@
       prefs_(prefs),
       metrics_lib_(metrics_lib),
       priority_(utils::kProcessPriorityNormal),
       manage_priority_source_(NULL),
       download_active_(false),
       status_(UPDATE_STATUS_IDLE),
       download_progress_(0.0),
       last_checked_time_(0),
       new_version_("0.0.0.0"),
       new_size_(0) {
-  last_notify_time_.tv_sec = 0;
-  last_notify_time_.tv_nsec = 0;
   if (utils::FileExists(kUpdateCompletedMarker))
     status_ = UPDATE_STATUS_UPDATED_NEED_REBOOT;
 }
 
 UpdateAttempter::~UpdateAttempter() {
   CleanupPriorityManagement();
 }
 
 void UpdateAttempter::Update(const std::string& app_version,
                              const std::string& omaha_url) {
@@ skipping 213 matching lines @@
 void UpdateAttempter::SetDownloadStatus(bool active) {
   download_active_ = active;
   LOG(INFO) << "Download status: " << (active ? "active" : "inactive");
 }
 
 void UpdateAttempter::BytesReceived(uint64_t bytes_received, uint64_t total) {
   if (!download_active_) {
     LOG(ERROR) << "BytesReceived called while not downloading.";
     return;
   }
-  download_progress_ = static_cast<double>(bytes_received) /
+  double progress = static_cast<double>(bytes_received) /
       static_cast<double>(total);
-  // We self throttle here
-  timespec now;
-  now.tv_sec = 0;
-  now.tv_nsec = 0;
-  if (GetCPUClockTime(&now) &&
-      CPUClockTimeGreaterThanHalfSecond(
-          CPUClockTimeElapsed(last_notify_time_, now))) {
+  // Self throttle based on progress. Also send notifications if
+  // progress is too slow.
+  const double kDeltaPercent = 0.01;  // 1%
+  if (status_ != UPDATE_STATUS_DOWNLOADING ||
+      bytes_received == total ||
+      progress - download_progress_ >= kDeltaPercent ||
+      TimeTicks::Now() - last_notify_time_ >= TimeDelta::FromSeconds(10)) {
+    download_progress_ = progress;
     SetStatusAndNotify(UPDATE_STATUS_DOWNLOADING);
   }
 }
 
 bool UpdateAttempter::GetStatus(int64_t* last_checked_time,
                                 double* progress,
                                 std::string* current_operation,
                                 std::string* new_version,
                                 int64_t* new_size) {
   *last_checked_time = last_checked_time_;
   *progress = download_progress_;
   *current_operation = UpdateStatusToString(status_);
   *new_version = new_version_;
   *new_size = new_size_;
   return true;
 }
 
 void UpdateAttempter::SetStatusAndNotify(UpdateStatus status) {
   status_ = status;
   if (!dbus_service_)
     return;
-  GetCPUClockTime(&last_notify_time_);
+  last_notify_time_ = TimeTicks::Now();
   update_engine_service_emit_status_update(
       dbus_service_,
       last_checked_time_,
       download_progress_,
       UpdateStatusToString(status_),
       new_version_.c_str(),
       new_size_);
 }
 
 void UpdateAttempter::CreatePendingErrorEvent(AbstractAction* action,
@@ skipping 80 matching lines @@
     SetPriority(utils::kProcessPriorityNormal);
     return true;
   }
   // Set the priority to high and let GLib destroy the timeout source.
   SetPriority(utils::kProcessPriorityHigh);
   manage_priority_source_ = NULL;
   return false;
 }
 
 }  // namespace chromeos_update_engine