diff --git a/buffet/manager.cc b/buffet/manager.cc
index abe687c..071b861 100644
--- a/buffet/manager.cc
+++ b/buffet/manager.cc
@@ -79,7 +79,7 @@
   device_info_->Load();
 }
 
-void Manager::HandleStartDevice(scoped_ptr<DBusMethodResponse> response) {
+void Manager::HandleStartDevice(scoped_ptr<DBusMethodResponse<>> response) {
   LOG(INFO) << "Received call to Manager.StartDevice()";
 
   chromeos::ErrorPtr error;
@@ -91,7 +91,7 @@
 }
 
 void Manager::HandleCheckDeviceRegistered(
-    scoped_ptr<DBusMethodResponse> response) {
+    scoped_ptr<DBusMethodResponse<std::string>> response) {
   LOG(INFO) << "Received call to Manager.CheckDeviceRegistered()";
   chromeos::ErrorPtr error;
   bool registered = device_info_->CheckRegistration(&error);
@@ -117,7 +117,7 @@
 }
 
 void Manager::HandleGetDeviceInfo(
-    scoped_ptr<DBusMethodResponse> response) {
+    scoped_ptr<DBusMethodResponse<std::string>> response) {
   LOG(INFO) << "Received call to Manager.GetDeviceInfo()";
 
   chromeos::ErrorPtr error;
@@ -133,7 +133,7 @@
 }
 
 void Manager::HandleRegisterDevice(
-    scoped_ptr<DBusMethodResponse> response,
+    scoped_ptr<DBusMethodResponse<std::string>> response,
     const std::map<std::string, std::string>& params) {
   LOG(INFO) << "Received call to Manager.RegisterDevice()";
 
@@ -146,7 +146,7 @@
 }
 
 void Manager::HandleUpdateState(
-    scoped_ptr<DBusMethodResponse> response,
+    scoped_ptr<DBusMethodResponse<>> response,
     const chromeos::VariantDictionary& property_set) {
   chromeos::ErrorPtr error;
   base::Time timestamp = base::Time::Now();
@@ -165,7 +165,7 @@
     response->Return();
 }
 
-void Manager::HandleAddCommand(scoped_ptr<DBusMethodResponse> response,
+void Manager::HandleAddCommand(scoped_ptr<DBusMethodResponse<>> response,
                                const std::string& json_command) {
   static int next_id = 0;
   std::string error_message;
diff --git a/buffet/manager.h b/buffet/manager.h
index b8ef91a..bcc0425 100644
--- a/buffet/manager.h
+++ b/buffet/manager.h
@@ -48,24 +48,27 @@
   // DBus methods:
   // Handles calls to org.chromium.Buffet.Manager.StartDevice().
   void HandleStartDevice(
-      scoped_ptr<chromeos::dbus_utils::DBusMethodResponse> response);
+      scoped_ptr<chromeos::dbus_utils::DBusMethodResponse<>> response);
   // Handles calls to org.chromium.Buffet.Manager.CheckDeviceRegistered().
   void HandleCheckDeviceRegistered(
-      scoped_ptr<chromeos::dbus_utils::DBusMethodResponse> response);
+      scoped_ptr<chromeos::dbus_utils::DBusMethodResponse<std::string>>
+          response);
   // Handles calls to org.chromium.Buffet.Manager.GetDeviceInfo().
   void HandleGetDeviceInfo(
-      scoped_ptr<chromeos::dbus_utils::DBusMethodResponse> response);
+      scoped_ptr<chromeos::dbus_utils::DBusMethodResponse<std::string>>
+          response);
   // Handles calls to org.chromium.Buffet.Manager.RegisterDevice().
   void HandleRegisterDevice(
-      scoped_ptr<chromeos::dbus_utils::DBusMethodResponse> response,
+      scoped_ptr<chromeos::dbus_utils::DBusMethodResponse<std::string>>
+          response,
       const std::map<std::string, std::string>& params);
   // Handles calls to org.chromium.Buffet.Manager.UpdateState().
   void HandleUpdateState(
-      scoped_ptr<chromeos::dbus_utils::DBusMethodResponse> response,
+      scoped_ptr<chromeos::dbus_utils::DBusMethodResponse<>> response,
       const chromeos::VariantDictionary& property_set);
   // Handles calls to org.chromium.Buffet.Manager.AddCommand().
   void HandleAddCommand(
-      scoped_ptr<chromeos::dbus_utils::DBusMethodResponse> response,
+      scoped_ptr<chromeos::dbus_utils::DBusMethodResponse<>> response,
       const std::string& json_command);
   // Handles calls to org.chromium.Buffet.Manager.Test()
   std::string HandleTestMethod(const std::string& message);
