diff --git a/SConstruct b/SConstruct
index 9598975..6855425 100644
--- a/SConstruct
+++ b/SConstruct
@@ -138,7 +138,8 @@
   if os.environ.has_key(key):
     env['ENV'][key] = os.environ[key]
 
-env.ParseConfig('pkg-config --cflags --libs glib-2.0 dbus-1 dbus-glib-1')
+env.ParseConfig('pkg-config --cflags --libs '
+                'dbus-1 dbus-glib-1 gio-2.0 gio-unix-2.0 glib-2.0')
 env.ProtocolBuffer('update_metadata.pb.cc', 'update_metadata.proto')
 
 env.DbusBindings('update_engine.dbusclient.h', 'update_engine.xml')
@@ -190,6 +191,7 @@
                             extent_mapper_unittest.cc
                             extent_writer_unittest.cc
                             file_writer_unittest.cc
+                            filesystem_copier_action_unittest.cc
                             filesystem_iterator_unittest.cc
                             graph_utils_unittest.cc
                             http_fetcher_unittest.cc
diff --git a/filesystem_copier_action.cc b/filesystem_copier_action.cc
old mode 100644
new mode 100755
index 2a361ee..18bab44
--- a/filesystem_copier_action.cc
+++ b/filesystem_copier_action.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -12,6 +12,10 @@
 #include <map>
 #include <string>
 #include <vector>
+#include <gio/gio.h>
+#include <gio/gunixinputstream.h>
+#include <gio/gunixoutputstream.h>
+#include <glib.h>
 #include "update_engine/filesystem_iterator.h"
 #include "update_engine/subprocess.h"
 #include "update_engine/utils.h"
