AU: Update status to DOWNLOADING only after receiving some bytes from server.

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
@@ skipping 103 matching lines @@
   return code;
 }
 
 UpdateAttempter::UpdateAttempter(PrefsInterface* prefs,
                                  MetricsLibraryInterface* metrics_lib)
     : dbus_service_(NULL),
       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;
 }
@@ skipping 178 matching lines @@
   const string type = action->Type();
   if (type == DownloadAction::StaticType())
     download_progress_ = 0.0;
   if (code != kActionCodeSuccess) {
     // On failure, schedule an error event to be sent to Omaha.
     CreatePendingErrorEvent(action, code);
     return;
   }
   // Find out which action completed.
   if (type == OmahaResponseHandlerAction::StaticType()) {
-    SetStatusAndNotify(UPDATE_STATUS_DOWNLOADING);
+    // Note that the status will be updated to DOWNLOADING when some
+    // bytes get actually downloaded from the server and the
+    // BytesReceived callback is invoked. This avoids notifying the
+    // user that a download has started in cases when the server and
+    // the client are unable to initiate the download.
     OmahaResponseHandlerAction* omaha_response_handler_action =
         dynamic_cast<OmahaResponseHandlerAction*>(action);
     CHECK(omaha_response_handler_action);
     const InstallPlan& plan = omaha_response_handler_action->install_plan();
     last_checked_time_ = time(NULL);
     // TODO(adlr): put version in InstallPlan
     new_version_ = "0.0.0.0";
     new_size_ = plan.size;
     SetupPriorityManagement();
   } else if (type == DownloadAction::StaticType()) {
     SetStatusAndNotify(UPDATE_STATUS_FINALIZING);
   }
 }
 
 // Stop updating. An attempt will be made to record status to the disk
 // so that updates can be resumed later.
 void UpdateAttempter::Terminate() {
   // TODO(adlr): implement this method.
   NOTIMPLEMENTED();
 }
 
 // Try to resume from a previously Terminate()d update.
 void UpdateAttempter::ResumeUpdating() {
   // TODO(adlr): implement this method.
   NOTIMPLEMENTED();
 }
 
+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 (status_ != UPDATE_STATUS_DOWNLOADING) {
+  if (!download_active_) {
     LOG(ERROR) << "BytesReceived called while not downloading.";
     return;
   }
   download_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) &&
@@ skipping 114 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