AU: Execute postinst asynchronously so that the D-Bus service is not blocked.

postinstall_runner_action_unittest.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 <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
 #include <string>
 #include <vector>
 #include <gtest/gtest.h>
 #include "update_engine/postinstall_runner_action.h"
 #include "update_engine/test_utils.h"
 #include "update_engine/utils.h"
 
 using std::string;
 using std::vector;
 
 namespace chromeos_update_engine {
 
+namespace {
+gboolean StartProcessorInRunLoop(gpointer data) {
+  ActionProcessor *processor = reinterpret_cast<ActionProcessor*>(data);
+  processor->StartProcessing();
+  return FALSE;
+}
+}  // namespace
+
 class PostinstallRunnerActionTest : public ::testing::Test {
  public:
   void DoTest(bool do_losetup, bool do_err_script);
 };
 
 class PostinstActionProcessorDelegate : public ActionProcessorDelegate {
  public:
   PostinstActionProcessorDelegate()
-      : code_(kActionCodeError),
+      : loop_(NULL),
+        code_(kActionCodeError),
         code_set_(false) {}
+  void ProcessingDone(const ActionProcessor* processor,
+                      ActionExitCode code) {
+    ASSERT_TRUE(loop_);
+    g_main_loop_quit(loop_);
+  }
   void ActionCompleted(ActionProcessor* processor,
                        AbstractAction* action,
                        ActionExitCode code) {
     if (action->Type() == PostinstallRunnerAction::StaticType()) {
       code_ = code;
       code_set_ = true;
     }
   }
+  GMainLoop* loop_;
   ActionExitCode code_;
   bool code_set_;
 };
 
 TEST_F(PostinstallRunnerActionTest, RunAsRootSimpleTest) {
   ASSERT_EQ(0, getuid());
   DoTest(true, false);
 }
 
 TEST_F(PostinstallRunnerActionTest, RunAsRootCantMountTest) {
@@ skipping 70 matching lines @@
   feeder_action.set_obj(install_plan);
   PostinstallRunnerAction runner_action;
   BondActions(&feeder_action, &runner_action);
   ObjectCollectorAction<InstallPlan> collector_action;
   BondActions(&runner_action, &collector_action);
   PostinstActionProcessorDelegate delegate;
   processor.EnqueueAction(&feeder_action);
   processor.EnqueueAction(&runner_action);
   processor.EnqueueAction(&collector_action);
   processor.set_delegate(&delegate);
-  processor.StartProcessing();
-  ASSERT_FALSE(processor.IsRunning())
-      << "Update test to handle non-asynch actions";
+
+  GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE);
+  delegate.loop_ = loop;
+  g_timeout_add(0, &StartProcessorInRunLoop, &processor);
+  g_main_loop_run(loop);
+  g_main_loop_unref(loop);
+  ASSERT_FALSE(processor.IsRunning());
 
   EXPECT_TRUE(delegate.code_set_);
   EXPECT_EQ(do_losetup && !do_err_script, delegate.code_ == kActionCodeSuccess);
   EXPECT_EQ(do_losetup && !do_err_script,
             !collector_action.object().install_path.empty());
   if (do_losetup && !do_err_script) {
     EXPECT_TRUE(install_plan == collector_action.object());
   }
 
   struct stat stbuf;
@@ skipping 11 matching lines @@
 
 // Death tests don't seem to be working on Hardy
 TEST_F(PostinstallRunnerActionTest, DISABLED_RunAsRootDeathTest) {
   ASSERT_EQ(0, getuid());
   PostinstallRunnerAction runner_action;
   ASSERT_DEATH({ runner_action.TerminateProcessing(); },
                "postinstall_runner_action.h:.*] Check failed");
 }
 
 }  // namespace chromeos_update_engine