@@ -24,284 +28,144 @@
 namespace chromeos_update_engine {
 
 namespace {
-const char* kMountpointTemplate = "/tmp/au_dest_mnt.XXXXXX";
-const off_t kCopyFileBufferSize = 4 * 1024 * 1024;
-const char* kCopyExclusionPrefix = "/lost+found";
+const off_t kCopyFileBufferSize = 2 * 1024 * 1024;
 }  // namespace {}
 
 void FilesystemCopierAction::PerformAction() {
+  // Will tell the ActionProcessor we've failed if we return.
+  ScopedActionCompleter abort_action_completer(processor_, this);
+
   if (!HasInputObject()) {
-    LOG(ERROR) << "No input object. Aborting.";
-    processor_->ActionComplete(this, false);
+    LOG(ERROR) << "FilesystemCopierAction missing input object.";
     return;
   }
   install_plan_ = GetInputObject();
 
   if (install_plan_.is_full_update) {
-    // No copy needed.
-    processor_->ActionComplete(this, true);
+    // No copy needed. Done!
+    abort_action_completer.set_success(true);
     return;
   }
 
-  {
-    // Set up dest_path_
-    char *dest_path_temp = strdup(kMountpointTemplate);
-    CHECK(dest_path_temp);
-    CHECK_EQ(mkdtemp(dest_path_temp), dest_path_temp);
-    CHECK_NE(dest_path_temp[0], '\0');
-    dest_path_ = dest_path_temp;
-    free(dest_path_temp);
+  const string source =
+      copy_source_.empty() ? utils::BootDevice() : copy_source_;
+  LOG(INFO) << "Copying from " << source << " to "
+            << install_plan_.install_path;
+  
+  int src_fd = open(source.c_str(), O_RDONLY);
+  if (src_fd < 0) {
+    PLOG(ERROR) << "Unable to open " << source << " for reading:";
+    return;
+  }
+  int dst_fd = open(install_plan_.install_path.c_str(),
+                    O_WRONLY | O_TRUNC | O_CREAT,
+                    0644);
+  if (dst_fd < 0) {
+    close(src_fd);
+    PLOG(ERROR) << "Unable to open " << install_plan_.install_path
+                << " for writing:";
+    return;
   }
 
-  // Make sure we're properly mounted
-  if (Mount(install_plan_.install_path, dest_path_)) {
-    bool done_early = false;
-    if (utils::FileExists(
-            (dest_path_ +
-             FilesystemCopierAction::kCompleteFilesystemMarker).c_str())) {
-      // We're done!
-      done_early = true;
-      skipped_copy_ = true;
-      if (HasOutputPipe())
-        SetOutputObject(install_plan_);
-    }
-    if (!Unmount(dest_path_)) {
-      LOG(ERROR) << "Unmount failed. Aborting.";
-      processor_->ActionComplete(this, false);
-      return;
-    }
-    if (done_early) {
-      CHECK(!is_mounted_);
-      if (rmdir(dest_path_.c_str()) != 0)
-        LOG(ERROR) << "Unable to remove " << dest_path_;
-      processor_->ActionComplete(this, true);
-      return;
-    }
-  }
-  LOG(ERROR) << "not mounted; spawning thread";
-  // If we get here, mount failed or we're not done yet. Reformat and copy.
-  CHECK_EQ(pthread_create(&helper_thread_, NULL, HelperThreadMainStatic, this),
-           0);
+  src_stream_ = g_unix_input_stream_new(src_fd, TRUE);
+  dst_stream_ = g_unix_output_stream_new(dst_fd, TRUE);
+
+  buffer_.resize(kCopyFileBufferSize);
+
+  // Set up the first read
+  canceller_ = g_cancellable_new();
+
+  g_input_stream_read_async(src_stream_,
+                            &buffer_[0],
+                            buffer_.size(),
+                            G_PRIORITY_DEFAULT,
+                            canceller_,
+                            &FilesystemCopierAction::StaticAsyncReadyCallback,
+                            this);
+  read_in_flight_ = true;
+
+  abort_action_completer.set_should_complete(false);
 }
 
 void FilesystemCopierAction::TerminateProcessing() {
-  if (is_mounted_) {
-    LOG(ERROR) << "Aborted processing, but left a filesystem mounted.";
+  if (canceller_) {
+    g_cancellable_cancel(canceller_);
   }
 }
 
-bool FilesystemCopierAction::Mount(const string& device,
-                                   const string& mountpoint) {
-  CHECK(!is_mounted_);
-  if(utils::MountFilesystem(device, mountpoint, 0))
-    is_mounted_ = true;
-  return is_mounted_;
-}
-
-bool FilesystemCopierAction::Unmount(const string& mountpoint) {
-  CHECK(is_mounted_);
-  if (utils::UnmountFilesystem(mountpoint))
-    is_mounted_ = false;
-  return !is_mounted_;
-}
-
-void* FilesystemCopierAction::HelperThreadMain() {
-  // First, format the drive
-  vector<string> cmd;
-  cmd.push_back("/sbin/mkfs.ext3");
-  cmd.push_back("-F");
-  cmd.push_back(install_plan_.install_path);
-  int return_code = 1;
-  bool success = Subprocess::SynchronousExec(cmd, &return_code);
-  if (return_code != 0) {
-    LOG(INFO) << "Format of " << install_plan_.install_path
-              << " failed. Exit code: " << return_code;
-    success = false;
-  }
-  if (success) {
-    if (!Mount(install_plan_.install_path, dest_path_)) {
-      LOG(ERROR) << "Mount failed. Aborting";
-      success = false;
-    }
-  }
-  if (success) {
-    success = CopySynchronously();
-  }
-  if (success) {
-    // Place our marker to avoid copies again in the future
-    int r = open((dest_path_ +
-                  FilesystemCopierAction::kCompleteFilesystemMarker).c_str(),
-                 O_CREAT | O_WRONLY, 0644);
-    if (r >= 0)
-      close(r);
-  }
-  // Unmount
-  if (!Unmount(dest_path_)) {
-    LOG(ERROR) << "Unmount failed. Aborting";
-    success = false;
-  }
-  if (HasOutputPipe())
+void FilesystemCopierAction::Cleanup(bool success, bool was_cancelled) {
+  g_object_unref(src_stream_);
+  src_stream_ = NULL;
+  g_object_unref(dst_stream_);
+  dst_stream_ = NULL;
+  if (was_cancelled)
+    return;
+  if (success && HasOutputPipe())
     SetOutputObject(install_plan_);
-
-  // Tell main thread that we're done
-  g_timeout_add(0, CollectThreadStatic, this);
-  return reinterpret_cast<void*>(success ? 0 : 1);
-}
-
-void FilesystemCopierAction::CollectThread() {
-  void *thread_ret_value = NULL;
-  CHECK_EQ(pthread_join(helper_thread_, &thread_ret_value), 0);
-  bool success = (thread_ret_value == 0);
-  CHECK(!is_mounted_);
-  if (rmdir(dest_path_.c_str()) != 0)
-    LOG(INFO) << "Unable to remove " << dest_path_;
-  LOG(INFO) << "FilesystemCopierAction done";
   processor_->ActionComplete(this, success);
 }
 
-bool FilesystemCopierAction::CreateDirSynchronously(const std::string& new_path,
-                                                    const struct stat& stbuf) {
-  int r = mkdir(new_path.c_str(), stbuf.st_mode);
-  TEST_AND_RETURN_FALSE_ERRNO(r == 0);
-  return true;
-}
+void FilesystemCopierAction::AsyncReadyCallback(GObject *source_object,
+                                                GAsyncResult *res) {
+  GError* error = NULL;
+  CHECK(canceller_);
+  bool was_cancelled = g_cancellable_is_cancelled(canceller_) == TRUE;
+  g_object_unref(canceller_);
+  canceller_ = NULL;
 
-bool FilesystemCopierAction::CopyFileSynchronously(const std::string& old_path,
-                                                   const std::string& new_path,
-                                                   const struct stat& stbuf) {
-  int fd_out = open(new_path.c_str(), O_CREAT | O_EXCL | O_WRONLY,
-                    stbuf.st_mode);
-  TEST_AND_RETURN_FALSE_ERRNO(fd_out >= 0);
-  ScopedFdCloser fd_out_closer(&fd_out);
-  int fd_in = open(old_path.c_str(), O_RDONLY, 0);
-  TEST_AND_RETURN_FALSE_ERRNO(fd_in >= 0);
-  ScopedFdCloser fd_in_closer(&fd_in);
-
-  vector<char> buf(min(kCopyFileBufferSize, stbuf.st_size));
-  off_t bytes_written = 0;
-  while (true) {
-    // Make sure we don't need to abort early:
-    TEST_AND_RETURN_FALSE(!g_atomic_int_get(&thread_should_exit_));
-
-    ssize_t read_size = read(fd_in, &buf[0], buf.size());
-    TEST_AND_RETURN_FALSE_ERRNO(read_size >= 0);
-    if (0 == read_size)  // EOF
-      break;
-
-    ssize_t write_size = 0;
-    while (write_size < read_size) {
-      ssize_t r = write(fd_out, &buf[write_size], read_size - write_size);
-      TEST_AND_RETURN_FALSE_ERRNO(r >= 0);
-      write_size += r;
+  if (read_in_flight_) {
+    ssize_t bytes_read = g_input_stream_read_finish(src_stream_, res, &error);
+    if (bytes_read < 0) {
+      LOG(ERROR) << "Read failed:" << utils::GetGErrorMessage(error);
+      Cleanup(false, was_cancelled);
+      return;
     }
-    CHECK_EQ(write_size, read_size);
-    bytes_written += write_size;
-    CHECK_LE(bytes_written, stbuf.st_size);
-    if (bytes_written == stbuf.st_size)
-      break;
+
+    if (bytes_read == 0) {
+      // We're done!
+      Cleanup(true, was_cancelled);
+      return;
+    }
+    // Kick off a write
+    read_in_flight_ = false;
+    buffer_valid_size_ = bytes_read;
+    canceller_ = g_cancellable_new();
+    g_output_stream_write_async(
+        dst_stream_,
+        &buffer_[0],
+        bytes_read,
+        G_PRIORITY_DEFAULT,
+        canceller_,
+        &FilesystemCopierAction::StaticAsyncReadyCallback,
+        this);
+    return;
   }
-  CHECK_EQ(bytes_written, stbuf.st_size);
-  return true;
-}
 
-bool FilesystemCopierAction::CreateHardLinkSynchronously(
-    const std::string& old_path,
-    const std::string& new_path) {
-  int r = link(old_path.c_str(), new_path.c_str());
-  TEST_AND_RETURN_FALSE_ERRNO(r == 0);
-  return true;
-}
-
-bool FilesystemCopierAction::CopySymlinkSynchronously(
-    const std::string& old_path,
-    const std::string& new_path,
-    const struct stat& stbuf) {
-  vector<char> buf(PATH_MAX + 1);
-  ssize_t r = readlink(old_path.c_str(), &buf[0], buf.size());
-  TEST_AND_RETURN_FALSE_ERRNO(r >= 0);
-  // Make sure we got the entire link
-  TEST_AND_RETURN_FALSE(static_cast<unsigned>(r) < buf.size());
-  buf[r] = '\0';
-  int rc = symlink(&buf[0], new_path.c_str());
-  TEST_AND_RETURN_FALSE_ERRNO(rc == 0);
-  return true;
-}
-
-bool FilesystemCopierAction::CreateNodeSynchronously(
-    const std::string& new_path,
-    const struct stat& stbuf) {
-  int r = mknod(new_path.c_str(), stbuf.st_mode, stbuf.st_rdev);
-  TEST_AND_RETURN_FALSE_ERRNO(r == 0);
-  return true;
-}
-
-// Returns true on success
-bool FilesystemCopierAction::CopySynchronously() {
-  // This map is a map from inode # to new_path.
-  map<ino_t, string> hard_links;
-  FilesystemIterator iter(copy_source_,
-                          utils::SetWithValue<string>(kCopyExclusionPrefix));
-  bool success = true;
-  for (; !g_atomic_int_get(&thread_should_exit_) &&
-           !iter.IsEnd(); iter.Increment()) {
-    const string old_path = iter.GetFullPath();
-    const string new_path = dest_path_ + iter.GetPartialPath();
-    LOG(INFO) << "copying " << old_path << " to " << new_path;
-    const struct stat stbuf = iter.GetStat();
-    success = false;
-
-    // Skip lost+found
-    CHECK_NE(kCopyExclusionPrefix, iter.GetPartialPath());
-
-    // Directories can't be hard-linked, so check for directories first
-    if (iter.GetPartialPath().empty()) {
-      // Root has an empty path.
-      // We don't need to create anything for the root, which is the first
-      // thing we get from the iterator.
-      success = true;
-    } else if (S_ISDIR(stbuf.st_mode)) {
-      success = CreateDirSynchronously(new_path, stbuf);
+  ssize_t bytes_written = g_output_stream_write_finish(dst_stream_,
+                                                       res,
+                                                       &error);
+  if (bytes_written < static_cast<ssize_t>(buffer_valid_size_)) {
+    if (bytes_written < 0) {
+      LOG(ERROR) << "Write failed:" << utils::GetGErrorMessage(error);
     } else {
-      if (stbuf.st_nlink > 1 &&
-          utils::MapContainsKey(hard_links, stbuf.st_ino)) {
-        success = CreateHardLinkSynchronously(hard_links[stbuf.st_ino],
-                                              new_path);
-      } else {
-        if (stbuf.st_nlink > 1)
-          hard_links[stbuf.st_ino] = new_path;
-        if (S_ISREG(stbuf.st_mode)) {
-          success = CopyFileSynchronously(old_path, new_path, stbuf);
-        } else if (S_ISLNK(stbuf.st_mode)) {
-          success = CopySymlinkSynchronously(old_path, new_path, stbuf);
-        } else if (S_ISFIFO(stbuf.st_mode) ||
-                   S_ISCHR(stbuf.st_mode) ||
-                   S_ISBLK(stbuf.st_mode) ||
-                   S_ISSOCK(stbuf.st_mode)) {
-          success = CreateNodeSynchronously(new_path, stbuf);
-        } else {
-          CHECK(false) << "Unable to copy file " << old_path << " with mode "
-                       << stbuf.st_mode;
-        }
-      }
+      LOG(ERROR) << "Write was short: wrote " << bytes_written
+                 << " but expected to write " << buffer_valid_size_;
     }
-    TEST_AND_RETURN_FALSE(success);
-
-    // chmod new file
-    if (!S_ISLNK(stbuf.st_mode)) {
-      int r = chmod(new_path.c_str(), stbuf.st_mode);
-      TEST_AND_RETURN_FALSE_ERRNO(r == 0);
-    }
-
-    // Set uid/gid.
-    int r = lchown(new_path.c_str(), stbuf.st_uid, stbuf.st_gid);
-    TEST_AND_RETURN_FALSE_ERRNO(r == 0);
+    Cleanup(false, was_cancelled);
+    return;
   }
-  TEST_AND_RETURN_FALSE(!iter.IsErr());
-  // Success!
-  return true;
-}
 
-const char* FilesystemCopierAction::kCompleteFilesystemMarker(
-    "/update_engine_copy_success");
+  // Kick off a read
+  read_in_flight_ = true;
+  canceller_ = g_cancellable_new();
+  g_input_stream_read_async(
+      src_stream_,
+      &buffer_[0],
+      buffer_.size(),
+      G_PRIORITY_DEFAULT,
+      canceller_,
+      &FilesystemCopierAction::StaticAsyncReadyCallback,
+      this);
+}
 
 }  // namespace chromeos_update_engine
diff --git a/filesystem_copier_action.h b/filesystem_copier_action.h
index 3a330ef..9e7f060 100644
--- a/filesystem_copier_action.h
+++ b/filesystem_copier_action.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -8,30 +8,14 @@
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <string>
+#include <vector>
+#include <gio/gio.h>
 #include <glib.h>
 #include "update_engine/action.h"
 #include "update_engine/install_plan.h"
 
 // This action will only do real work if it's a delta update. It will
-// format the install partition as ext3/4, copy the root filesystem into it,
-// and then terminate.
-
-// Implementation notes: This action uses a helper thread, which seems to
-// violate the design decision to only have a single thread and use
-// asynchronous i/o. The issue is that (to the best of my knowledge),
-// there are no linux APIs to crawl a filesystem's metadata asynchronously.
-// The suggested way seems to be to open the raw device and parse the ext
-// filesystem. That's not a good approach for a number of reasons:
-// - ties us to ext filesystem
-// - although this wouldn't happen at the time of writing, it may not handle
-//   changes to the source fs during the copy as gracefully.
-// - requires us to have read-access to the source filesystem device, which
-//   may be a security issue.
-//
-// Having said this, using a helper thread is not ideal, but it's acceptable:
-// we still honor the Action API. That is, all interaction between the action
-// and other objects in the system (e.g. the ActionProcessor) happens on the
-// main thread. The helper thread is fully encapsulated by the action.
+// copy the root partition to install partition, and then terminate.
 
 namespace chromeos_update_engine {
 
@@ -49,10 +33,11 @@
 class FilesystemCopierAction : public Action<FilesystemCopierAction> {
  public:
   FilesystemCopierAction()
-      : thread_should_exit_(0),
-        is_mounted_(false),
-        copy_source_("/"),
-        skipped_copy_(false) {}
+      : src_stream_(NULL),
+        dst_stream_(NULL),
+        canceller_(NULL),
+        read_in_flight_(false),
+        buffer_valid_size_(0) {}
   typedef ActionTraits<FilesystemCopierAction>::InputObjectType
   InputObjectType;
   typedef ActionTraits<FilesystemCopierAction>::OutputObjectType
@@ -64,81 +49,51 @@
   void set_copy_source(const std::string& path) {
     copy_source_ = path;
   }
-  // Returns true if we detected that a copy was unneeded and thus skipped it.
-  bool skipped_copy() { return skipped_copy_; }
 
   // Debugging/logging
   static std::string StaticType() { return "FilesystemCopierAction"; }
   std::string Type() const { return StaticType(); }
 
  private:
-  // These synchronously mount or unmount the given mountpoint
-  bool Mount(const std::string& device, const std::string& mountpoint);
-  bool Unmount(const std::string& mountpoint);
-
-  // Performs a recursive file/directory copy from copy_source_ to dest_path_.
-  // Doesn't return until the copy has completed. Returns true on success
-  // or false on error.
-  bool CopySynchronously();
-
-  // There are helper functions for CopySynchronously. They handle creating
-  // various types of files. They return true on success.
-  bool CreateDirSynchronously(const std::string& new_path,
-                              const struct stat& stbuf);
-  bool CopyFileSynchronously(const std::string& old_path,
-                             const std::string& new_path,
-                             const struct stat& stbuf);
-  bool CreateHardLinkSynchronously(const std::string& old_path,
-                                   const std::string& new_path);
-  // Note: Here, old_path is an existing symlink that will be copied to
-  // new_path. Thus, old_path is *not* the same as the old_path from
-  // the symlink() syscall.
-  bool CopySymlinkSynchronously(const std::string& old_path,
-                                const std::string& new_path,
-                                const struct stat& stbuf);
-  bool CreateNodeSynchronously(const std::string& new_path,
-                               const struct stat& stbuf);
-
-  // Returns NULL on success
-  void* HelperThreadMain();
-  static void* HelperThreadMainStatic(void* data) {
-    FilesystemCopierAction* self =
-        reinterpret_cast<FilesystemCopierAction*>(data);
-    return self->HelperThreadMain();
+  // Callback from glib when the copy operation is done.
+  void AsyncReadyCallback(GObject *source_object, GAsyncResult *res);
+  static void StaticAsyncReadyCallback(GObject *source_object,
+                                       GAsyncResult *res,
+                                       gpointer user_data) {
+    reinterpret_cast<FilesystemCopierAction*>(user_data)->AsyncReadyCallback(
+        source_object, res);
   }
-
-  // Joins the thread and tells the processor that we're done
-  void CollectThread();
-  // GMainLoop callback function:
-  static gboolean CollectThreadStatic(gpointer data) {
-    FilesystemCopierAction* self =
-        reinterpret_cast<FilesystemCopierAction*>(data);
-    self->CollectThread();
-    return FALSE;
-  }
-
-  pthread_t helper_thread_;
-
-  volatile gint thread_should_exit_;
-
-  static const char* kCompleteFilesystemMarker;
-
-  // Whether or not the destination device is currently mounted.
-  bool is_mounted_;
-
-  // Where the destination device is mounted.
-  std::string dest_path_;
-
-  // The path to copy from. Usually left as the default "/", but tests can
-  // change it.
+  
+  // Cleans up all the variables we use for async operations and tells
+  // the ActionProcessor we're done w/ success as passed in.
+  // was_cancelled should be true if TerminateProcessing() was called.
+  void Cleanup(bool success, bool was_cancelled);
+  
+  // The path to copy from. If empty (the default), the source is from the
+  // passed in InstallPlan.
   std::string copy_source_;
 
+  // If non-NULL, these are GUnixInputStream objects for the opened
+  // source/destination partitions.
+  GInputStream* src_stream_;
+  GOutputStream* dst_stream_;
+  
+  // If non-NULL, the cancellable object for the in-flight async call.
+  GCancellable* canceller_;
+  
+  // True if we're waiting on a read to complete; false if we're
+  // waiting on a write.
+  bool read_in_flight_;
+  
+  // The buffer for storing data we read/write.
+  std::vector<char> buffer_;
+
+  // Number of valid elements in buffer_.
+  std::vector<char>::size_type buffer_valid_size_;
+
   // The install plan we're passed in via the input pipe.
   InstallPlan install_plan_;
-
-  // Set to true if we detected the copy was unneeded and thus we skipped it.
-  bool skipped_copy_;
-
+  
   DISALLOW_COPY_AND_ASSIGN(FilesystemCopierAction);
 };
 
diff --git a/filesystem_copier_action_unittest.cc b/filesystem_copier_action_unittest.cc
index 86c15ac..3ccea2b 100644
--- a/filesystem_copier_action_unittest.cc
+++ b/filesystem_copier_action_unittest.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -7,6 +7,7 @@
 #include <string>
 #include <vector>
 #include <gtest/gtest.h>
+#include "base/string_util.h"
 #include "update_engine/filesystem_copier_action.h"
 #include "update_engine/filesystem_iterator.h"
 #include "update_engine/omaha_hash_calculator.h"
@@ -21,22 +22,28 @@
 
 class FilesystemCopierActionTest : public ::testing::Test {
  protected:
-  void DoTest(bool double_copy, bool run_out_of_space);
-  string TestDir() { return "./FilesystemCopierActionTestDir"; }
+  void DoTest(bool run_out_of_space, bool terminate_early);
   void SetUp() {
-    System(string("mkdir -p ") + TestDir());
   }
   void TearDown() {
-    System(string("rm -rf ") + TestDir());
   }
 };
 
 class FilesystemCopierActionTestDelegate : public ActionProcessorDelegate {
  public:
   FilesystemCopierActionTestDelegate() : ran_(false), success_(false) {}
-  void ProcessingDone(const ActionProcessor* processor, bool success) {
+  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) {
+    ExitMainLoop();
+  }
+  void ProcessingStopped(const ActionProcessor* processor) {
+    ExitMainLoop();
+  }
   void ActionCompleted(ActionProcessor* processor,
                        AbstractAction* action,
                        bool success) {
@@ -56,9 +63,21 @@
   bool success_;
 };
 
+struct StartProcessorCallbackArgs {
+  ActionProcessor* processor;
+  FilesystemCopierAction* filesystem_copier_action;
+  bool terminate_early;
+};
+
 gboolean StartProcessorInRunLoop(gpointer data) {
-  ActionProcessor* processor = reinterpret_cast<ActionProcessor*>(data);
+  StartProcessorCallbackArgs* args =
+      reinterpret_cast<StartProcessorCallbackArgs*>(data);
+  ActionProcessor* processor = args->processor;
   processor->StartProcessing();
+  if (args->terminate_early) {
+    EXPECT_TRUE(args->filesystem_copier_action);
+    args->processor->StopProcessing();
+  }
   return FALSE;
 }
 
@@ -66,44 +85,54 @@
   ASSERT_EQ(0, getuid());
   DoTest(false, false);
 }
-void FilesystemCopierActionTest::DoTest(bool double_copy,
-                                        bool run_out_of_space) {
+void FilesystemCopierActionTest::DoTest(bool run_out_of_space,
+                                        bool terminate_early) {
   GMainLoop *loop = g_main_loop_new(g_main_context_default(), FALSE);
 
-  // make two populated ext images, mount them both (one in the other),
-  // and copy to a loop device setup to correspond to another file.
+  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
 
-  const string a_image(TestDir() + "/a_image");
-  const string b_image(TestDir() + "/b_image");
-  const string out_image(TestDir() + "/out_image");
+  // Write data to disk
+  EXPECT_TRUE(WriteFileVector(a_loop_file, a_loop_data));
+  EXPECT_TRUE(WriteFileVector(b_loop_file, b_loop_data));
 
-  vector<string> expected_paths_vector;
-  CreateExtImageAtPath(a_image, &expected_paths_vector);
-  CreateExtImageAtPath(b_image, NULL);
+  // Make loop devices for the files
+  string a_dev = GetUnusedLoopDevice();
+  EXPECT_FALSE(a_dev.empty());
+  EXPECT_EQ(0, System(StringPrintf("losetup %s %s",
+                                   a_dev.c_str(),
+                                   a_loop_file.c_str())));
+  ScopedLoopbackDeviceReleaser a_dev_releaser(a_dev);
 
-  // create 5 MiB file
-  ASSERT_EQ(0, System(string("dd if=/dev/zero of=") + out_image
-                      + " seek=5242879 bs=1 count=1"));
+  string b_dev = GetUnusedLoopDevice();
+  EXPECT_FALSE(b_dev.empty());
+  EXPECT_EQ(0, System(StringPrintf("losetup %s %s",
+                                   b_dev.c_str(),
+                                   b_loop_file.c_str())));
+  ScopedLoopbackDeviceReleaser b_dev_releaser(b_dev);
 
-  // mount them both
-  System(("mkdir -p " + TestDir() + "/mnt").c_str());
-  ASSERT_EQ(0, System(string("mount -o loop ") + a_image + " " +
-                      TestDir() + "/mnt"));
-  ASSERT_EQ(0,
-            System(string("mount -o loop ") + b_image + " " +
-                   TestDir() + "/mnt/some_dir/mnt"));
-
-  if (run_out_of_space)
-    ASSERT_EQ(0, System(string("dd if=/dev/zero of=") +
-                        TestDir() + "/mnt/big_zero bs=5M count=1"));
-
-  string dev = GetUnusedLoopDevice();
-
-  EXPECT_EQ(0, System(string("losetup ") + dev + " " + out_image));
-
+  // Set up the action objects
   InstallPlan install_plan;
   install_plan.is_full_update = false;
-  install_plan.install_path = dev;
+  install_plan.install_path = b_dev;
 
   ActionProcessor processor;
   FilesystemCopierActionTestDelegate delegate;
@@ -112,72 +141,43 @@
 
   ObjectFeederAction<InstallPlan> feeder_action;
   FilesystemCopierAction copier_action;
-  FilesystemCopierAction copier_action2;
   ObjectCollectorAction<InstallPlan> collector_action;
 
   BondActions(&feeder_action, &copier_action);
-  if (double_copy) {
-    BondActions(&copier_action, &copier_action2);
-    BondActions(&copier_action2, &collector_action);
-  } else {
-    BondActions(&copier_action, &collector_action);
-  }
+  BondActions(&copier_action, &collector_action);
 
   processor.EnqueueAction(&feeder_action);
   processor.EnqueueAction(&copier_action);
-  if (double_copy)
-    processor.EnqueueAction(&copier_action2);
   processor.EnqueueAction(&collector_action);
 
-  copier_action.set_copy_source(TestDir() + "/mnt");
+  copier_action.set_copy_source(a_dev);
   feeder_action.set_obj(install_plan);
 
-  g_timeout_add(0, &StartProcessorInRunLoop, &processor);
+  StartProcessorCallbackArgs start_callback_args;
+  start_callback_args.processor = &processor;
+  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);
 
-  EXPECT_EQ(0, System(string("losetup -d ") + dev));
-  EXPECT_EQ(0, System(string("umount -d ") + TestDir() + "/mnt/some_dir/mnt"));
-  EXPECT_EQ(0, System(string("umount -d ") + TestDir() + "/mnt"));
-  EXPECT_EQ(0, unlink(a_image.c_str()));
-  EXPECT_EQ(0, unlink(b_image.c_str()));
-
-  EXPECT_TRUE(delegate.ran());
-  if (run_out_of_space) {
+  if (!terminate_early)
+    EXPECT_TRUE(delegate.ran());
+  if (run_out_of_space || terminate_early) {
     EXPECT_FALSE(delegate.success());
-    EXPECT_EQ(0, unlink(out_image.c_str()));
-    EXPECT_EQ(0, rmdir((TestDir() + "/mnt").c_str()));
     return;
   }
   EXPECT_TRUE(delegate.success());
 
-  EXPECT_EQ(0, System(string("mount -o loop ") + out_image + " " +
-                      TestDir() + "/mnt"));
   // Make sure everything in the out_image is there
-  expected_paths_vector.push_back("/update_engine_copy_success");
-  for (vector<string>::iterator it = expected_paths_vector.begin();
-       it != expected_paths_vector.end(); ++it) {
-    *it = TestDir() + "/mnt" + *it;
-  }
-  set<string> expected_paths(expected_paths_vector.begin(),
-                             expected_paths_vector.end());
-  VerifyAllPaths(TestDir() + "/mnt", expected_paths);
-  string file_data;
-  EXPECT_TRUE(utils::ReadFileToString(TestDir() + "/mnt/hi", &file_data));
-  EXPECT_EQ("hi\n", file_data);
-  EXPECT_TRUE(utils::ReadFileToString(TestDir() + "/mnt/hello", &file_data));
-  EXPECT_EQ("hello\n", file_data);
-  EXPECT_EQ("/some/target", Readlink(TestDir() + "/mnt/sym"));
-  EXPECT_EQ(0, System(string("umount -d ") + TestDir() + "/mnt"));
+  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_EQ(0, unlink(out_image.c_str()));
-  EXPECT_EQ(0, rmdir((TestDir() + "/mnt").c_str()));
-
-  EXPECT_FALSE(copier_action.skipped_copy());
-  LOG(INFO) << "collected plan:";
-  collector_action.object().Dump();
-  LOG(INFO) << "expected plan:";
-  install_plan.Dump();
   EXPECT_TRUE(collector_action.object() == install_plan);
 }
 
@@ -262,12 +262,12 @@
   EXPECT_FALSE(delegate.success_);
 }
 
-TEST_F(FilesystemCopierActionTest, RunAsRootSkipUpdateTest) {
+TEST_F(FilesystemCopierActionTest, RunAsRootNoSpaceTest) {
   ASSERT_EQ(0, getuid());
   DoTest(true, false);
 }
 
-TEST_F(FilesystemCopierActionTest, RunAsRootNoSpaceTest) {
+TEST_F(FilesystemCopierActionTest, RunAsRootTerminateEarlyTest) {
   ASSERT_EQ(0, getuid());
   DoTest(false, true);
 }
diff --git a/testrunner.cc b/testrunner.cc
index 0a74480..933c25d 100644
--- a/testrunner.cc
+++ b/testrunner.cc
@@ -4,14 +4,21 @@
 
 // based on pam_google_testrunner.cc
 
+#include <dbus/dbus-glib.h>
+#include <dbus/dbus-glib-bindings.h>
+#include <dbus/dbus-glib-lowlevel.h>
 #include <glib.h>
+#include <glib-object.h>
 #include <gtest/gtest.h>
-
+#include "base/command_line.h"
 #include "update_engine/subprocess.h"
 
 int main(int argc, char **argv) {
+  ::g_type_init();
   g_thread_init(NULL);
+  dbus_g_thread_init();
   chromeos_update_engine::Subprocess::Init();
+  CommandLine::Init(argc, argv);
   ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }
diff --git a/update_engine_client.cc b/update_engine_client.cc
index 1e273ed..bed7205 100644
--- a/update_engine_client.cc
+++ b/update_engine_client.cc
@@ -16,6 +16,7 @@
 using chromeos_update_engine::kUpdateEngineServiceName;
 using chromeos_update_engine::kUpdateEngineServicePath;
 using chromeos_update_engine::kUpdateEngineServiceInterface;
+using chromeos_update_engine::utils::GetGErrorMessage;
 
 DEFINE_bool(status, false, "Print the status to stdout.");
 DEFINE_bool(force_update, false,
@@ -25,12 +26,6 @@
 
 namespace {
 
-const char* GetErrorMessage(const GError* error) {
-  if (!error)
-    return "Unknown error.";
-  return error->message;
-}
-
 bool GetStatus() {
   DBusGConnection *bus;
   DBusGProxy *proxy;
@@ -46,7 +41,7 @@
                                           kUpdateEngineServiceInterface,
                                           &error);
   if (!proxy) {
-    LOG(FATAL) << "Error getting proxy: " << GetErrorMessage(error);
+    LOG(FATAL) << "Error getting proxy: " << GetGErrorMessage(error);
   }
 
   gint64 last_checked_time = 0;
@@ -64,7 +59,7 @@
       &new_size,
       &error);
   if (rc == FALSE) {
-    LOG(INFO) << "Error getting status: " << GetErrorMessage(error);
+    LOG(INFO) << "Error getting status: " << GetGErrorMessage(error);
   }
   printf("LAST_CHECKED_TIME=%" PRIi64 "\nPROGRESS=%f\nCURRENT_OP=%s\n"
          "NEW_VERSION=%s\nNEW_SIZE=%" PRIi64 "\n",
diff --git a/utils.cc b/utils.cc
index 7f05ffb..724a4ba 100644
--- a/utils.cc
+++ b/utils.cc
@@ -333,6 +333,12 @@
   return true;
 }
 
+const char* GetGErrorMessage(const GError* error) {
+  if (!error)
+    return "Unknown error.";
+  return error->message;
+}
+
 const char* const kStatefulPartition = "/mnt/stateful_partition";
 
 }  // namespace utils
diff --git a/utils.h b/utils.h
index bcbd8da..7b6fc10 100644
--- a/utils.h
+++ b/utils.h
@@ -10,6 +10,7 @@
 #include <set>
 #include <string>
 #include <vector>
+#include <glib.h>
 #include "update_engine/action.h"
 #include "update_engine/action_processor.h"
 
@@ -78,6 +79,9 @@
                      unsigned long flags);
 bool UnmountFilesystem(const std::string& mountpoint);
 
+// Returns the error message, if any, from a GError pointer.
+const char* GetGErrorMessage(const GError* error);
+
 // Log a string in hex to LOG(INFO). Useful for debugging.
 void HexDumpArray(const unsigned char* const arr, const size_t length);
 inline void HexDumpString(const std::string& str) {