diff --git a/buffet/privet/cloud_delegate.cc b/buffet/privet/cloud_delegate.cc
index 5003c9d..653bf5d 100644
--- a/buffet/privet/cloud_delegate.cc
+++ b/buffet/privet/cloud_delegate.cc
@@ -509,8 +509,10 @@
 
 // static
 std::unique_ptr<CloudDelegate> CloudDelegate::CreateDefault(
-    const scoped_refptr<dbus::Bus>& bus,
     bool is_gcd_setup_enabled) {
+  dbus::Bus::Options options;
+  options.bus_type = dbus::Bus::SYSTEM;
+  scoped_refptr<dbus::Bus> bus{new dbus::Bus{options}};
   return std::unique_ptr<CloudDelegateImpl>{
       new CloudDelegateImpl{bus, is_gcd_setup_enabled}};
 }
diff --git a/buffet/privet/cloud_delegate.h b/buffet/privet/cloud_delegate.h
index 0d027f9..75d0a63 100644
--- a/buffet/privet/cloud_delegate.h
+++ b/buffet/privet/cloud_delegate.h
@@ -131,7 +131,6 @@
 
   // Create default instance.
   static std::unique_ptr<CloudDelegate> CreateDefault(
-      const scoped_refptr<dbus::Bus>& bus,
       bool is_gcd_setup_enabled);
 
  private:
diff --git a/buffet/privet/privet_manager.cc b/buffet/privet/privet_manager.cc
index 36aaa7e..1471404 100644
--- a/buffet/privet/privet_manager.cc
+++ b/buffet/privet/privet_manager.cc
@@ -7,7 +7,6 @@
 #include <memory>
 #include <set>
 #include <string>
-#include <sysexits.h>
 
 #include <base/bind.h>
 #include <base/command_line.h>
@@ -39,6 +38,7 @@
 #include "buffet/privet/security_manager.h"
 #include "buffet/privet/shill_client.h"
 #include "buffet/privet/wifi_bootstrap_manager.h"
+#include "buffet/dbus_constants.h"
 
 namespace privetd {
 
@@ -57,59 +57,60 @@
   return headers.empty() ? std::string() : headers.front();
 }
 
-const char kServiceName[] = "org.chromium.privetd";
-const char kRootPath[] = "/org/chromium/privetd";
-
 }  // namespace
 
