For actions, switch bool success into an exit code.

action_processor.h

-// Copyright (c) 2009 The Chromium OS Authors. All rights reserved.
+// 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.
 
 #ifndef CHROMEOS_PLATFORM_UPDATE_ENGINE_ACTION_PROCESSOR_H__
 #define CHROMEOS_PLATFORM_UPDATE_ENGINE_ACTION_PROCESSOR_H__
 
 #include <deque>
 
 #include "base/basictypes.h"
 
 // The structure of these classes (Action, ActionPipe, ActionProcessor, etc.)
 // is based on the KSAction* classes from the Google Update Engine code at
 // http://code.google.com/p/update-engine/ . The author of this file sends
 // a big thanks to that team for their high quality design, implementation,
 // and documentation.
 
 // See action.h for an overview of this class and other other Action* classes.
 
 // An ActionProcessor keeps a queue of Actions and processes them in order.
 
 namespace chromeos_update_engine {
 
+// Action exit codes.
+enum ActionExitCode {
+  kActionCodeSuccess = 0,
+  kActionCodeError = 1,
+};
+
 class AbstractAction;
 class ActionProcessorDelegate;
 
 class ActionProcessor {
  public:
   ActionProcessor();
 
   ~ActionProcessor();
 
   // Starts processing the first Action in the queue. If there's a delegate,
@@ skipping 16 matching lines @@
   void set_delegate(ActionProcessorDelegate *delegate) {
     delegate_ = delegate;
   }
 
   // Returns a pointer to the current Action that's processing.
   AbstractAction* current_action() const {
     return current_action_;
   }
 
   // Called by an action to notify processor that it's done. Caller passes self.
-  void ActionComplete(AbstractAction* actionptr, bool success);
+  void ActionComplete(AbstractAction* actionptr, ActionExitCode code);
 
  private:
   // Actions that have not yet begun processing, in the order in which
   // they'll be processed.
   std::deque<AbstractAction*> actions_;
 
   // A pointer to the currrently processing Action, if any.
   AbstractAction* current_action_;
 
   // A pointer to the delegate, or NULL if none.
   ActionProcessorDelegate *delegate_;
   DISALLOW_COPY_AND_ASSIGN(ActionProcessor);
 };
 
 // A delegate object can be used to be notified of events that happen
 // in an ActionProcessor. An instance of this class can be passed to an
 // ActionProcessor to register itself.
 class ActionProcessorDelegate {
  public:
   // Called when all processing in an ActionProcessor has completed. A pointer
-  // to the ActionProcessor is passed. success is true iff all actions
-  // completed successfully
-  virtual void ProcessingDone(const ActionProcessor* processor, bool success) {}
+  // to the ActionProcessor is passed. |code| is set to the exit code of the
+  // last completed action.
+  virtual void ProcessingDone(const ActionProcessor* processor,
+                              ActionExitCode code) {}
 
   // Called when processing has stopped. Does not mean that all Actions have
   // completed. If/when all Actions complete, ProcessingDone() will be called.
   virtual void ProcessingStopped(const ActionProcessor* processor) {}
 
   // Called whenever an action has finished processing, either successfully
   // or otherwise.
   virtual void ActionCompleted(ActionProcessor* processor,
                                AbstractAction* action,
-                               bool success) {}
+                               ActionExitCode code) {}
 };
 
 }  // namespace chromeos_update_engine
 
 #endif  // CHROMEOS_PLATFORM_UPDATE_ENGINE_ACTION_PROCESSOR_H__