For actions, switch bool success into an exit code.

filesystem_copier_action_unittest.cc

 // Copyright (c) 2010 The Chromium 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 <glib.h>
 #include <set>
 #include <string>
 #include <vector>
 #include <gtest/gtest.h>
 #include "base/string_util.h"
@@ skipping 15 matching lines @@
               bool terminate_early,
               bool use_kernel_partition);
   void SetUp() {
   }
   void TearDown() {
   }
 };
 
 class FilesystemCopierActionTestDelegate : public ActionProcessorDelegate {
  public:
-  FilesystemCopierActionTestDelegate() : ran_(false), success_(false) {}
+  FilesystemCopierActionTestDelegate() : ran_(false), code_(kActionCodeError) {}
   void ExitMainLoop() {
     while (g_main_context_pending(NULL)) {
       g_main_context_iteration(NULL, false);
     }
     g_main_loop_quit(loop_);
   }
-  void ProcessingDone(const ActionProcessor* processor, bool success) {
+  void ProcessingDone(const ActionProcessor* processor, ActionExitCode code) {
     ExitMainLoop();
   }
   void ProcessingStopped(const ActionProcessor* processor) {
     ExitMainLoop();
   }
   void ActionCompleted(ActionProcessor* processor,
                        AbstractAction* action,
-                       bool success) {
+                       ActionExitCode code) {
     if (action->Type() == FilesystemCopierAction::StaticType()) {
       ran_ = true;
-      success_ = success;
+      code_ = code;
     }
   }
   void set_loop(GMainLoop* loop) {
     loop_ = loop;
   }
   bool ran() { return ran_; }
-  bool success() { return success_; }
+  ActionExitCode code() { return code_; }
  private:
   GMainLoop* loop_;
   bool ran_;
-  bool success_;
+  ActionExitCode code_;
 };
 
 struct StartProcessorCallbackArgs {
   ActionProcessor* processor;
   FilesystemCopierAction* filesystem_copier_action;
   bool terminate_early;
 };
 
 gboolean StartProcessorInRunLoop(gpointer data) {
   StartProcessorCallbackArgs* args =
@@ skipping 13 matching lines @@
 
   DoTest(false, false, true);
 }
 void FilesystemCopierActionTest::DoTest(bool run_out_of_space,
                                         bool terminate_early,
                                         bool use_kernel_partition) {
   GMainLoop *loop = g_main_loop_new(g_main_context_default(), FALSE);
 
   string a_loop_file;
   string b_loop_file;
-  
+
   EXPECT_TRUE(utils::MakeTempFile("/tmp/a_loop_file.XXXXXX",
                                   &a_loop_file,
                                   NULL));
   ScopedPathUnlinker a_loop_file_unlinker(a_loop_file);
   EXPECT_TRUE(utils::MakeTempFile("/tmp/b_loop_file.XXXXXX",
                                   &b_loop_file,
                                   NULL));
   ScopedPathUnlinker b_loop_file_unlinker(b_loop_file);
-  
+
   // Make random data for a, zero filled data for b.
   const size_t kLoopFileSize = 10 * 1024 * 1024 + 512;
   vector<char> a_loop_data(kLoopFileSize);
   FillWithData(&a_loop_data);
   vector<char> b_loop_data(run_out_of_space ?
                            (kLoopFileSize - 1) :
                            kLoopFileSize,
                            '\0');  // Fill with 0s
 
   // Write data to disk
@@ skipping 47 matching lines @@
   start_callback_args.filesystem_copier_action = &copier_action;
   start_callback_args.terminate_early = terminate_early;
 
   g_timeout_add(0, &StartProcessorInRunLoop, &start_callback_args);
   g_main_loop_run(loop);
   g_main_loop_unref(loop);
 
   if (!terminate_early)
     EXPECT_TRUE(delegate.ran());
   if (run_out_of_space || terminate_early) {
-    EXPECT_FALSE(delegate.success());
+    EXPECT_EQ(kActionCodeError, delegate.code());
     return;
   }
-  EXPECT_TRUE(delegate.success());
+  EXPECT_EQ(kActionCodeSuccess, delegate.code());
 
   // Make sure everything in the out_image is there
   vector<char> a_out;
   vector<char> b_out;
   EXPECT_TRUE(utils::ReadFile(a_dev, &a_out));
   EXPECT_TRUE(utils::ReadFile(b_dev, &b_out));
   EXPECT_TRUE(ExpectVectorsEq(a_out, b_out));
   EXPECT_TRUE(ExpectVectorsEq(a_loop_data, a_out));
 
   EXPECT_TRUE(collector_action.object() == install_plan);
 }
 
 class FilesystemCopierActionTest2Delegate : public ActionProcessorDelegate {
  public:
   void ActionCompleted(ActionProcessor* processor,
                        AbstractAction* action,
-                       bool success) {
+                       ActionExitCode code) {
     if (action->Type() == FilesystemCopierAction::StaticType()) {
       ran_ = true;
-      success_ = success;
+      code_ = code;
     }
   }
   GMainLoop *loop_;
   bool ran_;
-  bool success_;
+  ActionExitCode code_;
 };
 
 TEST_F(FilesystemCopierActionTest, MissingInputObjectTest) {
   ActionProcessor processor;
   FilesystemCopierActionTest2Delegate delegate;
 
   processor.set_delegate(&delegate);
 
   FilesystemCopierAction copier_action(false);
   ObjectCollectorAction<InstallPlan> collector_action;
 
   BondActions(&copier_action, &collector_action);
 
   processor.EnqueueAction(&copier_action);
   processor.EnqueueAction(&collector_action);
   processor.StartProcessing();
   EXPECT_FALSE(processor.IsRunning());
   EXPECT_TRUE(delegate.ran_);
-  EXPECT_FALSE(delegate.success_);
+  EXPECT_EQ(kActionCodeError, delegate.code_);
 }
 
 TEST_F(FilesystemCopierActionTest, FullUpdateTest) {
   ActionProcessor processor;
   FilesystemCopierActionTest2Delegate delegate;
 
   processor.set_delegate(&delegate);
 
   ObjectFeederAction<InstallPlan> feeder_action;
   const char* kUrl = "http://some/url";
   InstallPlan install_plan(true, kUrl, 0, "", "", "");
   feeder_action.set_obj(install_plan);
   FilesystemCopierAction copier_action(false);
   ObjectCollectorAction<InstallPlan> collector_action;
 
   BondActions(&feeder_action, &copier_action);
   BondActions(&copier_action, &collector_action);
 
   processor.EnqueueAction(&feeder_action);
   processor.EnqueueAction(&copier_action);
   processor.EnqueueAction(&collector_action);
   processor.StartProcessing();
   EXPECT_FALSE(processor.IsRunning());
   EXPECT_TRUE(delegate.ran_);
-  EXPECT_TRUE(delegate.success_);
+  EXPECT_EQ(kActionCodeSuccess, delegate.code_);
   EXPECT_EQ(kUrl, collector_action.object().download_url);
 }
 
 TEST_F(FilesystemCopierActionTest, NonExistentDriveTest) {
   ActionProcessor processor;
   FilesystemCopierActionTest2Delegate delegate;
 
   processor.set_delegate(&delegate);
 
   ObjectFeederAction<InstallPlan> feeder_action;
   InstallPlan install_plan(false, "", 0, "", "/no/such/file", "/no/such/file");
   feeder_action.set_obj(install_plan);
   FilesystemCopierAction copier_action(false);
   ObjectCollectorAction<InstallPlan> collector_action;
 
   BondActions(&copier_action, &collector_action);
 
   processor.EnqueueAction(&feeder_action);
   processor.EnqueueAction(&copier_action);
   processor.EnqueueAction(&collector_action);
   processor.StartProcessing();
   EXPECT_FALSE(processor.IsRunning());
   EXPECT_TRUE(delegate.ran_);
-  EXPECT_FALSE(delegate.success_);
+  EXPECT_EQ(kActionCodeError, delegate.code_);
 }
 
 TEST_F(FilesystemCopierActionTest, RunAsRootNoSpaceTest) {
   ASSERT_EQ(0, getuid());
   DoTest(true, false, false);
 }
 
 TEST_F(FilesystemCopierActionTest, RunAsRootTerminateEarlyTest) {
   ASSERT_EQ(0, getuid());
   DoTest(false, true, false);
 }
 
 }  // namespace chromeos_update_engine