diff --git a/buffet/dbus_bindings/com.android.Weave.Command.dbus-xml b/buffet/dbus_bindings/com.android.Weave.Command.dbus-xml
index 5fb2940..46913b3 100644
--- a/buffet/dbus_bindings/com.android.Weave.Command.dbus-xml
+++ b/buffet/dbus_bindings/com.android.Weave.Command.dbus-xml
@@ -6,15 +6,22 @@
       <arg name="progress" type="a{sv}" direction="in"/>
       <annotation name="org.chromium.DBus.Method.Kind" value="normal"/>
     </method>
-    <method name="SetResults">
+    <method name="Complete">
+      <tp:docstring>
+        Mark the command as successfully completed and specifies the command
+        results to be returned to the caller.
+      </tp:docstring>
       <arg name="results" type="a{sv}" direction="in"/>
       <annotation name="org.chromium.DBus.Method.Kind" value="normal"/>
     </method>
     <method name="Abort">
       <tp:docstring>
         Mark the command as aborted. This tells the cloud that the device did
-        not successfully complete executing the command.
+        not successfully complete executing the command. The error information
+        is provided in |code| and |message| parameters.
       </tp:docstring>
+      <arg name="code" type="s" direction="in"/>
+      <arg name="message" type="s" direction="in"/>
       <annotation name="org.chromium.DBus.Method.Kind" value="normal"/>
     </method>
     <method name="Cancel">
@@ -24,16 +31,9 @@
       </tp:docstring>
       <annotation name="org.chromium.DBus.Method.Kind" value="normal"/>
     </method>
-    <method name="Done">
-      <tp:docstring>
-        Mark the command as successfully completed.
-      </tp:docstring>
-      <annotation name="org.chromium.DBus.Method.Kind" value="normal"/>
-    </method>
     <property name="Name" type="s" access="read"/>
-    <property name="Category" type="s" access="read"/>
     <property name="Id" type="s" access="read"/>
-    <property name="Status" type="s" access="read"/>
+    <property name="State" type="s" access="read"/>
     <property name="Parameters" type="a{sv}" access="read"/>
     <property name="Progress" type="a{sv}" access="read"/>
     <property name="Results" type="a{sv}" access="read"/>
diff --git a/buffet/dbus_bindings/com.android.Weave.Manager.dbus-xml b/buffet/dbus_bindings/com.android.Weave.Manager.dbus-xml
index c93d893..a922491 100644
--- a/buffet/dbus_bindings/com.android.Weave.Manager.dbus-xml
+++ b/buffet/dbus_bindings/com.android.Weave.Manager.dbus-xml
@@ -26,11 +26,6 @@
       <arg name="id" type="s" direction="out"/>
       <annotation name="org.chromium.DBus.Method.Kind" value="async"/>
     </method>
-    <method name="GetCommand">
-      <arg name="id" type="s" direction="in"/>
-      <arg name="json_command" type="s" direction="out"/>
-      <annotation name="org.chromium.DBus.Method.Kind" value="async"/>
-    </method>
     <method name="TestMethod">
       <arg name="message" type="s" direction="in"/>
       <arg name="echoed_message" type="s" direction="out"/>
diff --git a/buffet/dbus_command_proxy.cc b/buffet/dbus_command_proxy.cc
index 71196e8..8c5c99f 100644
--- a/buffet/dbus_command_proxy.cc
+++ b/buffet/dbus_command_proxy.cc
@@ -52,7 +52,7 @@
   // Set the initial property values before registering the DBus object.
   dbus_adaptor_.SetName(command->GetName());
   dbus_adaptor_.SetId(command->GetID());
-  dbus_adaptor_.SetStatus(EnumToString(command->GetStatus()));
+  dbus_adaptor_.SetState(EnumToString(command->GetState()));
   dbus_adaptor_.SetProgress(
       DictionaryToDBusVariantDictionary(*command->GetProgress()));
   dbus_adaptor_.SetOrigin(EnumToString(command->GetOrigin()));
@@ -84,40 +84,49 @@
   }
   dbus_adaptor_.SetProgress(
       DictionaryToDBusVariantDictionary(*command->GetProgress()));
-  dbus_adaptor_.SetStatus(EnumToString(command->GetStatus()));
+  dbus_adaptor_.SetState(EnumToString(command->GetState()));
   return true;
 }
 
