Narrow down to one generic error per action.

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 72 matching lines @@
       return "UPDATE_STATUS_FINALIZING";
     case UPDATE_STATUS_UPDATED_NEED_REBOOT:
       return "UPDATE_STATUS_UPDATED_NEED_REBOOT";
     case UPDATE_STATUS_REPORTING_ERROR_EVENT:
       return "UPDATE_STATUS_REPORTING_ERROR_EVENT";
     default:
       return "unknown status";
   }
 }
 
+// Turns a generic kActionCodeError to a generic error code specific
+// to |action| (e.g., kActionCodeFilesystemCopierError). If |code| is
+// not kActionCodeError, or the action is not matched, returns |code|
+// unchanged.
+ActionExitCode GetErrorCodeForAction(AbstractAction* action,
+                                     ActionExitCode code) {
+  if (code != kActionCodeError)
+    return code;
+
+  const string type = action->Type();
+  if (type == OmahaRequestAction::StaticType())
+    return kActionCodeOmahaRequestError;
+  if (type == OmahaResponseHandlerAction::StaticType())
+    return kActionCodeOmahaResponseHandlerError;
+  if (type == FilesystemCopierAction::StaticType())
+    return kActionCodeFilesystemCopierError;
+  if (type == PostinstallRunnerAction::StaticType())
+    return kActionCodePostinstallRunnerError;
+  if (type == SetBootableFlagAction::StaticType())
+    return kActionCodeSetBootableFlagError;
+
+  return code;
+}
+
 void UpdateAttempter::Update() {
   if (status_ == UPDATE_STATUS_UPDATED_NEED_REBOOT) {
     LOG(INFO) << "Not updating b/c we already updated and we're waiting for "
               << "reboot";
     return;
   }
   if (status_ != UPDATE_STATUS_IDLE) {
     // Update in progress. Do nothing
     return;
   }
@@ skipping 136 matching lines @@
 // or otherwise.
 void UpdateAttempter::ActionCompleted(ActionProcessor* processor,
                                       AbstractAction* action,
                                       ActionExitCode code) {
   // Reset download progress regardless of whether or not the download action
   // succeeded.
   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. For
-    // now assume that Omaha response action failure means that
-    // 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 (type != OmahaResponseHandlerAction::StaticType() &&
-        status_ != UPDATE_STATUS_REPORTING_ERROR_EVENT) {
-      CreatePendingErrorEvent(code);
-    }
+    // 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);
     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);
@@ skipping 56 matching lines @@
   GetCPUClockTime(&last_notify_time_);
   update_engine_service_emit_status_update(
       dbus_service_,
       last_checked_time_,
       download_progress_,
       UpdateStatusToString(status_),
       new_version_.c_str(),
       new_size_);
 }
 
-void UpdateAttempter::CreatePendingErrorEvent(ActionExitCode code) {
+void UpdateAttempter::CreatePendingErrorEvent(AbstractAction* action,
+                                              ActionExitCode code) {
   if (error_event_.get()) {
     // This shouldn't really happen.
     LOG(WARNING) << "There's already an existing pending error event.";
     return;
   }
+
+  // For now assume that Omaha response action failure means that
+  // 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() ||
+      status_ == UPDATE_STATUS_REPORTING_ERROR_EVENT) {
+    return;
+  }
+
+  code = GetErrorCodeForAction(action, code);
   error_event_.reset(new OmahaEvent(OmahaEvent::kTypeUpdateComplete,
                                     OmahaEvent::kResultError,
                                     code));
 }
 
 bool UpdateAttempter::ScheduleErrorEventAction() {
   if (error_event_.get() == NULL)
     return false;
 
   shared_ptr<OmahaRequestAction> error_event_action(
       new OmahaRequestAction(omaha_request_params_,
                              error_event_.release(),  // Pass ownership.
                              new LibcurlHttpFetcher));
   actions_.push_back(shared_ptr<AbstractAction>(error_event_action));
   processor_.EnqueueAction(error_event_action.get());
   SetStatusAndNotify(UPDATE_STATUS_REPORTING_ERROR_EVENT);
   processor_.StartProcessing();
   return true;
 }
 
 }  // namespace chromeos_update_engine