-Manager::Manager(bool disable_security,
-                 bool enable_ping,
-                 const std::set<std::string>& device_whitelist,
-                 const base::FilePath& config_path,
-                 const base::FilePath& state_path)
-    : DBusServiceDaemon(kServiceName, kRootPath),
-      disable_security_(disable_security),
-      enable_ping_(enable_ping),
-      device_whitelist_(device_whitelist),
-      config_path_(config_path),
-      state_store_(new DaemonState(state_path)) {
+Manager::Manager() {
 }
 
-void Manager::RegisterDBusObjectsAsync(AsyncEventSequencer* sequencer) {
+Manager::~Manager() {
+}
+
+void Manager::Start(const Options& options,
+                    const scoped_refptr<dbus::Bus>& bus,
+                    AsyncEventSequencer* sequencer) {
+  disable_security_ = options.disable_security;
+
+  // TODO(vitalybuka): switch to BuffetConfig.
+  base::FilePath config_path{privetd::kDefaultConfigFilePath};
+  base::FilePath state_path{privetd::kDefaultStateFilePath};
+
+  state_store_.reset(new DaemonState(state_path));
   parser_.reset(new PrivetdConfigParser);
 
   chromeos::KeyValueStore config_store;
-  if (!config_store.Load(config_path_)) {
+  if (!config_store.Load(config_path)) {
     LOG(ERROR) << "Failed to read privetd config file from "
-               << config_path_.value();
+               << config_path.value();
   } else {
     CHECK(parser_->Parse(config_store)) << "Failed to read configuration file.";
   }
   state_store_->Init();
+
+  std::set<std::string> device_whitelist{options.device_whitelist};
   // This state store key doesn't exist naturally, but developers
   // sometime put it in their state store to cause the device to bring
   // up WiFi bootstrapping while being connected to an ethernet interface.
   std::string test_device_whitelist;
-  if (device_whitelist_.empty() &&
+  if (device_whitelist.empty() &&
       state_store_->GetString(kWiFiBootstrapInterfaces,
                               &test_device_whitelist)) {
     auto interfaces =
         chromeos::string_utils::Split(test_device_whitelist, ",", true, true);
-    device_whitelist_.insert(interfaces.begin(), interfaces.end());
+    device_whitelist.insert(interfaces.begin(), interfaces.end());
   }
   device_ = DeviceDelegate::CreateDefault();
-  cloud_ = CloudDelegate::CreateDefault(
-      bus_, parser_->gcd_bootstrap_mode() != GcdBootstrapMode::kDisabled);
+  cloud_ = CloudDelegate::CreateDefault(parser_->gcd_bootstrap_mode() !=
+                                        GcdBootstrapMode::kDisabled);
   cloud_observer_.Add(cloud_.get());
   security_.reset(new SecurityManager(parser_->pairing_modes(),
                                       parser_->embedded_code_path(),
                                       disable_security_));
   shill_client_.reset(new ShillClient(
-      bus_, device_whitelist_.empty() ? parser_->automatic_wifi_interfaces()
-                                      : device_whitelist_));
+      bus, device_whitelist.empty() ? parser_->automatic_wifi_interfaces()
+                                    : device_whitelist));
   shill_client_->RegisterConnectivityListener(
       base::Bind(&Manager::OnConnectivityChanged, base::Unretained(this)));
-  ap_manager_client_.reset(new ApManagerClient(bus_));
+  ap_manager_client_.reset(new ApManagerClient(bus));
 
   if (parser_->wifi_bootstrap_mode() != WiFiBootstrapMode::kDisabled) {
     VLOG(1) << "Enabling WiFi bootstrapping.";
@@ -121,19 +122,20 @@
     wifi_bootstrap_manager_->Init();
   }
 
-  peerd_client_.reset(new PeerdClient(bus_, device_.get(), cloud_.get(),
+  peerd_client_.reset(new PeerdClient(bus, device_.get(), cloud_.get(),
                                       wifi_bootstrap_manager_.get()));
 
   privet_handler_.reset(
       new PrivetHandler(cloud_.get(), device_.get(), security_.get(),
                         wifi_bootstrap_manager_.get(), peerd_client_.get()));
+
   web_server_.reset(new libwebserv::Server);
   web_server_->OnProtocolHandlerConnected(base::Bind(
       &Manager::OnProtocolHandlerConnected, weak_ptr_factory_.GetWeakPtr()));
   web_server_->OnProtocolHandlerDisconnected(base::Bind(
       &Manager::OnProtocolHandlerDisconnected, weak_ptr_factory_.GetWeakPtr()));
 
-  web_server_->Connect(bus_, kServiceName,
+  web_server_->Connect(bus, buffet::dbus_constants::kServiceName,
                        sequencer->GetHandler("Server::Connect failed.", true),
                        base::Bind(&base::DoNothing),
                        base::Bind(&base::DoNothing));
@@ -144,7 +146,7 @@
   web_server_->GetDefaultHttpsHandler()->AddHandlerCallback(
       "/privet/", "",
       base::Bind(&Manager::PrivetRequestHandler, base::Unretained(this)));
-  if (enable_ping_) {
+  if (options.enable_ping) {
     web_server_->GetDefaultHttpHandler()->AddHandlerCallback(
         "/privet/ping", chromeos::http::request_type::kGet,
         base::Bind(&Manager::HelloWorldHandler, base::Unretained(this)));
@@ -154,14 +156,13 @@
   }
 }
 
-void Manager::OnShutdown(int* return_code) {
+void Manager::OnShutdown() {
   web_server_->Disconnect();
-  DBusDaemon::OnShutdown(return_code);
 }
 
 void Manager::OnDeviceInfoChanged() {
   OnChanged();
-}
+};
 
 void Manager::PrivetRequestHandler(std::unique_ptr<Request> request,
                                    std::unique_ptr<Response> response) {
@@ -240,38 +241,3 @@
 }
 
 }  // namespace privetd
-
-int old_main(int argc, char* argv[]) {
-  DEFINE_bool(disable_security, false, "disable Privet security for tests");
-  DEFINE_bool(enable_ping, false, "enable test HTTP handler at /privet/ping");
-  DEFINE_bool(log_to_stderr, false, "log trace messages to stderr as well");
-  DEFINE_string(config_path, privetd::kDefaultConfigFilePath,
-                "Path to file containing config information.");
-  DEFINE_string(state_path, privetd::kDefaultStateFilePath,
-                "Path to file containing state information.");
-  DEFINE_string(device_whitelist, "",
-                "Comma separated list of network interfaces to monitor for "
-                "connectivity (an empty list enables all interfaces).");
-
-  chromeos::FlagHelper::Init(argc, argv, "Privet protocol handler daemon");
-
-  int flags = chromeos::kLogToSyslog;
-  if (FLAGS_log_to_stderr)
-    flags |= chromeos::kLogToStderr;
-  chromeos::InitLog(flags | chromeos::kLogHeader);
-
-  if (FLAGS_config_path.empty())
-    FLAGS_config_path = privetd::kDefaultConfigFilePath;
-
-  if (FLAGS_state_path.empty())
-    FLAGS_state_path = privetd::kDefaultStateFilePath;
-
-  auto device_whitelist =
-      chromeos::string_utils::Split(FLAGS_device_whitelist, ",", true, true);
-
-  privetd::Manager daemon(
-      FLAGS_disable_security, FLAGS_enable_ping,
-      std::set<std::string>(device_whitelist.begin(), device_whitelist.end()),
-      base::FilePath(FLAGS_config_path), base::FilePath(FLAGS_state_path));
-  return daemon.Run();
-}
diff --git a/buffet/privet/privet_manager.h b/buffet/privet/privet_manager.h
index 23e19d4..8130b9d 100644
--- a/buffet/privet/privet_manager.h
+++ b/buffet/privet/privet_manager.h
@@ -12,10 +12,14 @@
 
 #include <base/memory/weak_ptr.h>
 #include <base/scoped_observer.h>
-#include <chromeos/daemons/dbus_daemon.h>
 
 #include "buffet/privet/cloud_delegate.h"
 
+namespace buffet {
+class CommandManager;
+class DeviceRegistrationInfo;
+}
+
 namespace chromeos {
 namespace dbus_utils {
 class AsyncEventSequencer;
@@ -31,34 +35,43 @@
 
 namespace privetd {
 
-class PrivetdConfigParser;
-class DaemonState;
-class CloudDelegate;
-class DeviceDelegate;
-class SecurityManager;
-class ShillClient;
 class ApManagerClient;
-class WifiBootstrapManager;
+class CloudDelegate;
+class DaemonState;
+class DeviceDelegate;
 class PeerdClient;
 class PrivetHandler;
+class PrivetdConfigParser;
+class SecurityManager;
+class ShillClient;
+class WifiBootstrapManager;
 
-class Manager : public chromeos::DBusServiceDaemon,
-                public CloudDelegate::Observer {
+class Manager : public CloudDelegate::Observer {
  public:
-  Manager(bool disable_security,
-          bool enable_ping,
-          const std::set<std::string>& device_whitelist,
-          const base::FilePath& config_path,
-          const base::FilePath& state_path);
-  ~Manager() override;
+  struct Options {
+    bool disable_privet{false};
+    bool disable_security{false};
+    bool enable_ping{false};
+    std::set<std::string> device_whitelist;
+  };
 
-  void RegisterDBusObjectsAsync(
-      chromeos::dbus_utils::AsyncEventSequencer* sequencer) override;
+  Manager();
+  ~Manager();
 
-  void OnShutdown(int* return_code) override;
+  void Start(const Options& options,
+             const scoped_refptr<dbus::Bus>& bus,
+             chromeos::dbus_utils::AsyncEventSequencer* sequencer);
+
+  void OnShutdown();
 
   void OnDeviceInfoChanged() override;
 
+  privetd::WifiBootstrapManager* GetWifiBootstrapManager() {
+    return wifi_bootstrap_manager_.get();
+  }
+
+  privetd::SecurityManager* GetSecurityManager() { return security_.get(); }
+
  private:
   void PrivetRequestHandler(std::unique_ptr<libwebserv::Request> request,
                             std::unique_ptr<libwebserv::Response> response);
@@ -80,11 +93,8 @@
   void OnProtocolHandlerDisconnected(
       libwebserv::ProtocolHandler* protocol_handler);
 
-  bool disable_security_;
-  bool enable_ping_;
+  bool disable_security_{false};
   std::unique_ptr<PrivetdConfigParser> parser_;
-  std::set<std::string> device_whitelist_;
-  base::FilePath config_path_;
   std::unique_ptr<DaemonState> state_store_;
   std::unique_ptr<CloudDelegate> cloud_;
   std::unique_ptr<DeviceDelegate> device_;