-bool DBusCommandProxy::SetResults(chromeos::ErrorPtr* error,
-                                  const chromeos::VariantDictionary& results) {
+bool DBusCommandProxy::Complete(chromeos::ErrorPtr* error,
+                                const chromeos::VariantDictionary& results) {
   auto command = command_.lock();
   if (!command)
     return ReportDestroyedError(error);
 
   LOG(INFO) << "Received call to Command<" << command->GetName()
-            << ">::SetResults()";
+            << ">::Complete()";
   auto dictionary = DictionaryFromDBusVariantDictionary(results, error);
   if (!dictionary)
     return false;
   weave::ErrorPtr weave_error;
-  if (!command->SetResults(*dictionary, &weave_error)) {
+  if (!command->Complete(*dictionary, &weave_error)) {
     ConvertError(*weave_error, error);
     return false;
   }
   dbus_adaptor_.SetProgress(
       DictionaryToDBusVariantDictionary(*command->GetProgress()));
+  dbus_adaptor_.SetState(EnumToString(command->GetState()));
   return true;
 }
 
-bool DBusCommandProxy::Abort(chromeos::ErrorPtr* error) {
+bool DBusCommandProxy::Abort(chromeos::ErrorPtr* error,
+                             const std::string& code,
+                             const std::string& message) {
   auto command = command_.lock();
   if (!command)
     return ReportDestroyedError(error);
 
   LOG(INFO) << "Received call to Command<" << command->GetName()
             << ">::Abort()";
-  command->Abort();
-  dbus_adaptor_.SetStatus(EnumToString(command->GetStatus()));
+  weave::ErrorPtr cmd_error;
+  weave::Error::AddTo(&cmd_error, FROM_HERE, "command_error", code, message);
+  weave::ErrorPtr weave_error;
+  if (!command->Abort(cmd_error.get(), &weave_error)) {
+    ConvertError(*weave_error, error);
+    return false;
+  }
+  dbus_adaptor_.SetState(EnumToString(command->GetState()));
   return true;
 }
 
@@ -128,22 +137,12 @@
 
   LOG(INFO) << "Received call to Command<" << command->GetName()
             << ">::Cancel()";
-  command->Cancel();
-  dbus_adaptor_.SetStatus(EnumToString(command->GetStatus()));
-  return true;
-}
-
-bool DBusCommandProxy::Done(chromeos::ErrorPtr* error) {
-  auto command = command_.lock();
-  if (!command)
-    return ReportDestroyedError(error);
-
-  LOG(INFO) << "Received call to Command<" << command->GetName()
-            << ">::Done()";
-  command->Done();
-  dbus_adaptor_.SetProgress(
-      DictionaryToDBusVariantDictionary(*command->GetProgress()));
-  dbus_adaptor_.SetStatus(EnumToString(command->GetStatus()));
+  weave::ErrorPtr weave_error;
+  if (!command->Cancel(&weave_error)) {
+    ConvertError(*weave_error, error);
+    return false;
+  }
+  dbus_adaptor_.SetState(EnumToString(command->GetState()));
   return true;
 }
 
diff --git a/buffet/dbus_command_proxy.h b/buffet/dbus_command_proxy.h
index bf2868d..68f2055 100644
--- a/buffet/dbus_command_proxy.h
+++ b/buffet/dbus_command_proxy.h
@@ -39,15 +39,15 @@
   // Handles calls to com.android.Weave.Command.SetProgress(progress).
   bool SetProgress(chromeos::ErrorPtr* error,
                    const chromeos::VariantDictionary& progress) override;
-  // Handles calls to com.android.Weave.Command.SetResults(results).
-  bool SetResults(chromeos::ErrorPtr* error,
-                  const chromeos::VariantDictionary& results) override;
+  // Handles calls to com.android.Weave.Command.Complete(results).
+  bool Complete(chromeos::ErrorPtr* error,
+                const chromeos::VariantDictionary& results) override;
   // Handles calls to com.android.Weave.Command.Abort().
-  bool Abort(chromeos::ErrorPtr* error) override;
+  bool Abort(chromeos::ErrorPtr* error,
+             const std::string& code,
+             const std::string& message) override;
   // Handles calls to com.android.Weave.Command.Cancel().
   bool Cancel(chromeos::ErrorPtr* error) override;
-  // Handles calls to com.android.Weave.Command.Done().
-  bool Done(chromeos::ErrorPtr* error) override;
 
   std::weak_ptr<weave::Command> command_;
   com::android::Weave::CommandAdaptor dbus_adaptor_{this};
diff --git a/buffet/dbus_command_proxy_unittest.cc b/buffet/dbus_command_proxy_unittest.cc
index 1e156e4..5988d98 100644
--- a/buffet/dbus_command_proxy_unittest.cc
+++ b/buffet/dbus_command_proxy_unittest.cc
@@ -43,6 +43,10 @@
   return IsEqualValue(*json_value, arg);
 }
 
+MATCHER_P2(ExpectError, code, message, "") {
+  return arg->GetCode() == code && arg->GetMessage() == message;
+}
+
 }  // namespace
 
 class DBusCommandProxyTest : public ::testing::Test {
@@ -62,10 +66,10 @@
     // Use WillRepeatedly because GetName is used for logging.
     EXPECT_CALL(*command_, GetName())
         .WillRepeatedly(ReturnRefOfCopy<std::string>("robot.jump"));
-    EXPECT_CALL(*command_, GetStatus())
-        .WillRepeatedly(Return(weave::CommandStatus::kQueued));
+    EXPECT_CALL(*command_, GetState())
+        .WillRepeatedly(Return(weave::Command::State::kQueued));
     EXPECT_CALL(*command_, GetOrigin())
-        .WillOnce(Return(weave::CommandOrigin::kLocal));
+        .WillOnce(Return(weave::Command::Origin::kLocal));
     EXPECT_CALL(*command_, MockGetParameters())
         .WillOnce(ReturnRefOfCopy<std::string>(R"({
           'height': 53,
@@ -111,10 +115,10 @@
     return GetCommandProxy();
   }
 
-  weave::CommandStatus GetCommandStatus() const {
-    weave::CommandStatus status;
-    EXPECT_TRUE(StringToEnum(GetCommandAdaptor()->GetStatus(), &status));
-    return status;
+  weave::Command::State GetCommandState() const {
+    weave::Command::State state;
+    EXPECT_TRUE(StringToEnum(GetCommandAdaptor()->GetState(), &state));
+    return state;
   }
 
   scoped_refptr<dbus::MockExportedObject> mock_exported_object_command_;
@@ -128,7 +132,7 @@
   VariantDictionary params = {
       {"height", int32_t{53}}, {"_jumpType", std::string{"_withKick"}},
   };
-  EXPECT_EQ(weave::CommandStatus::kQueued, GetCommandStatus());
+  EXPECT_EQ(weave::Command::State::kQueued, GetCommandState());
   EXPECT_EQ(params, GetCommandAdaptor()->GetParameters());
   EXPECT_EQ(VariantDictionary{}, GetCommandAdaptor()->GetProgress());
   EXPECT_EQ(VariantDictionary{}, GetCommandAdaptor()->GetResults());
@@ -143,32 +147,28 @@
       GetCommandInterface()->SetProgress(nullptr, {{"progress", int32_t{10}}}));
 }
 
-TEST_F(DBusCommandProxyTest, SetResults) {
+TEST_F(DBusCommandProxyTest, Complete) {
   EXPECT_CALL(
       *command_,
-      SetResults(
+      Complete(
           EqualToJson("{'foo': 42, 'bar': 'foobar', 'resultList': [1, 2, 3]}"),
           _))
       .WillOnce(Return(true));
-  EXPECT_TRUE(GetCommandInterface()->SetResults(
+  EXPECT_TRUE(GetCommandInterface()->Complete(
       nullptr, VariantDictionary{{"foo", int32_t{42}},
                                  {"bar", std::string{"foobar"}},
                                  {"resultList", std::vector<int>{1, 2, 3}}}));
 }
 
 TEST_F(DBusCommandProxyTest, Abort) {
-  EXPECT_CALL(*command_, Abort());
-  EXPECT_TRUE(GetCommandInterface()->Abort(nullptr));
+  EXPECT_CALL(*command_, Abort(ExpectError("foo", "bar"), _))
+      .WillOnce(Return(true));
+  EXPECT_TRUE(GetCommandInterface()->Abort(nullptr, "foo", "bar"));
 }
 
 TEST_F(DBusCommandProxyTest, Cancel) {
-  EXPECT_CALL(*command_, Cancel());
+  EXPECT_CALL(*command_, Cancel(_)).WillOnce(Return(true));
   EXPECT_TRUE(GetCommandInterface()->Cancel(nullptr));
 }
 
-TEST_F(DBusCommandProxyTest, Done) {
-  EXPECT_CALL(*command_, Done());
-  EXPECT_TRUE(GetCommandInterface()->Done(nullptr));
-}
-
 }  // namespace buffet
diff --git a/buffet/manager.cc b/buffet/manager.cc
index c3cbc87..3f3f4c1 100644
--- a/buffet/manager.cc
+++ b/buffet/manager.cc
@@ -41,6 +41,7 @@
 #include "buffet/webserv_client.h"
 
 using chromeos::dbus_utils::AsyncEventSequencer;
+using chromeos::dbus_utils::DBusMethodResponse;
 using chromeos::dbus_utils::ExportedObjectManager;
 
 namespace buffet {
@@ -121,6 +122,21 @@
   }
 }
 
+void RegisterDeviceSuccess(
+    const std::shared_ptr<DBusMethodResponse<std::string>>& response,
+    weave::Device* device) {
+  LOG(INFO) << "Device registered: " << device->GetSettings().cloud_id;
+  response->Return(device->GetSettings().cloud_id);
+}
+
+void RegisterDeviceError(
+    const std::shared_ptr<DBusMethodResponse<std::string>>& response,
+    const weave::Error* weave_error) {
+  chromeos::ErrorPtr error;
+  ConvertError(*weave_error, &error);
+  response->ReplyWithError(error.get());
+}
+
 }  // anonymous namespace
 
 class Manager::TaskRunner : public weave::provider::TaskRunner {
@@ -163,23 +179,32 @@
 #ifdef BUFFET_USE_WIFI_BOOTSTRAPPING
   if (!options_.disable_privet) {
     mdns_client_ = MdnsClient::CreateInstance(dbus_object_.GetBus());
-    web_serv_client_.reset(new WebServClient{dbus_object_.GetBus(), sequencer});
+    web_serv_client_.reset(new WebServClient{
+        dbus_object_.GetBus(), sequencer,
+        base::Bind(&Manager::CreateDevice, weak_ptr_factory_.GetWeakPtr())});
     bluetooth_client_ = BluetoothClient::CreateInstance();
     http_server = web_serv_client_.get();
 
     if (options_.enable_ping) {
-      http_server->AddRequestHandler(
-          "/privet/ping",
-          base::Bind(
-              [](const weave::provider::HttpServer::Request& request,
-                 const weave::provider::HttpServer::OnReplyCallback& callback) {
-                callback.Run(chromeos::http::status_code::Ok, "Hello, world!",
-                             chromeos::mime::text::kPlain);
-              }));
+      auto ping_handler = base::Bind(
+          [](std::unique_ptr<weave::provider::HttpServer::Request> request) {
+        request->SendReply(chromeos::http::status_code::Ok, "Hello, world!",
+                           chromeos::mime::text::kPlain);
+      });
+      http_server->AddHttpRequestHandler("/privet/ping", ping_handler);
+      http_server->AddHttpsRequestHandler("/privet/ping", ping_handler);
     }
   }
 #endif  // BUFFET_USE_WIFI_BOOTSTRAPPING
 
+  if (!http_server)
+    CreateDevice();
+}
+
+void Manager::CreateDevice() {
+  if (device_)
+    return;
+
   device_ = weave::Device::Create(config_.get(), task_runner_.get(),
                                   http_client_.get(), shill_client_.get(),
                                   mdns_client_.get(), web_serv_client_.get(),
@@ -223,15 +248,13 @@
                              const std::string& ticket_id) {
   LOG(INFO) << "Received call to Manager.RegisterDevice()";
 
-  weave::ErrorPtr error;
-  std::string device_id = device_->Register(ticket_id, &error);
-  if (!device_id.empty()) {
-    response->Return(device_id);
-    return;
-  }
-  chromeos::ErrorPtr chromeos_error;
-  ConvertError(*error, &chromeos_error);
-  response->ReplyWithError(chromeos_error.get());
+  std::shared_ptr<DBusMethodResponse<std::string>> shared_response =
+      std::move(response);
+
+  device_->Register(
+      ticket_id,
+      base::Bind(&RegisterDeviceSuccess, shared_response, device_.get()),
+      base::Bind(&RegisterDeviceError, shared_response));
 }
 
 void Manager::UpdateState(DBusMethodResponsePtr<> response,
@@ -283,20 +306,6 @@
   response->Return(id);
 }
 
-void Manager::GetCommand(DBusMethodResponsePtr<std::string> response,
-                         const std::string& id) {
-  const weave::Command* command = device_->FindCommand(id);
-  if (!command) {
-    response->ReplyWithError(FROM_HERE, kErrorDomain, "unknown_command",
-                             "Can't find command with id: " + id);
-    return;
-  }
-  std::string command_str;
-  base::JSONWriter::WriteWithOptions(
-      *command->ToJson(), base::JSONWriter::OPTIONS_PRETTY_PRINT, &command_str);
-  response->Return(command_str);
-}
-
 std::string Manager::TestMethod(const std::string& message) {
   LOG(INFO) << "Received call to test method: " << message;
   return message;
diff --git a/buffet/manager.h b/buffet/manager.h
index 9ae5b17..a90925d 100644
--- a/buffet/manager.h
+++ b/buffet/manager.h
@@ -72,6 +72,7 @@
 
  private:
   void RestartWeave(chromeos::dbus_utils::AsyncEventSequencer* sequencer);
+  void CreateDevice();
 
   // DBus methods:
   void RegisterDevice(DBusMethodResponsePtr<std::string> response,
@@ -81,8 +82,6 @@
   bool GetState(chromeos::ErrorPtr* error, std::string* state) override;
   void AddCommand(DBusMethodResponsePtr<std::string> response,
                   const std::string& json_command) override;
-  void GetCommand(DBusMethodResponsePtr<std::string> response,
-                  const std::string& id) override;
   std::string TestMethod(const std::string& message) override;
 
   void StartPrivet(const Options& options,
diff --git a/buffet/shill_client.cc b/buffet/shill_client.cc
index ed80af2..e0babfc 100644
--- a/buffet/shill_client.cc
+++ b/buffet/shill_client.cc
@@ -65,7 +65,7 @@
   if ((state.compare(shill::kStateReady) == 0) ||
       (state.compare(shill::kStatePortal) == 0) ||
       (state.compare(shill::kStateOnline) == 0)) {
-    return Network::State::kConnected;
+    return Network::State::kOnline;
   }
   if ((state.compare(shill::kStateAssociation) == 0) ||
       (state.compare(shill::kStateConfiguration) == 0)) {
@@ -74,7 +74,7 @@
   if ((state.compare(shill::kStateFailure) == 0) ||
       (state.compare(shill::kStateActivationFailure) == 0)) {
     // TODO(wiley) Get error information off the service object.
-    return Network::State::kFailure;
+    return Network::State::kError;
   }
   if ((state.compare(shill::kStateIdle) == 0) ||
       (state.compare(shill::kStateOffline) == 0) ||
@@ -451,7 +451,7 @@
 
 void ShillClient::OnStateChangeForConnectingService(const string& state) {
   switch (ShillServiceStateToNetworkState(state)) {
-    case Network::State::kConnected: {
+    case Network::State::kOnline: {
       auto callback = connect_success_callback_;
       CleanupConnectingService();
 
@@ -459,7 +459,7 @@
         callback.Run();
       break;
     }
-    case Network::State::kFailure: {
+    case Network::State::kError: {
       ConnectToServiceError(connecting_service_);
       break;
     }
@@ -538,7 +538,7 @@
       FROM_HERE,
       base::Bind(&ShillClient::NotifyConnectivityListeners,
                  weak_factory_.GetWeakPtr(),
-                 GetConnectionState() == Network::State::kConnected));
+                 GetConnectionState() == Network::State::kOnline));
 }
 
 void ShillClient::NotifyConnectivityListeners(bool am_online) {
diff --git a/buffet/webserv_client.cc b/buffet/webserv_client.cc
index e79a6a4..4b464c8 100644
--- a/buffet/webserv_client.cc
+++ b/buffet/webserv_client.cc
@@ -23,12 +23,13 @@
 
 class RequestImpl : public HttpServer::Request {
  public:
-  explicit RequestImpl(std::unique_ptr<libwebserv::Request> request)
-      : request_{std::move(request)} {}
+  explicit RequestImpl(std::unique_ptr<libwebserv::Request> request,
+                       std::unique_ptr<libwebserv::Response> response)
+      : request_{std::move(request)}, response_{std::move(response)} {}
   ~RequestImpl() override {}
 
   // HttpServer::Request implementation.
-  const std::string& GetPath() const override { return request_->GetPath(); }
+  std::string GetPath() const override { return request_->GetPath(); }
 
   std::string GetFirstHeader(const std::string& name) const override {
     return request_->GetFirstHeader(name);
@@ -36,27 +37,32 @@
 
   // TODO(avakulenko): Remove this method and rewrite all call sites in libweave
   // to use GetDataStream() instead.
-  const std::vector<uint8_t>& GetData() const override {
+  std::string GetData() override {
     if (request_data_)
       return *request_data_;
 
-    request_data_.reset(new std::vector<uint8_t>);
+    request_data_.reset(new std::string);
     auto stream = request_->GetDataStream();
     if (stream) {
       if (stream->CanGetSize())
         request_data_->reserve(stream->GetRemainingSize());
-      std::vector<uint8_t> buffer(16 * 1024);  // 16K seems to be good enough.
+      std::vector<char> buffer(16 * 1024);  // 16K seems to be good enough.
       size_t sz = 0;
       while (stream->ReadBlocking(buffer.data(), buffer.size(), &sz, nullptr) &&
              sz > 0) {
-        request_data_->insert(request_data_->end(),
-                              buffer.data(), buffer.data() + sz);
+        request_data_->append(buffer.data(), buffer.data() + sz);
       }
     }
     return *request_data_;
   }
 
-  std::unique_ptr<weave::Stream> GetDataStream() const override {
+  void SendReply(int status_code,
+                 const std::string& data,
+                 const std::string& mime_type) override {
+    response_->ReplyWithText(status_code, data, mime_type);
+  }
+
+  std::unique_ptr<weave::Stream> GetDataStream() const {
     auto stream = std::unique_ptr<weave::Stream>{
         new SocketStream{request_->GetDataStream()}};
     return stream;
@@ -64,48 +70,19 @@
 
  private:
   std::unique_ptr<libwebserv::Request> request_;
-  mutable std::unique_ptr<std::vector<uint8_t>> request_data_;
+  std::unique_ptr<libwebserv::Response> response_;
+  mutable std::unique_ptr<std::string> request_data_;
 
   DISALLOW_COPY_AND_ASSIGN(RequestImpl);
 };
 
 }  // namespace
 
-WebServClient::~WebServClient() {
-  web_server_->Disconnect();
-}
-
-void WebServClient::AddOnStateChangedCallback(
-    const OnStateChangedCallback& callback) {
-  on_state_changed_callbacks_.push_back(callback);
-  callback.Run(*this);
-}
-
-void WebServClient::AddRequestHandler(const std::string& path_prefix,
-                                      const OnRequestCallback& callback) {
-  web_server_->GetDefaultHttpHandler()->AddHandlerCallback(
-      path_prefix, "", base::Bind(&WebServClient::OnRequest,
-                                  weak_ptr_factory_.GetWeakPtr(), callback));
-  web_server_->GetDefaultHttpsHandler()->AddHandlerCallback(
-      path_prefix, "", base::Bind(&WebServClient::OnRequest,
-                                  weak_ptr_factory_.GetWeakPtr(), callback));
-}
-
-uint16_t WebServClient::GetHttpPort() const {
-  return http_port_;
-}
-
-uint16_t WebServClient::GetHttpsPort() const {
-  return https_port_;
-}
-
-const chromeos::Blob& WebServClient::GetHttpsCertificateFingerprint() const {
-  return certificate_;
-}
-
 WebServClient::WebServClient(
     const scoped_refptr<dbus::Bus>& bus,
-    chromeos::dbus_utils::AsyncEventSequencer* sequencer) {
+    chromeos::dbus_utils::AsyncEventSequencer* sequencer,
+    const base::Closure& server_available_callback)
+    : server_available_callback_{server_available_callback} {
   web_server_.reset(new libwebserv::Server);
   web_server_->OnProtocolHandlerConnected(
       base::Bind(&WebServClient::OnProtocolHandlerConnected,
@@ -120,20 +97,44 @@
                        base::Bind(&base::DoNothing));
 }
 
-void WebServClient::OnRequest(const OnRequestCallback& callback,
-                              std::unique_ptr<libwebserv::Request> request,
-                              std::unique_ptr<libwebserv::Response> response) {
-  callback.Run(
-      RequestImpl{std::move(request)},
-      base::Bind(&WebServClient::OnResponse, weak_ptr_factory_.GetWeakPtr(),
-                 base::Passed(&response)));
+WebServClient::~WebServClient() {
+  web_server_->Disconnect();
 }
 
-void WebServClient::OnResponse(std::unique_ptr<libwebserv::Response> response,
-                               int status_code,
-                               const std::string& data,
-                               const std::string& mime_type) {
-  response->ReplyWithText(status_code, data, mime_type);
+void WebServClient::AddHttpRequestHandler(
+    const std::string& path,
+    const RequestHandlerCallback& callback) {
+  web_server_->GetDefaultHttpHandler()->AddHandlerCallback(
+      path, "", base::Bind(&WebServClient::OnRequest,
+                           weak_ptr_factory_.GetWeakPtr(), callback));
+}
+
+void WebServClient::AddHttpsRequestHandler(
+    const std::string& path,
+    const RequestHandlerCallback& callback) {
+  web_server_->GetDefaultHttpsHandler()->AddHandlerCallback(
+      path, "", base::Bind(&WebServClient::OnRequest,
+                           weak_ptr_factory_.GetWeakPtr(), callback));
+}
+
+uint16_t WebServClient::GetHttpPort() const {
+  return http_port_;
+}
+
+uint16_t WebServClient::GetHttpsPort() const {
+  return https_port_;
+}
+
+chromeos::Blob WebServClient::GetHttpsCertificateFingerprint() const {
+  return certificate_;
+}
+
+void WebServClient::OnRequest(const RequestHandlerCallback& callback,
+                              std::unique_ptr<libwebserv::Request> request,
+                              std::unique_ptr<libwebserv::Response> response) {
+  std::unique_ptr<Request> weave_request{
+      new RequestImpl{std::move(request), std::move(response)}};
+  callback.Run(std::move(weave_request));
 }
 
 void WebServClient::OnProtocolHandlerConnected(
@@ -145,8 +146,8 @@
     https_port_ = *protocol_handler->GetPorts().begin();
     certificate_ = protocol_handler->GetCertificateFingerprint();
   }
-  for (const auto& cb : on_state_changed_callbacks_)
-    cb.Run(*this);
+  if (https_port_ && https_port_)
+    server_available_callback_.Run();
 }
 
 void WebServClient::OnProtocolHandlerDisconnected(
@@ -158,8 +159,6 @@
     https_port_ = 0;
     certificate_.clear();
   }
-  for (const auto& cb : on_state_changed_callbacks_)
-    cb.Run(*this);
 }
 
 }  // namespace buffet
diff --git a/buffet/webserv_client.h b/buffet/webserv_client.h
index 0b47527..cf3b397 100644
--- a/buffet/webserv_client.h
+++ b/buffet/webserv_client.h
@@ -35,20 +35,22 @@
 class WebServClient : public weave::provider::HttpServer {
  public:
   WebServClient(const scoped_refptr<dbus::Bus>& bus,
-                chromeos::dbus_utils::AsyncEventSequencer* sequencer);
+                chromeos::dbus_utils::AsyncEventSequencer* sequencer,
+                const base::Closure& server_available_callback);
   ~WebServClient() override;
 
   // HttpServer implementation.
-  void AddOnStateChangedCallback(
-      const OnStateChangedCallback& callback) override;
-  void AddRequestHandler(const std::string& path_prefix,
-                         const OnRequestCallback& callback) override;
+  void AddHttpRequestHandler(const std::string& path,
+                             const RequestHandlerCallback& callback) override;
+  void AddHttpsRequestHandler(const std::string& path,
+                              const RequestHandlerCallback& callback) override;
+
   uint16_t GetHttpPort() const override;
   uint16_t GetHttpsPort() const override;
-  const std::vector<uint8_t>& GetHttpsCertificateFingerprint() const override;
+  std::vector<uint8_t> GetHttpsCertificateFingerprint() const override;
 
  private:
-  void OnRequest(const OnRequestCallback& callback,
+  void OnRequest(const RequestHandlerCallback& callback,
                  std::unique_ptr<libwebserv::Request> request,
                  std::unique_ptr<libwebserv::Response> response);
 
@@ -67,9 +69,8 @@
   uint16_t https_port_{0};
   std::vector<uint8_t> certificate_;
 
-  std::vector<OnStateChangedCallback> on_state_changed_callbacks_;
-
   std::unique_ptr<libwebserv::Server> web_server_;
+  base::Closure server_available_callback_;
 
   base::WeakPtrFactory<WebServClient> weak_ptr_factory_{this};
   DISALLOW_COPY_AND_ASSIGN(WebServClient);