diff --git a/README.md b/README.md
new file mode 100644
index 0000000..8f2fe3a
--- /dev/null
+++ b/README.md
@@ -0,0 +1,15 @@
+# src/platform/imageloader
+
+This aims to provide a generic utility to load (mount) and unload (unmount)
+verified disk images through DBus IPC.
+
+# Binaries
+
+* `imageloader`
+* `imageloadclient`
+
+`imageloader` can be run as root and can handle mounting and unmounting of
+disk images. `imageloadclient` is a simple client (intended to be run as
+chronos) that can talk to `imageloader` and ask it to mount and unmount stuff.
+When `imageloader` is not running, DBus can invoke it via the one time
+run option (`imageloader -o`) and get the task done.
diff --git a/imageloadclient-glue.xml b/imageloadclient-glue.xml
new file mode 100644
index 0000000..f78ae28
--- /dev/null
+++ b/imageloadclient-glue.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" ?>
+<!--
+  Copyright 2016 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.
+-->
+<node name="/org/chromium/ImageLoader">
+  <interface name="org.chromium.ImageLoaderInterface">
+    <method name="RegisterComponent">
+      <arg type="s" name="name" direction="in"/>
+      <arg type="s" name="version" direction="in" />
+      <arg type="s" name="fs_image_abs_path" direction="in"/>
+      <arg type="b" name="success" direction="out" />
+    </method>
+    <method name="GetComponentVersion">
+      <arg type="s" name="name" direction="in" />
+      <arg type="s" name="version" direction="out" />
+    </method>
+    <method name="LoadComponent">
+      <arg type="s" name="name" direction="in" />
+      <arg type="s" name="mount_point" direction="out" />
+    </method>
+    <method name="UnloadComponent">
+      <arg type="s" name="name" direction="in" />
+      <arg type="b" name="success" direction="out" />
+    </method>
+  </interface>
+</node>
diff --git a/imageloadclient.cc b/imageloadclient.cc
new file mode 100644
index 0000000..42620c1
--- /dev/null
+++ b/imageloadclient.cc
@@ -0,0 +1,124 @@
+// Copyright 2016 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 "imageloadclient.h"
+
+#include <signal.h>
+
+#include <iostream>
+#include <string>
+
+#include <base/command_line.h>
+#include <base/files/file_path.h>
+#include <base/logging.h>
+#include <pthread.h>
+
+#include "imageloader_common.h"
+
+namespace imageloader {
+
+ImageLoadClient::ImageLoadClient(DBus::Connection* conn, const char* path,
+                                 const char* name)
+    : DBus::ObjectProxy(*conn, path, name) {}
+
+void ImageLoadClient::RegisterComponentCallback(const bool& success,
+                                                const ::DBus::Error& err,
+                                                void*) {
+  if (success) {
+    LOG(INFO) << "Success.";
+  } else {
+    LOG(INFO) << "Failure.";
+  }
+}
+
+void ImageLoadClient::GetComponentVersionCallback(const std::string& version,
+                                                  const ::DBus::Error& err,
+                                                  void*) {
+  if (version == kBadResult) {
+    LOG(INFO) << "Failure.";
+  } else {
+    LOG(INFO) << "Version = " << version;
+  }
+}
+
+void ImageLoadClient::LoadComponentCallback(const std::string& mount_point,
+                                            const ::DBus::Error& err, void*) {
+  if (mount_point == kBadResult) {
+    LOG(INFO) << "Could not mount.";
+  } else {
+    LOG(INFO) << "Mounted at " << mount_point << ".";
+  }
+}
+
+void ImageLoadClient::UnloadComponentCallback(const bool& success,
+                                              const ::DBus::Error& err,
+                                              void*) {
+  if (success) {
+    LOG(INFO) << "Success.";
+  } else {
+    LOG(INFO) << "Failure.";
+  }
+}
+
+namespace {
+
+void *TestCalls(void *arg) {
+  ImageLoadClient *client = reinterpret_cast<ImageLoadClient *>(arg);
+  while (1) {
+    std::string inp, name, abs_path, rel_path, version;
+    std::cin >> inp;
+    if (inp == "rc") {  // RegisterComponent
+      std::cin >> name;
+      std::cin >> version;
+      std::cin >> rel_path;
+      char* c_abs_path = realpath(rel_path.c_str(), NULL);
+      if (c_abs_path != NULL) {
+        abs_path = std::string(c_abs_path);
+        client->RegisterComponentAsync(name, version, abs_path, NULL);
+        free(c_abs_path);
+      } else {
+        PLOG(ERROR) << "realpath : " << rel_path;
+      }
+    } else if (inp == "gcv") {  // GetComponentVersion
+      std::cin >> name;
+      client->GetComponentVersionAsync(name, NULL);
+    } else if (inp == "lc") {  // LoadComponent
+      std::cin >> name;
+      client->LoadComponentAsync(name, NULL);
+    } else if (inp == "uc") {  // UnloadComponent
+      std::cin >> name;
+      client->UnloadComponentAsync(name, NULL);
+    }
+  }
+  return NULL;
+}
+
+}  // namespace {}
+
+}  // namespace imageloader
+
+int main(int argc, char** argv) {
+  signal(SIGTERM, imageloader::OnQuit);
+  signal(SIGINT, imageloader::OnQuit);
+
+  base::CommandLine::Init(argc, argv);
+  logging::LoggingSettings settings;
+  logging::InitLogging(settings);
+
+  DBus::_init_threading();
+  DBus::BusDispatcher dispatcher;
+  DBus::default_dispatcher = &dispatcher;
+  DBus::Connection conn = DBus::Connection::SystemBus();
+
+  imageloader::ImageLoadClient client(&conn, imageloader::kImageLoaderPath,
+                                      imageloader::kImageLoaderName);
+
+  pthread_t thread;
+  pthread_create(&thread, NULL, imageloader::TestCalls, &client);
+
+  dispatcher.enter();
+  LOG(INFO) << "Exiting ...";
+
+  return 0;
+}
diff --git a/imageloadclient.h b/imageloadclient.h
new file mode 100644
index 0000000..c948aef
--- /dev/null
+++ b/imageloadclient.h
@@ -0,0 +1,39 @@
+// Copyright 2016 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 IMAGELOADER_IMAGELOADCLIENT_H_
+#define IMAGELOADER_IMAGELOADCLIENT_H_
+
+#include <string>
+
+#include <dbus-c++/dbus.h>
+
+#include "imageloadclient-glue.h"
+
+namespace imageloader {
+
+// This is a simple client to use imageloader's service in non-root mode.
+class ImageLoadClient
+    : public org::chromium::ImageLoaderInterface_proxy,
+      public DBus::ObjectProxy {
+ public:
+  // Initialize the ImageLoadClient instance.
+  ImageLoadClient(DBus::Connection* conn, const char* path, const char* name);
+
+  void RegisterComponentCallback(const bool& success, const ::DBus::Error& err,
+                                 void* data);
+
+  void GetComponentVersionCallback(const std::string& version,
+                                   const ::DBus::Error& err, void* data);
+
+  void LoadComponentCallback(const std::string& mount_point,
+                             const ::DBus::Error& err, void* data);
+
+  void UnloadComponentCallback(const bool& success, const ::DBus::Error& err,
+                               void* data);
+};
+
+}  // namespace imageloader
+
+#endif  // IMAGELOADER_IMAGELOADCLIENT_H_
diff --git a/imageloader-glue.xml b/imageloader-glue.xml
new file mode 100644
index 0000000..f78ae28
--- /dev/null
+++ b/imageloader-glue.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" ?>
+<!--
+  Copyright 2016 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.
+-->
+<node name="/org/chromium/ImageLoader">
+  <interface name="org.chromium.ImageLoaderInterface">
+    <method name="RegisterComponent">
+      <arg type="s" name="name" direction="in"/>
+      <arg type="s" name="version" direction="in" />
+      <arg type="s" name="fs_image_abs_path" direction="in"/>
+      <arg type="b" name="success" direction="out" />
+    </method>
+    <method name="GetComponentVersion">
+      <arg type="s" name="name" direction="in" />
+      <arg type="s" name="version" direction="out" />
+    </method>
+    <method name="LoadComponent">
+      <arg type="s" name="name" direction="in" />
+      <arg type="s" name="mount_point" direction="out" />
+    </method>
+    <method name="UnloadComponent">
+      <arg type="s" name="name" direction="in" />
+      <arg type="b" name="success" direction="out" />
+    </method>
+  </interface>
+</node>
diff --git a/imageloader.cc b/imageloader.cc
new file mode 100644
index 0000000..c9a9916
--- /dev/null
+++ b/imageloader.cc
@@ -0,0 +1,216 @@
+// Copyright 2016 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 "imageloader.h"
+
+#include <fcntl.h>
+#include <linux/loop.h>
+#include <signal.h>
+#include <sys/ioctl.h>
+#include <sys/mount.h>
+
+#include <sstream>
+#include <string>
+#include <utility>
+
+#include <base/command_line.h>
+#include <base/files/file_path.h>
+#include <base/files/file_util.h>
+#include <base/files/scoped_file.h>
+#include <base/guid.h>
+#include <base/logging.h>
+#include <brillo/flag_helper.h>
+#include <dbus-c++/error.h>
+
+#include "imageloader_common.h"
+
+namespace imageloader {
+
+using base::CreateDirectory;
+using base::DeleteFile;
+using base::FilePath;
+using base::GenerateGUID;
+using base::PathExists;
+using base::ScopedFD;
+
+namespace {
+
+using imageloader::kBadResult;
+
+// Generate a good enough (unique) mount point.
+FilePath GenerateMountPoint(const char prefix[]) {
+  return FilePath(prefix + GenerateGUID());
+}
+
+}  // namespace {}
+
+// Mount component at location generated.
+std::string ImageLoader::LoadComponentUtil(const std::string& name) {
+  FilePath mount_point = GenerateMountPoint("/mnt/");
+  // Is this somehow taken up by any other name or mount?
+  for (auto it = mounts.begin(); it != mounts.end(); ++it) {
+    if ((it->second).first == mount_point) {
+      return kBadResult;
+    }
+  }
+  if (PathExists(mount_point)) {
+    LOG(INFO) << "Generated mount_point is already stat-able : "
+              << mount_point.value();
+    return kBadResult;
+  }
+  // The mount point is not yet taken, so go ahead.
+  ScopedFD loopctl_fd(open("/dev/loop-control", O_RDONLY | O_CLOEXEC));
+  if (!loopctl_fd.is_valid()) {
+    PLOG(ERROR) << "loopctl_fd";
+    return kBadResult;
+  }
+  int device_free_number = ioctl(loopctl_fd.get(), LOOP_CTL_GET_FREE);
+  if (device_free_number < 0) {
+    PLOG(ERROR) << "ioctl : LOOP_CTL_GET_FREE";
+    return kBadResult;
+  }
+  std::ostringstream device_path;
+  device_path << "/dev/loop" << device_free_number;
+  ScopedFD device_path_fd(open(device_path.str().c_str(),
+                          O_RDONLY | O_CLOEXEC));
+  if (!device_path_fd.is_valid()) {
+    PLOG(ERROR) << "device_path_fd";
+    return kBadResult;
+  }
+  ScopedFD fs_image_fd(open(reg[name].second.value().c_str(),
+                       O_RDONLY | O_CLOEXEC));
+  if (!fs_image_fd.is_valid()) {
+    PLOG(ERROR) << "fs_image_fd";
+    return kBadResult;
+  }
+  if (ioctl(device_path_fd.get(), LOOP_SET_FD, fs_image_fd.get()) < 0) {
+    PLOG(ERROR) << "ioctl: LOOP_SET_FD";
+    return kBadResult;
+  }
+  if (!CreateDirectory(mount_point)) {
+    PLOG(ERROR) << "CreateDirectory : " << mount_point.value();
+    ioctl(device_path_fd.get(), LOOP_CLR_FD, 0);
+    return kBadResult;
+  }
+  if (mount(device_path.str().c_str(), mount_point.value().c_str(), "squashfs",
+            MS_RDONLY | MS_NOSUID | MS_NODEV, "") < 0) {
+    PLOG(ERROR) << "mount";
+    ioctl(device_path_fd.get(), LOOP_CLR_FD, 0);
+    return kBadResult;
+  }
+  mounts[name] = std::make_pair(mount_point, FilePath(device_path.str()));
+  return mount_point.value();
+}
+
+// Unmount the given component.
+bool ImageLoader::UnloadComponentUtil(const std::string& name) {
+  std::string device_path = mounts[name].second.value();
+  if (umount(mounts[name].first.value().c_str()) < 0) {
+    PLOG(ERROR) << "umount";
+    return false;
+  }
+  const FilePath fp_mount_point(mounts[name].first);
+  if (!DeleteFile(fp_mount_point, false)) {
+    PLOG(ERROR) << "DeleteFile : " << fp_mount_point.value();
+    return false;
+  }
+  ScopedFD device_path_fd(open(device_path.c_str(), O_RDONLY | O_CLOEXEC));
+  if (!device_path_fd.is_valid()) {
+    PLOG(ERROR) << "device_path_fd";
+    return false;
+  }
+  if (ioctl(device_path_fd.get(), LOOP_CLR_FD, 0) < 0) {
+    PLOG(ERROR) << "ioctl: LOOP_CLR_FD";
+    return false;
+  }
+  mounts.erase(mounts.find(name));
+  return true;
+}
+
+// Following functions are required directly for the DBus functionality.
+
+ImageLoader::ImageLoader(DBus::Connection* conn)
+    : DBus::ObjectAdaptor(*conn, kImageLoaderPath) {}
+
+bool ImageLoader::RegisterComponent(const std::string& name,
+                                    const std::string& version,
+                                    const std::string& fs_image_abs_path,
+                                    ::DBus::Error& err) {
+  if (reg.find(name) == reg.end()) {
+    reg[name] = std::make_pair(version, FilePath(fs_image_abs_path));
+    LOG(INFO) << "Registered (" << name << ", " << version << ", "
+              << fs_image_abs_path << ")";
+    return true;
+  }
+  LOG(ERROR) <<
+      "Couldn't register, entry with specified name already exists : "
+      << name;
+  return false;
+}
+
+std::string ImageLoader::GetComponentVersion(const std::string& name,
+                                             ::DBus::Error& err) {
+  if (reg.find(name) != reg.end()) {
+    LOG(INFO) << "Found entry (" << name << ", " << reg[name].first << ", "
+              << reg[name].second.value() << ")";
+    return reg[name].first;
+  }
+  LOG(ERROR) << "Entry not found : " << name;
+  return kBadResult;
+}
+
+std::string ImageLoader::LoadComponent(const std::string& name,
+                                       ::DBus::Error& err) {
+  if (reg.find(name) != reg.end()) {
+    if (mounts.find(name) != mounts.end()) {
+      LOG(ERROR) << "Already mounted at " << mounts[name].first.value() << ".";
+      return kBadResult;
+    }
+    std::string mount_point = LoadComponentUtil(name);
+    if (mount_point == kBadResult) {
+      LOG(ERROR) << "Unable to mount : " << mount_point;
+      return kBadResult;
+    }
+    LOG(INFO) << "Mounted successfully at " << mount_point << ".";
+    return mount_point;
+  }
+  LOG(ERROR) << "Entry not found : " << name;
+  return kBadResult;
+}
+
+bool ImageLoader::UnloadComponent(const std::string& name,
+                                  ::DBus::Error& err) {
+  if (UnloadComponentUtil(name)) {
+    LOG(INFO) << "Unmount " << name << " successful.";
+    return true;
+  }
+  LOG(ERROR) << "Unmount " << name << " unsucessful.";
+  return false;
+}
+
+}  // namespace imageloader
+
+int main(int argc, char **argv) {
+  signal(SIGTERM, imageloader::OnQuit);
+  signal(SIGINT, imageloader::OnQuit);
+
+  DEFINE_bool(o, false, "run once");
+  brillo::FlagHelper::Init(argc, argv, "imageloader");
+
+  logging::LoggingSettings settings;
+  logging::InitLogging(settings);
+
+  DBus::BusDispatcher dispatcher;
+  DBus::default_dispatcher = &dispatcher;
+  DBus::Connection conn = DBus::Connection::SystemBus();
+  conn.request_name(imageloader::kImageLoaderName);
+  imageloader::ImageLoader helper(&conn);
+
+  if (FLAGS_o) {
+    dispatcher.dispatch_pending();
+  } else {
+    dispatcher.enter();
+  }
+  return 0;
+}
diff --git a/imageloader.gyp b/imageloader.gyp
new file mode 100644
index 0000000..f69f018
--- /dev/null
+++ b/imageloader.gyp
@@ -0,0 +1,100 @@
+# Copyright 2016 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.
+
+{
+  'target_defaults': {
+    'variables': {
+      'deps': [
+        'libchrome-<(libbase_ver)',
+        'dbus-c++-1',
+      ],
+      # imageloader uses try/catch to interact with dbus-c++
+      'enable_exceptions': 1,
+    },
+  },
+  'targets': [
+    {
+      'target_name': 'libimageloader_common',
+      'type': 'static_library',
+      'sources': [
+        'imageloader_common.cc',
+        'imageloader_common.h',
+      ],
+    },
+    {
+      'target_name': 'imageloader-glue',
+      'type': 'none',
+      'variables': {
+        'xml2cpp_type': 'adaptor',
+        'xml2cpp_in_dir': '.',
+        'xml2cpp_out_dir': 'include',
+      },
+      'sources': [
+        '<(xml2cpp_in_dir)/imageloader-glue.xml',
+      ],
+      'includes': ['../../platform2/common-mk/xml2cpp.gypi'],
+    },
+    {
+      'target_name': 'imageloadclient-glue',
+      'type': 'none',
+      'variables': {
+        'xml2cpp_type': 'proxy',
+        'xml2cpp_in_dir': '.',
+        'xml2cpp_out_dir': 'include',
+      },
+      'sources': [
+        '<(xml2cpp_in_dir)/imageloadclient-glue.xml',
+      ],
+      'includes': ['../../platform2/common-mk/xml2cpp.gypi'],
+    },
+    {
+      'target_name': 'imageloader',
+      'type': 'executable',
+      'variables': {
+        'deps': ['libbrillo-<(libbase_ver)'],
+      },
+      'dependencies': [
+        'imageloader-glue',
+        'libimageloader_common',
+      ],
+      'sources': [
+        'imageloader.cc',
+        'imageloader.h',
+        'imageloader-glue.h',
+      ],
+    },
+    {
+      'target_name': 'imageloadclient',
+      'type': 'executable',
+      'dependencies': [
+        'imageloadclient-glue',
+        'libimageloader_common',
+      ],
+      'sources': [
+        'imageloadclient.cc',
+        'imageloadclient.h',
+        'imageloadclient-glue.h',
+      ],
+      'libraries': ['-lpthread'],
+    },
+  ],
+  'conditions': [
+    ['USE_test == 1', {
+      'targets': [
+        {
+          'target_name': 'run_tests',
+          'type': 'executable',
+          'includes': ['../../platform2/common-mk/common_test.gypi'],
+          'dependencies': [
+            'libimageloader_common',
+          ],
+          'sources': [
+            'run_tests.cc',
+            'imageloader_common_unittest.cc'
+          ],
+        },
+      ],
+    }],
+  ],
+}
diff --git a/imageloader.h b/imageloader.h
new file mode 100644
index 0000000..49a7abc
--- /dev/null
+++ b/imageloader.h
@@ -0,0 +1,54 @@
+// Copyright 2016 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 IMAGELOADER_IMAGELOADER_H_
+#define IMAGELOADER_IMAGELOADER_H_
+
+#include <map>
+#include <string>
+#include <utility>
+
+#include <base/files/file_path.h>
+#include <dbus-c++/dbus.h>
+
+#include "imageloader-glue.h"
+
+namespace imageloader {
+
+// This is a utility that handles mounting and unmounting of
+// verified filesystem images that might include binaries intended
+// to be run as read only.
+class ImageLoader
+    : org::chromium::ImageLoaderInterface_adaptor,
+      public DBus::ObjectAdaptor {
+ public:
+  // Instantiate a D-Bus Helper Instance
+  explicit ImageLoader(DBus::Connection* conn);
+
+  // Register a component.
+  bool RegisterComponent(const std::string& name, const std::string& version,
+                         const std::string& fs_image_abs_path,
+                         ::DBus::Error& err);
+
+  // Get component version given component name.
+  std::string GetComponentVersion(const std::string& name, ::DBus::Error& err);
+
+  // Load the specified component.
+  std::string LoadComponent(const std::string& name, ::DBus::Error& err);
+  std::string LoadComponentUtil(const std::string& name);
+
+  // Unload the specified component.
+  bool UnloadComponent(const std::string& name, ::DBus::Error& err);
+  bool UnloadComponentUtil(const std::string& name);
+ private:
+  // "mounts" keeps track of what has been mounted.
+  // mounts = (name, (mount_point, device_path))
+  std::map<std::string, std::pair<base::FilePath, base::FilePath>> mounts;
+  // "reg" keeps track of registered components.
+  // reg = (name, (version, fs_image_abs_path))
+  std::map<std::string, std::pair<std::string, base::FilePath>> reg;
+};
+
+}  // namespace imageloader
+
+#endif  // IMAGELOADER_IMAGELOADER_H_
diff --git a/imageloader_common.cc b/imageloader_common.cc
new file mode 100644
index 0000000..af96772
--- /dev/null
+++ b/imageloader_common.cc
@@ -0,0 +1,16 @@
+// Copyright 2016 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 "imageloader_common.h"
+
+#include <dbus-c++/dbus.h>
+
+namespace imageloader {
+
+void OnQuit(int sig) {
+  if (DBus::default_dispatcher)
+    DBus::default_dispatcher->leave();
+}
+
+}  // namespace imageloader
diff --git a/imageloader_common.h b/imageloader_common.h
new file mode 100644
index 0000000..bd51e58
--- /dev/null
+++ b/imageloader_common.h
@@ -0,0 +1,18 @@
+// Copyright 2016 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 IMAGELOADER_IMAGELOADER_COMMON_H_
+#define IMAGELOADER_IMAGELOADER_COMMON_H_
+
+namespace imageloader {
+
+const char kBadResult[] = "";
+const char kImageLoaderName[] = "org.chromium.ImageLoader";
+const char kImageLoaderPath[] = "/org/chromium/ImageLoader";
+
+void OnQuit(int sig);
+
+}  // namespace imageloader
+
+#endif  // IMAGELOADER_IMAGELOADER_COMMON_H_
diff --git a/org.chromium.ImageLoader.conf b/org.chromium.ImageLoader.conf
new file mode 100644
index 0000000..2d1f65d
--- /dev/null
+++ b/org.chromium.ImageLoader.conf
@@ -0,0 +1,33 @@
+<!DOCTYPE busconfig PUBLIC
+ "-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN"
+ "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
+<!--
+  Copyright 2016 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.
+
+  This file will be installed at /etc/dbus-1/system.d on Chromium OS.
+-->
+<busconfig>
+  <policy user="root">
+    <allow own="org.chromium.ImageLoader" />
+    <allow receive_sender="org.chromium.ImageLoader" />
+    <allow send_destination="org.chromium.ImageLoader" />
+  </policy>
+  <policy user="chronos">
+    <allow receive_sender="org.chromium.ImageLoader" />
+    <allow send_destination="org.chromium.ImageLoader"
+      send_interface="org.chromium.ImageLoaderInterface"
+      send_member="RegisterComponent" />
+    <allow send_destination="org.chromium.ImageLoader"
+      send_interface="org.chromium.ImageLoaderInterface"
+      send_member="GetComponentVersion" />
+    <allow send_destination="org.chromium.ImageLoader"
+      send_interface="org.chromium.ImageLoaderInterface"
+      send_member="LoadComponent" />
+    <allow send_destination="org.chromium.ImageLoader"
+      send_interface="org.chromium.ImageLoaderInterface"
+      send_member="UnloadComponent" />
+  </policy>
+  <!-- deny others maybe? -->
+</busconfig>
diff --git a/org.chromium.ImageLoader.service b/org.chromium.ImageLoader.service
new file mode 100644
index 0000000..4806839
--- /dev/null
+++ b/org.chromium.ImageLoader.service
@@ -0,0 +1,7 @@
+# Copyright (c) 2016 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.i
+[D-BUS Service]
+Name=org.chromium.ImageLoader
+Exec=/usr/sbin/imageloader -o
+User=root
diff --git a/run_tests.cc b/run_tests.cc
new file mode 100644
index 0000000..451d8eb
--- /dev/null
+++ b/run_tests.cc
@@ -0,0 +1,10 @@
+// Copyright 2016 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 <gtest/gtest.h>
+
+int main(int argc, char **argv) {
+  testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}