Slightly modified ETA computation algorithm. Also modified UI of the

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"
@@ skipping 32 matching lines @@
 
 // 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;
+const double kDownloadSpeedSmoothFactor = 0.1;

[Ivan Korotkov, 2012/08/24 09:01:36]

Please comment what that means.

[ygorshenin1, 2012/08/27 12:54:16]

Done.

 
 // 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) {
@@ skipping 68 matching lines @@
       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_->SetProgressMessage(
+            UpdateScreenActor::PROGRESS_MESSAGE_UPDATE_AVAILABLE);
+        actor_->ShowProgressMessage(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_->SetProgressMessage(
+                UpdateScreenActor::PROGRESS_MESSAGE_INSTALLING_UPDATE);
+            actor_->ShowProgressMessage(true);
             actor_->ShowCurtain(false);
           }
         }
         UpdateDownloadingStats(status);
       }
       break;
     case UpdateEngineClient::UPDATE_STATUS_VERIFYING:
       MakeSureScreenIsShown();
       actor_->SetProgress(kBeforeVerifyingProgress);
-      actor_->ShowEstimatedTimeLeft(false);
+      actor_->SetProgressMessage(UpdateScreenActor::PROGRESS_MESSAGE_VERIFYING);
+      actor_->ShowProgressMessage(true);
       break;
     case UpdateEngineClient::UPDATE_STATUS_FINALIZING:
       MakeSureScreenIsShown();
       actor_->SetProgress(kBeforeFinalizingProgress);
-      actor_->ShowEstimatedTimeLeft(false);
+      actor_->SetProgressMessage(
+          UpdateScreenActor::PROGRESS_MESSAGE_FINALIZING);
+      actor_->ShowProgressMessage(true);
       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";
@@ skipping 123 matching lines @@
 
 void UpdateScreen::SetIgnoreIdleStatus(bool ignore_idle_status) {
   ignore_idle_status_ = ignore_idle_status;
 }
 
 void UpdateScreen::UpdateDownloadingStats(
     const UpdateEngineClient::Status& status) {
   if (!actor_)
     return;
   base::Time download_current_time = base::Time::Now();
-  if (download_current_time >= download_last_time_ + kMinTimeStep &&
-      status.download_progress >=
-      download_last_progress_ + kMinProgressStep) {
+  if (download_current_time >= download_last_time_ + kMinTimeStep) {
     // 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;
 
@@ skipping 48 matching lines @@
   // 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