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

utils.h

 // 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_UTILS_H__
 #define CHROMEOS_PLATFORM_UPDATE_ENGINE_UTILS_H__
 
 #include <errno.h>
 
 #include <algorithm>
@@ skipping 219 matching lines @@
 // Sets the current process priority to |priority|. Returns true on
 // success, false otherwise.
 bool SetProcessPriority(ProcessPriority priority);
 
 }  // namespace utils
 
 // Class to unmount FS when object goes out of scope
 class ScopedFilesystemUnmounter {
  public:
   explicit ScopedFilesystemUnmounter(const std::string& mountpoint)
-      : mountpoint_(mountpoint) {}
+      : mountpoint_(mountpoint),
+        should_unmount_(true) {}
   ~ScopedFilesystemUnmounter() {
-    utils::UnmountFilesystem(mountpoint_);
+    if (should_unmount_) {
+      utils::UnmountFilesystem(mountpoint_);
+    }
   }
+  void set_should_unmount(bool unmount) { should_unmount_ = unmount; }
  private:
   const std::string mountpoint_;
+  bool should_unmount_;
   DISALLOW_COPY_AND_ASSIGN(ScopedFilesystemUnmounter);
 };
 
 // Utility class to close a file descriptor
 class ScopedFdCloser {
  public:
   explicit ScopedFdCloser(int* fd) : fd_(fd), should_close_(true) {}
-  void set_should_close(bool should_close) { should_close_ = should_close; }
   ~ScopedFdCloser() {
-    if (!should_close_)
-      return;
-    if (fd_ && (*fd_ >= 0)) {
+    if (should_close_ && fd_ && (*fd_ >= 0)) {
       close(*fd_);
       *fd_ = -1;
     }
   }
+  void set_should_close(bool should_close) { should_close_ = should_close; }
  private:
   int* fd_;
   bool should_close_;
   DISALLOW_COPY_AND_ASSIGN(ScopedFdCloser);
 };
 
 // Utility class to delete a file when it goes out of scope.
 class ScopedPathUnlinker {
  public:
   explicit ScopedPathUnlinker(const std::string& path) : path_(path) {}
   ~ScopedPathUnlinker() {
     if (unlink(path_.c_str()) < 0) {
       std::string err_message = strerror(errno);
       LOG(ERROR) << "Unable to unlink path " << path_ << ": " << err_message;
     }
   }
  private:
   const std::string path_;
   DISALLOW_COPY_AND_ASSIGN(ScopedPathUnlinker);
 };
 
 // Utility class to delete an empty directory when it goes out of scope.
 class ScopedDirRemover {
  public:
-  explicit ScopedDirRemover(const std::string& path) : path_(path) {}
+  explicit ScopedDirRemover(const std::string& path)
+      : path_(path),
+        should_remove_(true) {}
   ~ScopedDirRemover() {
-    if (rmdir(path_.c_str()) < 0)
+    if (should_remove_ && (rmdir(path_.c_str()) < 0)) {
       PLOG(ERROR) << "Unable to remove dir " << path_;
+    }
+  }
+  void set_should_remove(bool should_remove) { should_remove_ = should_remove; }
+
+ protected:
+  const std::string path_;
+
+ private:
+  bool should_remove_;
+  DISALLOW_COPY_AND_ASSIGN(ScopedDirRemover);
+};
+
+// Utility class to unmount a filesystem mounted on a temporary directory and
+// delete the temporary directory when it goes out of scope.
+class ScopedTempUnmounter : public ScopedDirRemover {
+ public:
+  explicit ScopedTempUnmounter(const std::string& path) :
+      ScopedDirRemover(path) {}
+  ~ScopedTempUnmounter() {
+    utils::UnmountFilesystem(path_);
   }
  private:
-  const std::string path_;
-  DISALLOW_COPY_AND_ASSIGN(ScopedDirRemover);
+  DISALLOW_COPY_AND_ASSIGN(ScopedTempUnmounter);
 };
 
 // A little object to call ActionComplete on the ActionProcessor when
 // it's destructed.
 class ScopedActionCompleter {
  public:
   explicit ScopedActionCompleter(ActionProcessor* processor,
                                  AbstractAction* action)
       : processor_(processor),
         action_(action),
@@ skipping 54 matching lines @@
     bool _success = (_x);                                                      \
     if (!_success) {                                                           \
       LOG(ERROR) << #_x " failed.";                                            \
       return;                                                                  \
     }                                                                          \
   } while (0)
 
 
 
 #endif  // CHROMEOS_PLATFORM_UPDATE_ENGINE_UTILS_H__