AU: Handle firmware update failure when booted from FW slot B.

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 85 matching lines @@
 }
 
 UpdateAttempter::UpdateAttempter(PrefsInterface* prefs,
                                  MetricsLibraryInterface* metrics_lib,
                                  DbusGlibInterface* dbus_iface)
     : processor_(new ActionProcessor()),
       dbus_service_(NULL),
       prefs_(prefs),
       metrics_lib_(metrics_lib),
       update_check_scheduler_(NULL),
+      fake_update_success_(false),
       http_response_code_(0),
       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),
       is_full_update_(false),
       proxy_manual_checks_(0),
       obeying_proxies_(true),
       chrome_proxy_resolver_(dbus_iface),
       updated_boot_flags_(false) {
   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,
                              bool obey_proxies) {
   chrome_proxy_resolver_.Init();
+  fake_update_success_ = false;
   UpdateBootFlags();  // Just in case we didn't do this yet.
   if (status_ == UPDATE_STATUS_UPDATED_NEED_REBOOT) {
     // Although we have applied an update, we still want to ping Omaha
     // to ensure the number of active statistics is accurate.
     LOG(INFO) << "Not updating b/c we already updated and we're waiting for "
               << "reboot, we'll ping Omaha instead";
     PingOmaha();
     return;
   }
   if (status_ != UPDATE_STATUS_IDLE) {
@@ skipping 165 matching lines @@
   CHECK(response_handler_action_);
   LOG(INFO) << "Processing Done.";
   actions_.clear();
 
   // Reset process priority back to normal.
   CleanupPriorityManagement();
 
   if (status_ == UPDATE_STATUS_REPORTING_ERROR_EVENT) {
     LOG(INFO) << "Error event sent.";
     SetStatusAndNotify(UPDATE_STATUS_IDLE);
-    return;
+    if (!fake_update_success_) {
+      return;
+    }
+    LOG(INFO) << "Booted from FW B and tried to install new firmware, "
+        "so requesting reboot from user.";
   }
 
   if (code == kActionCodeSuccess) {
     utils::WriteFile(kUpdateCompletedMarker, "", 0);
     prefs_->SetInt64(kPrefsDeltaUpdateFailures, 0);
     prefs_->SetString(kPrefsPreviousVersion, omaha_request_params_.app_version);
     DeltaPerformer::ResetUpdateProgress(prefs_, false);
     SetStatusAndNotify(UPDATE_STATUS_UPDATED_NEED_REBOOT);
 
     // Report the time it took to update the system.
     int64_t update_time = time(NULL) - last_checked_time_;
-    metrics_lib_->SendToUMA("Installer.UpdateTime",
-                            static_cast<int>(update_time),  // sample
-                            1,  // min = 1 second
-                            20 * 60,  // max = 20 minutes
-                            50);  // buckets
+    if (!fake_update_success_)
+      metrics_lib_->SendToUMA("Installer.UpdateTime",
+                              static_cast<int>(update_time),  // sample
+                              1,  // min = 1 second
+                              20 * 60,  // max = 20 minutes
+                              50);  // buckets
     return;
   }
 
   if (ScheduleErrorEventAction()) {
     return;
   }
   LOG(INFO) << "No update.";
   SetStatusAndNotify(UPDATE_STATUS_IDLE);
 }
 
@@ skipping 160 matching lines @@
   // there's no update so don't send an event. Also, double check that the
   // failure has not occurred while sending an error event -- in which case
   // don't schedule another. This shouldn't really happen but just in case...
   if ((action->Type() == OmahaResponseHandlerAction::StaticType() &&
        code == kActionCodeError) ||
       status_ == UPDATE_STATUS_REPORTING_ERROR_EVENT) {
     return;
   }
 
   code = GetErrorCodeForAction(action, code);
+  fake_update_success_ = code == kActionCodePostinstallBootedFromFirmwareB;
   error_event_.reset(new OmahaEvent(OmahaEvent::kTypeUpdateComplete,
                                     OmahaEvent::kResultError,
                                     code));
 }
 
 bool UpdateAttempter::ScheduleErrorEventAction() {
   if (error_event_.get() == NULL)
     return false;
 
   LOG(INFO) << "Update failed -- reporting the error event.";
@@ skipping 112 matching lines @@
                              true));
   actions_.push_back(shared_ptr<OmahaRequestAction>(ping_action));
   CHECK(!processor_->IsRunning());
   processor_->set_delegate(NULL);
   processor_->EnqueueAction(ping_action.get());
   g_idle_add(&StaticStartProcessing, this);
   SetStatusAndNotify(UPDATE_STATUS_UPDATED_NEED_REBOOT);
 }
 
 }  // namespace chromeos_update_engine