For actions, switch bool success into an exit code.

action_processor_unittest.cc

 // Copyright (c) 2009 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 <string>
 #include <gtest/gtest.h>
 #include "update_engine/action.h"
 #include "update_engine/action_processor.h"
 
 using std::string;
@@ skipping 14 matching lines @@
 // This is a simple Action class for testing.
 struct ActionProcessorTestAction : public Action<ActionProcessorTestAction> {
   typedef string InputObjectType;
   typedef string OutputObjectType;
   ActionPipe<string>* in_pipe() { return in_pipe_.get(); }
   ActionPipe<string>* out_pipe() { return out_pipe_.get(); }
   ActionProcessor* processor() { return processor_; }
   void PerformAction() {}
   void CompleteAction() {
     ASSERT_TRUE(processor());
-    processor()->ActionComplete(this, true);
+    processor()->ActionComplete(this, kActionCodeSuccess);
   }
   string Type() const { return "ActionProcessorTestAction"; }
 };
 
 class ActionProcessorTest : public ::testing::Test { };
 
 // This test creates two simple Actions and sends a message via an ActionPipe
 // from one to the other.
 TEST(ActionProcessorTest, SimpleTest) {
   ActionProcessorTestAction action;
@@ skipping 12 matching lines @@
 }
 
 namespace {
 class MyActionProcessorDelegate : public ActionProcessorDelegate {
  public:
   explicit MyActionProcessorDelegate(const ActionProcessor* processor)
       : processor_(processor),
         processing_done_called_(false),
         processing_stopped_called_(false),
         action_completed_called_(false),
-        action_completed_success_(false) {}
+        action_exit_code_(kActionCodeError) {}
 
-  virtual void ProcessingDone(const ActionProcessor* processor, bool success) {
+  virtual void ProcessingDone(const ActionProcessor* processor,
+                              ActionExitCode code) {
     EXPECT_EQ(processor_, processor);
     EXPECT_FALSE(processing_done_called_);
     processing_done_called_ = true;
   }
   virtual void ProcessingStopped(const ActionProcessor* processor) {
     EXPECT_EQ(processor_, processor);
     EXPECT_FALSE(processing_stopped_called_);
     processing_stopped_called_ = true;
   }
   virtual void ActionCompleted(ActionProcessor* processor,
                                AbstractAction* action,
-                               bool success) {
+                               ActionExitCode code) {
     EXPECT_EQ(processor_, processor);
     EXPECT_FALSE(action_completed_called_);
     action_completed_called_ = true;
-    action_completed_success_ = success;
+    action_exit_code_ = code;
   }
 
   const ActionProcessor* processor_;
   bool processing_done_called_;
   bool processing_stopped_called_;
   bool action_completed_called_;
-  bool action_completed_success_;
+  ActionExitCode action_exit_code_;
 };
 }  // namespace {}
 
 TEST(ActionProcessorTest, DelegateTest) {
   ActionProcessorTestAction action;
   ActionProcessor action_processor;
   MyActionProcessorDelegate delegate(&action_processor);
   action_processor.set_delegate(&delegate);
 
   action_processor.EnqueueAction(&action);
@@ skipping 62 matching lines @@
   action.CompleteAction();
 
   action_processor.EnqueueAction(&action);
   action_processor.StartProcessing();
   action_processor.StopProcessing();
 
   action_processor.set_delegate(NULL);
 }
 
 }  // namespace chromeos_update_engine