Added estimated time remaining on AU.

chrome/browser/chromeos/login/update_screen.cc

 // Copyright (c) 2012 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/login/update_screen.h"
 
+#include <algorithm>
+
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/threading/thread_restrictions.h"
 #include "chrome/browser/chromeos/login/screen_observer.h"
 #include "chrome/browser/chromeos/login/update_screen_actor.h"
 #include "chrome/browser/chromeos/login/wizard_controller.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "content/public/browser/browser_thread.h"
 
@@ skipping 15 matching lines @@
 
 // Defines what part of update progress does download part takes.
 const int kDownloadProgressIncrement = 60;
 
 // Considering 10px shadow from each side.
 const int kUpdateScreenWidth = 580;
 const int kUpdateScreenHeight = 305;
 
 const char kUpdateDeadlineFile[] = "/tmp/update-check-response-deadline";
 
+// Minimum timestep between two consecutive measurements for the
+// download rate.
+const base::TimeDelta kMinTimeStep = base::TimeDelta::FromSeconds(1);
+
+// Minimum allowed progress between two consecutive ETAs.
+const double kMinProgressStep = 1e-3;
+
+// Smooth factor that is used for the average downloading speed
+// estimation.
+const double kDownloadSpeedSmoothFactor = 0.005;
+
+// Minumum allowed value for the average downloading speed.
+const double kDownloadAverageSpeedDropBound = 1e-8;
+
+// An upper bound for possible downloading time left estimations.
+const double kMaxTimeLeft = 24 * 60 * 60;
+
 // Invoked from call to RequestUpdateCheck upon completion of the DBus call.
 void StartUpdateCallback(UpdateScreen* screen,
                          UpdateEngineClient::UpdateCheckResult result) {
   VLOG(1) << "Callback from RequestUpdateCheck, result " << result;
   if (UpdateScreen::HasInstance(screen)) {
     if (result == UpdateEngineClient::UPDATE_RESULT_SUCCESS)
       screen->SetIgnoreIdleStatus(false);
     else
       screen->ExitUpdate(UpdateScreen::REASON_UPDATE_INIT_FAILED);
   }
@@ skipping 48 matching lines @@
   }
 
   switch (status.status) {
     case UpdateEngineClient::UPDATE_STATUS_CHECKING_FOR_UPDATE:
       // Do nothing in these cases, we don't want to notify the user of the
       // check unless there is an update.
       break;
     case UpdateEngineClient::UPDATE_STATUS_UPDATE_AVAILABLE:
       MakeSureScreenIsShown();
       actor_->SetProgress(kBeforeDownloadProgress);
+      actor_->ShowEstimatedTimeLeft(false);
       if (!HasCriticalUpdate()) {
         LOG(INFO) << "Noncritical update available: "
                   << status.new_version;
         ExitUpdate(REASON_UPDATE_NON_CRITICAL);
       } else {
         LOG(INFO) << "Critical update available: "
                   << status.new_version;
         actor_->ShowPreparingUpdatesInfo(true);
         actor_->ShowCurtain(false);
       }
       break;
     case UpdateEngineClient::UPDATE_STATUS_DOWNLOADING:
       {
         MakeSureScreenIsShown();
         if (!is_downloading_update_) {
           // Because update engine doesn't send UPDATE_STATUS_UPDATE_AVAILABLE
           // we need to is update critical on first downloading notification.
           is_downloading_update_ = true;
+          download_start_time_ = download_last_time_ = base::Time::Now();
+          download_start_progress_ = status.download_progress;
+          download_last_progress_ = status.download_progress;
+          is_download_average_speed_computed_ = false;
+          download_average_speed_ = 0.0;
           if (!HasCriticalUpdate()) {
             LOG(INFO) << "Non-critical update available: "
                       << status.new_version;
             ExitUpdate(REASON_UPDATE_NON_CRITICAL);
           } else {
             LOG(INFO) << "Critical update available: "
                       << status.new_version;
             actor_->ShowPreparingUpdatesInfo(false);
             actor_->ShowCurtain(false);
           }
         }
-        int download_progress = static_cast<int>(
-            status.download_progress * kDownloadProgressIncrement);
-        actor_->SetProgress(kBeforeDownloadProgress + download_progress);
+        UpdateDownloadingStats(status);
       }
       break;
     case UpdateEngineClient::UPDATE_STATUS_VERIFYING:
       MakeSureScreenIsShown();
       actor_->SetProgress(kBeforeVerifyingProgress);
+      actor_->ShowEstimatedTimeLeft(false);
       break;
     case UpdateEngineClient::UPDATE_STATUS_FINALIZING:
       MakeSureScreenIsShown();
       actor_->SetProgress(kBeforeFinalizingProgress);
+      actor_->ShowEstimatedTimeLeft(false);
       break;
     case UpdateEngineClient::UPDATE_STATUS_UPDATED_NEED_REBOOT:
       MakeSureScreenIsShown();
       // Make sure that first OOBE stage won't be shown after reboot.
       WizardController::MarkOobeCompleted();
       actor_->SetProgress(kProgressComplete);
+      actor_->ShowEstimatedTimeLeft(false);
       if (HasCriticalUpdate()) {
         actor_->ShowCurtain(false);
         VLOG(1) << "Initiate reboot after update";
         DBusThreadManager::Get()->GetUpdateEngineClient()->RebootAfterUpdate();
         reboot_timer_.Start(FROM_HERE,
                             base::TimeDelta::FromSeconds(reboot_check_delay_),
                             this,
                             &UpdateScreen::OnWaitForRebootTimeElapsed);
       } else {
         ExitUpdate(REASON_UPDATE_NON_CRITICAL);
@@ skipping 102 matching lines @@
   if (seconds <= 0)
     reboot_timer_.Stop();
   DCHECK(!reboot_timer_.IsRunning());
   reboot_check_delay_ = seconds;
 }
 
 void UpdateScreen::SetIgnoreIdleStatus(bool ignore_idle_status) {
   ignore_idle_status_ = ignore_idle_status;
 }
 
+void UpdateScreen::UpdateDownloadingStats(
+    const UpdateEngineClient::Status& status) {
+  base::Time download_current_time = base::Time::Now();
+  if (download_current_time >= download_last_time_ + kMinTimeStep &&
+      status.download_progress >=
+      download_last_progress_ + kMinProgressStep) {
+    // Estimate downloading rate.
+    double progress_delta =
+        std::max(status.download_progress - download_last_progress_, 0.0);
+    double time_delta =
+        (download_current_time - download_last_time_).InSecondsF();
+    double download_rate = status.new_size * progress_delta / time_delta;
+
+    download_last_time_ = download_current_time;
+    download_last_progress_ = status.download_progress;
+
+    // Estimate time left.
+    double progress_left = std::max(1.0 - status.download_progress, 0.0);
+    if (!is_download_average_speed_computed_) {
+      download_average_speed_ = download_rate;
+      is_download_average_speed_computed_ = true;
+    }
+    download_average_speed_ =
+        kDownloadSpeedSmoothFactor * download_rate +
+        (1.0 - kDownloadSpeedSmoothFactor) * download_average_speed_;
+    if (download_average_speed_ < kDownloadAverageSpeedDropBound) {
+      time_delta =
+          (download_current_time - download_start_time_).InSecondsF();
+      download_average_speed_ =
+          status.new_size *
+          (status.download_progress - download_start_progress_) /
+          time_delta;
+    }
+    double work_left = progress_left * status.new_size;
+    double time_left = work_left / download_average_speed_;
+    // |time_left| may be large enough or even +infinity. So we must
+    // |bound possible estimations.
+    time_left = std::min(time_left, kMaxTimeLeft);
+
+    actor_->ShowEstimatedTimeLeft(true);
+    actor_->SetEstimatedTimeLeft(
+        base::TimeDelta::FromSeconds(static_cast<int64>(time_left)));
+  }
+
+  int download_progress = static_cast<int>(
+      status.download_progress * kDownloadProgressIncrement);
+  actor_->SetProgress(kBeforeDownloadProgress + download_progress);
+}
+
 bool UpdateScreen::HasCriticalUpdate() {
   if (is_ignore_update_deadlines_)
     return true;
 
   std::string deadline;
   // Checking for update flag file causes us to do blocking IO on UI thread.
   // Temporarily allow it until we fix http://crosbug.com/11106
   base::ThreadRestrictions::ScopedAllowIO allow_io;
   FilePath update_deadline_file_path(kUpdateDeadlineFile);
   if (!file_util::ReadFileToString(update_deadline_file_path, &deadline) ||
       deadline.empty()) {
     return false;
   }
 
   // TODO(dpolukhin): Analyze file content. Now we can just assume that
   // if the file exists and not empty, there is critical update.
   return true;
 }
 
 void UpdateScreen::OnActorDestroyed(UpdateScreenActor* actor) {
   if (actor_ == actor)
     actor_ = NULL;
 }
 
 }  // namespace chromeos