diff --git a/buffet/buffet.gyp b/buffet/buffet.gyp
index 2288162..c4c5a1b 100644
--- a/buffet/buffet.gyp
+++ b/buffet/buffet.gyp
@@ -76,6 +76,7 @@
         'async_event_sequencer_unittest.cc',
         'buffet_testrunner.cc',
         'data_encoding_unittest.cc',
+        'device_registration_info_unittest.cc',
         'exported_property_set_unittest.cc',
         'http_connection_fake.cc',
         'http_transport_fake.cc',
diff --git a/buffet/device_registration_info.cc b/buffet/device_registration_info.cc
index de89aff..c9aea9f 100644
--- a/buffet/device_registration_info.cc
+++ b/buffet/device_registration_info.cc
@@ -4,13 +4,15 @@
 
 #include "buffet/device_registration_info.h"
 
+#include <base/file_util.h>
+#include <base/files/important_file_writer.h>
 #include <base/json/json_reader.h>
 #include <base/json/json_writer.h>
 #include <base/values.h>
-#include <base/file_util.h>
 #include <memory>
 
 #include "buffet/data_encoding.h"
+#include "buffet/device_registration_storage_keys.h"
 #include "buffet/http_transport_curl.h"
 #include "buffet/http_utils.h"
 #include "buffet/mime_utils.h"
@@ -20,7 +22,9 @@
 using namespace chromeos;
 using namespace chromeos::data_encoding;
 
-namespace {
+namespace buffet {
+namespace storage_keys {
+
 // Persistent keys
 const char kClientId[]      = "client_id";
 const char kClientSecret[]  = "client_secret";
@@ -35,6 +39,11 @@
 const char kSystemName[]    = "system_name";
 const char kDisplayName[]   = "display_name";
 
+}  // namespace storage_keys
+}  // namespace buffet
+
+namespace {
+
 const base::FilePath::CharType kDeviceInfoFilePath[] =
     FILE_PATH_LITERAL("/var/lib/buffet/device_reg_info");
 
@@ -85,21 +94,52 @@
   return url::AppendQueryParams(result, params);
 }
 
+class FileStorage : public buffet::DeviceRegistrationInfo::StorageInterface {
+ public:
+  virtual std::unique_ptr<base::Value> Load() override {
+    // TODO(avakulenko): Figure out security implications of storing
+    // this data unencrypted.
+    std::string json;
+    if (!base::ReadFileToString(GetFilePath(), &json))
+      return std::unique_ptr<base::Value>();
 
-} // anonymous namespace
+    return std::unique_ptr<base::Value>(base::JSONReader::Read(json));
+  }
+
+  virtual bool Save(const base::Value* config) {
+    // TODO(avakulenko): Figure out security implications of storing
+    // this data unencrypted.
+    std::string json;
+    base::JSONWriter::WriteWithOptions(config,
+                                       base::JSONWriter::OPTIONS_PRETTY_PRINT,
+                                       &json);
+    return base::ImportantFileWriter::WriteFileAtomically(GetFilePath(), json);
+  }
+
+ private:
+  base::FilePath GetFilePath() const{
+    return base::FilePath(kDeviceInfoFilePath);
+  }
+};
+
+}  // anonymous namespace
 
 namespace buffet {
+
 DeviceRegistrationInfo::DeviceRegistrationInfo()
-    : transport_(new http::curl::Transport()){
+    : transport_(new http::curl::Transport()),
+      storage_(new FileStorage()) {
 }
 
 DeviceRegistrationInfo::DeviceRegistrationInfo(
-    std::shared_ptr<http::Transport> transport) : transport_(transport) {
+    std::shared_ptr<http::Transport> transport,
+    std::shared_ptr<StorageInterface> storage) : transport_(transport),
+                                                 storage_(storage) {
 }
 
 std::pair<std::string, std::string>
     DeviceRegistrationInfo::GetAuthorizationHeader() const {
-  return BuildAuthHeader(/*"Bearer"*/"OAuth", access_token_);
+  return BuildAuthHeader("Bearer", access_token_);
 }
 
 std::string DeviceRegistrationInfo::GetServiceURL(
@@ -123,13 +163,7 @@
 }
 
 bool DeviceRegistrationInfo::Load() {
-  // TODO(avakulenko): Figure out security implications of storing
-  // this data unencrypted.
-  std::string json;
-  if (!base::ReadFileToString(base::FilePath(kDeviceInfoFilePath), &json))
-    return false;
-
-  auto value = std::unique_ptr<base::Value>(base::JSONReader::Read(json));
+  auto value = storage_->Load();
   const base::DictionaryValue* dict = nullptr;
   if (!value || !value->GetAsDictionary(&dict))
     return false;
@@ -137,28 +171,28 @@
   // Get the values into temp variables first to make sure we can get
   // all the data correctly before changing the state of this object.
   std::string client_id;
-  if (!dict->GetString(kClientId, &client_id))
+  if (!dict->GetString(storage_keys::kClientId, &client_id))
     return false;
   std::string client_secret;
-  if (!dict->GetString(kClientSecret, &client_secret))
+  if (!dict->GetString(storage_keys::kClientSecret, &client_secret))
     return false;
   std::string api_key;
-  if (!dict->GetString(kApiKey, &api_key))
+  if (!dict->GetString(storage_keys::kApiKey, &api_key))
     return false;
   std::string refresh_token;
-  if (!dict->GetString(kRefreshToken, &refresh_token))
+  if (!dict->GetString(storage_keys::kRefreshToken, &refresh_token))
     return false;
   std::string device_id;
-  if (!dict->GetString(kDeviceId, &device_id))
+  if (!dict->GetString(storage_keys::kDeviceId, &device_id))
     return false;
   std::string oauth_url;
-  if (!dict->GetString(kOAuthURL, &oauth_url))
+  if (!dict->GetString(storage_keys::kOAuthURL, &oauth_url))
     return false;
   std::string service_url;
-  if (!dict->GetString(kServiceURL, &service_url))
+  if (!dict->GetString(storage_keys::kServiceURL, &service_url))
     return false;
   std::string device_robot_account;
-  if (!dict->GetString(kRobotAccount, &device_robot_account))
+  if (!dict->GetString(storage_keys::kRobotAccount, &device_robot_account))
     return false;
 
   client_id_            = client_id;
@@ -173,26 +207,16 @@
 }
 
 bool DeviceRegistrationInfo::Save() const {
-  // TODO(avakulenko): Figure out security implications of storing
-  // this data unencrypted.
   base::DictionaryValue dict;
-  dict.SetString(kClientId,     client_id_);
-  dict.SetString(kClientSecret, client_secret_);
-  dict.SetString(kApiKey,       api_key_);
-  dict.SetString(kRefreshToken, refresh_token_);
-  dict.SetString(kDeviceId,     device_id_);
-  dict.SetString(kOAuthURL,     oauth_url_);
-  dict.SetString(kServiceURL,   service_url_);
-  dict.SetString(kRobotAccount, device_robot_account_);
-
-  std::string json;
-  base::JSONWriter::WriteWithOptions(&dict,
-                                     base::JSONWriter::OPTIONS_PRETTY_PRINT,
-                                     &json);
-  int count = file_util::WriteFile(base::FilePath(kDeviceInfoFilePath),
-                                   json.data(), static_cast<int>(json.size()));
-
-  return (count > 0);
+  dict.SetString(storage_keys::kClientId,     client_id_);
+  dict.SetString(storage_keys::kClientSecret, client_secret_);
+  dict.SetString(storage_keys::kApiKey,       api_key_);
+  dict.SetString(storage_keys::kRefreshToken, refresh_token_);
+  dict.SetString(storage_keys::kDeviceId,     device_id_);
+  dict.SetString(storage_keys::kOAuthURL,     oauth_url_);
+  dict.SetString(storage_keys::kServiceURL,   service_url_);
+  dict.SetString(storage_keys::kRobotAccount, device_robot_account_);
+  return storage_->Save(&dict);
 }
 
 bool DeviceRegistrationInfo::CheckRegistration() {
@@ -209,7 +233,7 @@
 }
 
 bool DeviceRegistrationInfo::ValidateAndRefreshAccessToken() {
-  LOG(INFO) << " Checking access token expiration.";
+  LOG(INFO) << "Checking access token expiration.";
   if (!access_token_.empty() &&
       !access_token_expiration_.is_null() &&
       access_token_expiration_ > base::Time::Now()) {
@@ -284,29 +308,29 @@
 std::string DeviceRegistrationInfo::StartRegistration(
     const std::map<std::string, std::shared_ptr<base::Value>>& params,
   std::string* error_msg) {
-  GetParamValue(params, kClientId, &client_id_);
-  GetParamValue(params, kClientSecret, &client_secret_);
-  GetParamValue(params, kApiKey, &api_key_);
-  GetParamValue(params, kDeviceId, &device_id_);
-  GetParamValue(params, kDeviceKind, &device_kind_);
-  GetParamValue(params, kSystemName, &system_name_);
-  GetParamValue(params, kDisplayName, &display_name_);
-  GetParamValue(params, kOAuthURL, &oauth_url_);
-  GetParamValue(params, kServiceURL, &service_url_);
+  GetParamValue(params, storage_keys::kClientId, &client_id_);
+  GetParamValue(params, storage_keys::kClientSecret, &client_secret_);
+  GetParamValue(params, storage_keys::kApiKey, &api_key_);
+  GetParamValue(params, storage_keys::kDeviceId, &device_id_);
+  GetParamValue(params, storage_keys::kDeviceKind, &device_kind_);
+  GetParamValue(params, storage_keys::kSystemName, &system_name_);
+  GetParamValue(params, storage_keys::kDisplayName, &display_name_);
+  GetParamValue(params, storage_keys::kOAuthURL, &oauth_url_);
+  GetParamValue(params, storage_keys::kServiceURL, &service_url_);
 
-  if (!CheckParam(kClientId, client_id_, error_msg))
+  if (!CheckParam(storage_keys::kClientId, client_id_, error_msg))
     return std::string();
-  if (!CheckParam(kClientSecret, client_secret_, error_msg))
+  if (!CheckParam(storage_keys::kClientSecret, client_secret_, error_msg))
     return std::string();
-  if (!CheckParam(kApiKey, api_key_, error_msg))
+  if (!CheckParam(storage_keys::kApiKey, api_key_, error_msg))
     return std::string();
-  if (!CheckParam(kDeviceKind, device_kind_, error_msg))
+  if (!CheckParam(storage_keys::kDeviceKind, device_kind_, error_msg))
     return std::string();
-  if (!CheckParam(kSystemName, system_name_, error_msg))
+  if (!CheckParam(storage_keys::kSystemName, system_name_, error_msg))
     return std::string();
-  if (!CheckParam(kOAuthURL, oauth_url_, error_msg))
+  if (!CheckParam(storage_keys::kOAuthURL, oauth_url_, error_msg))
     return std::string();
-  if (!CheckParam(kServiceURL, service_url_, error_msg))
+  if (!CheckParam(storage_keys::kServiceURL, service_url_, error_msg))
     return std::string();
 
   std::vector<std::pair<std::string, std::vector<std::string>>> commands = {
@@ -416,18 +440,9 @@
 
   std::string auth_code;
   url += "/finalize?key=" + api_key_;
-  do {
-    LOG(INFO) << "Sending request to: " << url;
-    response = http::PostBinary(url, nullptr, 0, transport_);
-    if (response) {
-      if (response->GetStatusCode() == http::status_code::BadRequest)
-        sleep(1);
-    }
-  }
-  while (response &&
-         response->GetStatusCode() == http::status_code::BadRequest);
-  if (response &&
-      response->GetStatusCode() == http::status_code::Ok) {
+  LOG(INFO) << "Sending request to: " << url;
+  response = http::PostBinary(url, nullptr, 0, transport_);
+  if (response && response->IsSuccessful()) {
     auto json_resp = http::ParseJsonResponse(response.get(), nullptr, nullptr);
     if (json_resp &&
         json_resp->GetString("robotAccountEmail", &device_robot_account_) &&
@@ -463,8 +478,9 @@
 
       Save();
     }
+    return true;
   }
-  return true;
+  return false;
 }
 
 }  // namespace buffet
diff --git a/buffet/device_registration_info.h b/buffet/device_registration_info.h
index 6eea8eb..c60cf69 100644
--- a/buffet/device_registration_info.h
+++ b/buffet/device_registration_info.h
@@ -22,17 +22,33 @@
 namespace buffet {
 
 // The DeviceRegistrationInfo class represents device registration information.
-  class DeviceRegistrationInfo {
+class DeviceRegistrationInfo {
  public:
-   // Default-constructed uses CURL HTTP transport.
-   DeviceRegistrationInfo();
-   // This constructor allows to pass in a custom HTTP transport
-   // (mainly for testing).
-   DeviceRegistrationInfo(std::shared_ptr<chromeos::http::Transport> transport);
+  // The device registration configuration storage interface.
+  struct StorageInterface {
+    virtual ~StorageInterface() = default;
+    // Load the device registration configuration from storage.
+    // If it fails (e.g. the storage container [file?] doesn't exist), then
+    // it returns empty unique_ptr (aka nullptr).
+    virtual std::unique_ptr<base::Value> Load() = 0;
+    // Save the device registration configuration to storage.
+    // If saved successfully, returns true. Could fail when writing to
+    // physical storage like file system for various reasons (out of disk space,
+    // access permissions, etc).
+    virtual bool Save(const base::Value* config) = 0;
+  };
+  // This is a helper class for unit testing.
+  class TestHelper;
+  // Default-constructed uses CURL HTTP transport.
+  DeviceRegistrationInfo();
+  // This constructor allows to pass in a custom HTTP transport
+  // (mainly for testing).
+  DeviceRegistrationInfo(std::shared_ptr<chromeos::http::Transport> transport,
+                         std::shared_ptr<StorageInterface> storage);
 
   // Returns the authorization HTTP header that can be used to talk
   // to GCD server for authenticated device communication.
-  // Make sure CheckRegistration() is called before this call.
+  // Make sure ValidateAndRefreshAccessToken() is called before this call.
   std::pair<std::string, std::string> GetAuthorizationHeader() const;
 
   // Returns the GCD service request URL. If |subpath| is specified, it is
@@ -122,7 +138,10 @@
 
   // HTTP transport used for communications.
   std::shared_ptr<chromeos::http::Transport> transport_;
+  // Serialization interface to save and load device registration info.
+  std::shared_ptr<StorageInterface> storage_;
 
+  friend class TestHelper;
   DISALLOW_COPY_AND_ASSIGN(DeviceRegistrationInfo);
 };
 
diff --git a/buffet/device_registration_info_unittest.cc b/buffet/device_registration_info_unittest.cc
new file mode 100644
index 0000000..2357904
--- /dev/null
+++ b/buffet/device_registration_info_unittest.cc
@@ -0,0 +1,409 @@
+// Copyright 2014 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 <base/json/json_reader.h>
+#include <base/values.h>
+#include <gtest/gtest.h>
+
+#include "buffet/bind_lambda.h"
+#include "buffet/device_registration_info.h"
+#include "buffet/device_registration_storage_keys.h"
+#include "buffet/http_request.h"
+#include "buffet/http_transport_fake.h"
+#include "buffet/mime_utils.h"
+
+using namespace buffet;
+using namespace chromeos;
+using namespace chromeos::http;
+
+namespace {
+// StorageInterface for testing. Just stores the values in memory.
+class MemStorage : public DeviceRegistrationInfo::StorageInterface {
+ public:
+  virtual std::unique_ptr<base::Value> Load() override {
+    return std::unique_ptr<base::Value>(cache_->DeepCopy());
+  }
+
+  virtual bool Save(const base::Value* config) {
+    cache_.reset(config->DeepCopy());
+    ++save_count_;
+    return true;
+  }
+
+  int save_count_ = 0;
+
+private:
+  std::unique_ptr<base::Value> cache_;
+};
+
+namespace test_data {
+
+const char kServiceURL[]           = "http://gcd.server.com/";
+const char kOAuthURL[]             = "http://oauth.server.com/";
+const char kApiKey[]               = "GOadRdTf9FERf0k4w6EFOof56fUJ3kFDdFL3d7f";
+const char kClientId[]             = "123543821385-sfjkjshdkjhfk234sdfsdfkskd"
+                                     "fkjh7f.apps.googleusercontent.com";
+const char kClientSecret[]         = "5sdGdGlfolGlrFKfdFlgP6FG";
+const char kDeviceId[]             = "4a7ea2d1-b331-1e1f-b206-e863c7635196";
+const char kClaimTicketId[]        = "RTcUE";
+const char kAccessToken[]          = "ya29.1.AADtN_V-dLUM-sVZ0qVjG9Dxm5NgdS9J"
+                                     "Mx_JLUqhC9bED_YFjzHZtYt65ZzXCS35NMAeaVZ"
+                                     "Dei530-w0yE2urpQ";
+const char kRefreshToken[]         = "1/zQmxR6PKNvhcxf9SjXUrCjcmCrcqRKXctc6cp"
+                                     "1nI-GQ";
+const char kRobotAccountAuthCode[] = "4/Mf_ujEhPejVhOq-OxW9F5cSOnWzx."
+                                     "YgciVjTYGscRshQV0ieZDAqiTIjMigI";
+const char kRobotAccountEmail[]    = "6ed0b3f54f9bd619b942f4ad2441c252@"
+                                     "clouddevices.gserviceaccount.com";
+const char kUserAccountAuthCode[]  = "2/sd_GD1TGFKpJOLJ34-0g5fK0fflp.GlT"
+                                     "I0F5g7hNtFgj5HFGOf8FlGK9eflO";
+const char kUserAccessToken[]      = "sd56.4.FGDjG_F-gFGF-dFG6gGOG9Dxm5NgdS9"
+                                     "JMx_JLUqhC9bED_YFjLKjlkjLKJlkjLKjlKJea"
+                                     "VZDei530-w0yE2urpQ";
+const char kUserRefreshToken[]     = "1/zQLKjlKJlkLkLKjLkjLKjLkjLjLkjl0ftc6"
+                                     "cp1nI-GQ";
+
+}  // namespace test_data
+
+// Fill in the storage with default environment information (URLs, etc).
+void InitDefaultStorage(base::DictionaryValue* data) {
+  data->SetString(storage_keys::kClientId, test_data::kClientId);
+  data->SetString(storage_keys::kClientSecret, test_data::kClientSecret);
+  data->SetString(storage_keys::kApiKey, test_data::kApiKey);
+  data->SetString(storage_keys::kRefreshToken, "");
+  data->SetString(storage_keys::kDeviceId, "");
+  data->SetString(storage_keys::kOAuthURL, test_data::kOAuthURL);
+  data->SetString(storage_keys::kServiceURL, test_data::kServiceURL);
+  data->SetString(storage_keys::kRobotAccount, "");
+}
+
+// Add the test device registration information.
+void SetDefaultDeviceRegistration(base::DictionaryValue* data) {
+  data->SetString(storage_keys::kRefreshToken, test_data::kRefreshToken);
+  data->SetString(storage_keys::kDeviceId, test_data::kDeviceId);
+  data->SetString(storage_keys::kRobotAccount, test_data::kRobotAccountEmail);
+}
+
+void OAuth2Handler(const fake::ServerRequest& request,
+                  fake::ServerResponse* response) {
+  base::DictionaryValue json;
+  if (request.GetFormField("grant_type") == "refresh_token") {
+    // Refresh device access token.
+    EXPECT_EQ(test_data::kRefreshToken, request.GetFormField("refresh_token"));
+    EXPECT_EQ(test_data::kClientId, request.GetFormField("client_id"));
+    EXPECT_EQ(test_data::kClientSecret, request.GetFormField("client_secret"));
+    json.SetString("access_token", test_data::kAccessToken);
+  } else if (request.GetFormField("grant_type") == "authorization_code") {
+    // Obtain access token.
+    std::string code = request.GetFormField("code");
+    if (code == test_data::kUserAccountAuthCode) {
+      // Get user access token.
+      EXPECT_EQ(test_data::kClientId, request.GetFormField("client_id"));
+      EXPECT_EQ(test_data::kClientSecret,
+                request.GetFormField("client_secret"));
+      EXPECT_EQ("urn:ietf:wg:oauth:2.0:oob",
+                request.GetFormField("redirect_uri"));
+      json.SetString("access_token", test_data::kUserAccessToken);
+      json.SetString("token_type", "Bearer");
+      json.SetString("refresh_token", test_data::kUserRefreshToken);
+    } else if (code == test_data::kRobotAccountAuthCode) {
+      // Get device access token.
+      EXPECT_EQ(test_data::kClientId, request.GetFormField("client_id"));
+      EXPECT_EQ(test_data::kClientSecret,
+                request.GetFormField("client_secret"));
+      EXPECT_EQ("oob", request.GetFormField("redirect_uri"));
+      EXPECT_EQ("https://www.googleapis.com/auth/clouddevices",
+                request.GetFormField("scope"));
+      json.SetString("access_token", test_data::kAccessToken);
+      json.SetString("token_type", "Bearer");
+      json.SetString("refresh_token", test_data::kRefreshToken);
+    } else {
+      ASSERT_TRUE(false); // Unexpected authorization code.
+    }
+  } else {
+    ASSERT_TRUE(false); // Unexpected grant type.
+  }
+  json.SetInteger("expires_in", 3600);
+  response->ReplyJson(status_code::Ok, &json);
+}
+
+void DeviceInfoHandler(const fake::ServerRequest& request,
+                       fake::ServerResponse* response) {
+  std::string auth = "Bearer ";
+  auth += test_data::kAccessToken;
+  EXPECT_EQ(auth, request.GetHeader(http::request_header::kAuthorization));
+  response->ReplyJson(status_code::Ok, {
+    {"channel.supportedType", "xmpp"},
+    {"deviceKind", "vendor"},
+    {"id", test_data::kDeviceId},
+    {"kind", "clouddevices#device"},
+  });
+}
+
+void FinalizeTicketHandler(const fake::ServerRequest& request,
+                           fake::ServerResponse* response) {
+  EXPECT_EQ(test_data::kApiKey, request.GetFormField("key"));
+  EXPECT_TRUE(request.GetData().empty());
+
+  response->ReplyJson(status_code::Ok, {
+    {"id", test_data::kClaimTicketId},
+    {"kind", "clouddevices#registrationTicket"},
+    {"oauthClientId", test_data::kClientId},
+    {"userEmail", "user@email.com"},
+    {"deviceDraft.id", test_data::kDeviceId},
+    {"deviceDraft.kind", "clouddevices#device"},
+    {"deviceDraft.channel.supportedType", "xmpp"},
+    {"robotAccountEmail", test_data::kRobotAccountEmail},
+    {"robotAccountAuthorizationCode", test_data::kRobotAccountAuthCode},
+  });
+}
+
+}  // anonymous namespace
+
+// This is a helper class that allows the unit tests to set the private
+// member DeviceRegistrationInfo::ticket_id_, since TestHelper is declared
+// as a friend to DeviceRegistrationInfo.
+class DeviceRegistrationInfo::TestHelper {
+ public:
+  static void SetTestTicketId(DeviceRegistrationInfo* info) {
+    info->ticket_id_ = test_data::kClaimTicketId;
+  }
+};
+
+class DeviceRegistrationInfoTest : public ::testing::Test {
+ protected:
+  virtual void SetUp() override {
+    InitDefaultStorage(&data);
+    storage = std::make_shared<MemStorage>();
+    storage->Save(&data);
+    transport = std::make_shared<fake::Transport>();
+    dev_reg = std::unique_ptr<DeviceRegistrationInfo>(
+        new DeviceRegistrationInfo(transport, storage));
+  }
+
+  base::DictionaryValue data;
+  std::shared_ptr<MemStorage> storage;
+  std::shared_ptr<fake::Transport> transport;
+  std::unique_ptr<DeviceRegistrationInfo> dev_reg;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+TEST_F(DeviceRegistrationInfoTest, GetServiceURL) {
+  EXPECT_TRUE(dev_reg->Load());
+  EXPECT_EQ(test_data::kServiceURL, dev_reg->GetServiceURL());
+  std::string url = test_data::kServiceURL;
+  url += "registrationTickets";
+  EXPECT_EQ(url, dev_reg->GetServiceURL("registrationTickets"));
+  url += "?key=";
+  url += test_data::kApiKey;
+  EXPECT_EQ(url, dev_reg->GetServiceURL("registrationTickets", {
+    {"key", test_data::kApiKey}
+  }));
+  url += "&restart=true";
+  EXPECT_EQ(url, dev_reg->GetServiceURL("registrationTickets", {
+    {"key", test_data::kApiKey},
+    {"restart", "true"},
+  }));
+}
+
+TEST_F(DeviceRegistrationInfoTest, GetOAuthURL) {
+  EXPECT_TRUE(dev_reg->Load());
+  EXPECT_EQ(test_data::kOAuthURL, dev_reg->GetOAuthURL());
+  std::string url = test_data::kOAuthURL;
+  url += "auth?scope=https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fclouddevices&";
+  url += "redirect_uri=urn%3Aietf%3Awg%3Aoauth%3A2.0%3Aoob&";
+  url += "response_type=code&";
+  url += "client_id=";
+  url += test_data::kClientId;
+  EXPECT_EQ(url, dev_reg->GetOAuthURL("auth", {
+    {"scope", "https://www.googleapis.com/auth/clouddevices"},
+    {"redirect_uri", "urn:ietf:wg:oauth:2.0:oob"},
+    {"response_type", "code"},
+    {"client_id", test_data::kClientId}
+  }));
+}
+
+TEST_F(DeviceRegistrationInfoTest, CheckRegistration) {
+  EXPECT_TRUE(dev_reg->Load());
+  EXPECT_FALSE(dev_reg->CheckRegistration());
+  EXPECT_EQ(0, transport->GetRequestCount());
+
+  SetDefaultDeviceRegistration(&data);
+  storage->Save(&data);
+  EXPECT_TRUE(dev_reg->Load());
+
+  transport->AddHandler(dev_reg->GetOAuthURL("token"), request_type::kPost,
+                        base::Bind(OAuth2Handler));
+  transport->ResetRequestCount();
+  EXPECT_TRUE(dev_reg->CheckRegistration());
+  EXPECT_EQ(1, transport->GetRequestCount());
+}
+
+TEST_F(DeviceRegistrationInfoTest, GetDeviceInfo) {
+  SetDefaultDeviceRegistration(&data);
+  storage->Save(&data);
+  EXPECT_TRUE(dev_reg->Load());
+
+  transport->AddHandler(dev_reg->GetOAuthURL("token"), request_type::kPost,
+                        base::Bind(OAuth2Handler));
+  transport->AddHandler(dev_reg->GetDeviceURL(), request_type::kGet,
+                        base::Bind(DeviceInfoHandler));
+  transport->ResetRequestCount();
+  auto device_info = dev_reg->GetDeviceInfo();
+  EXPECT_EQ(2, transport->GetRequestCount());
+  EXPECT_NE(nullptr, device_info.get());
+  base::DictionaryValue* dict = nullptr;
+  EXPECT_TRUE(device_info->GetAsDictionary(&dict));
+  std::string id;
+  EXPECT_TRUE(dict->GetString("id", &id));
+  EXPECT_EQ(test_data::kDeviceId, id);
+}
+
+TEST_F(DeviceRegistrationInfoTest, GetDeviceId) {
+  SetDefaultDeviceRegistration(&data);
+  storage->Save(&data);
+  EXPECT_TRUE(dev_reg->Load());
+
+  transport->AddHandler(dev_reg->GetOAuthURL("token"), request_type::kPost,
+                        base::Bind(OAuth2Handler));
+  transport->AddHandler(dev_reg->GetDeviceURL(), request_type::kGet,
+                        base::Bind(DeviceInfoHandler));
+  std::string id = dev_reg->GetDeviceId();
+  EXPECT_EQ(test_data::kDeviceId, id);
+}
+
+TEST_F(DeviceRegistrationInfoTest, StartRegistration) {
+  EXPECT_TRUE(dev_reg->Load());
+
+  auto create_ticket = [](const fake::ServerRequest& request,
+                          fake::ServerResponse* response) {
+    EXPECT_EQ(test_data::kApiKey, request.GetFormField("key"));
+    auto json = request.GetDataAsJson();
+    EXPECT_NE(nullptr, json.get());
+    std::string value;
+    EXPECT_TRUE(json->GetString("deviceDraft.channel.supportedType", &value));
+    EXPECT_EQ("xmpp", value);
+    EXPECT_TRUE(json->GetString("oauthClientId", &value));
+    EXPECT_EQ(test_data::kClientId, value);
+    EXPECT_TRUE(json->GetString("deviceDraft.deviceKind", &value));
+    EXPECT_EQ("vendor", value);
+
+    base::DictionaryValue json_resp;
+    json_resp.SetString("id", test_data::kClaimTicketId);
+    json_resp.SetString("kind", "clouddevices#registrationTicket");
+    json_resp.SetString("oauthClientId", test_data::kClientId);
+    base::DictionaryValue* device_draft = nullptr;
+    EXPECT_TRUE(json->GetDictionary("deviceDraft", &device_draft));
+    device_draft = device_draft->DeepCopy();
+    device_draft->SetString("id", test_data::kDeviceId);
+    device_draft->SetString("kind", "clouddevices#device");
+    json_resp.Set("deviceDraft", device_draft);
+
+    response->ReplyJson(status_code::Ok, &json_resp);
+  };
+
+  transport->AddHandler(dev_reg->GetServiceURL("registrationTickets"),
+                        request_type::kPost,
+                        base::Bind(create_ticket));
+  std::map<std::string, std::shared_ptr<base::Value>> params;
+  std::string json_resp = dev_reg->StartRegistration(params, nullptr);
+  auto json = std::unique_ptr<base::Value>(base::JSONReader::Read(json_resp));
+  EXPECT_NE(nullptr, json.get());
+  base::DictionaryValue* dict = nullptr;
+  EXPECT_TRUE(json->GetAsDictionary(&dict));
+  std::string value;
+  EXPECT_TRUE(dict->GetString("ticket_id", &value));
+  EXPECT_EQ(test_data::kClaimTicketId, value);
+}
+
+TEST_F(DeviceRegistrationInfoTest, FinishRegistration_NoAuth) {
+  // Test finalizing ticket with no user authorization token.
+  // This assumes that a client would patch in their email separately.
+  EXPECT_TRUE(dev_reg->Load());
+
+  // General ticket finalization handler.
+  std::string ticket_url =
+      dev_reg->GetServiceURL("registrationTickets/" +
+                             std::string(test_data::kClaimTicketId));
+  transport->AddHandler(ticket_url + "/finalize", request_type::kPost,
+                        base::Bind(FinalizeTicketHandler));
+
+  transport->AddHandler(dev_reg->GetOAuthURL("token"), request_type::kPost,
+                        base::Bind(OAuth2Handler));
+
+  storage->save_count_ = 0;
+  DeviceRegistrationInfo::TestHelper::SetTestTicketId(dev_reg.get());
+  EXPECT_TRUE(dev_reg->FinishRegistration(""));
+  EXPECT_EQ(1, storage->save_count_); // The device info must have been saved.
+  EXPECT_EQ(2, transport->GetRequestCount());
+
+  // Validate the device info saved to storage...
+  auto storage_data = storage->Load();
+  base::DictionaryValue* dict = nullptr;
+  EXPECT_TRUE(storage_data->GetAsDictionary(&dict));
+  std::string value;
+  EXPECT_TRUE(dict->GetString(storage_keys::kApiKey, &value));
+  EXPECT_EQ(test_data::kApiKey, value);
+  EXPECT_TRUE(dict->GetString(storage_keys::kClientId, &value));
+  EXPECT_EQ(test_data::kClientId, value);
+  EXPECT_TRUE(dict->GetString(storage_keys::kClientSecret, &value));
+  EXPECT_EQ(test_data::kClientSecret, value);
+  EXPECT_TRUE(dict->GetString(storage_keys::kDeviceId, &value));
+  EXPECT_EQ(test_data::kDeviceId, value);
+  EXPECT_TRUE(dict->GetString(storage_keys::kOAuthURL, &value));
+  EXPECT_EQ(test_data::kOAuthURL, value);
+  EXPECT_TRUE(dict->GetString(storage_keys::kRefreshToken, &value));
+  EXPECT_EQ(test_data::kRefreshToken, value);
+  EXPECT_TRUE(dict->GetString(storage_keys::kRobotAccount, &value));
+  EXPECT_EQ(test_data::kRobotAccountEmail, value);
+  EXPECT_TRUE(dict->GetString(storage_keys::kServiceURL, &value));
+  EXPECT_EQ(test_data::kServiceURL, value);
+}
+
+TEST_F(DeviceRegistrationInfoTest, FinishRegistration_Auth) {
+  // Test finalizing ticket with user authorization token.
+  EXPECT_TRUE(dev_reg->Load());
+
+  // General ticket finalization handler.
+  std::string ticket_url =
+      dev_reg->GetServiceURL("registrationTickets/" +
+                             std::string(test_data::kClaimTicketId));
+  transport->AddHandler(ticket_url + "/finalize", request_type::kPost,
+                        base::Bind(FinalizeTicketHandler));
+
+  transport->AddHandler(dev_reg->GetOAuthURL("token"), request_type::kPost,
+                        base::Bind(OAuth2Handler));
+
+  // Handle patching in the user email onto the device record.
+  auto email_patch_handler = [](const fake::ServerRequest& request,
+                                fake::ServerResponse* response) {
+    std::string auth_header = "Bearer ";
+    auth_header += test_data::kUserAccessToken;
+    EXPECT_EQ(auth_header,
+              request.GetHeader(http::request_header::kAuthorization));
+    auto json = request.GetDataAsJson();
+    EXPECT_NE(nullptr, json.get());
+    std::string value;
+    EXPECT_TRUE(json->GetString("userEmail", &value));
+    EXPECT_EQ("me", value);
+
+    response->ReplyJson(status_code::Ok, {
+      {"id", test_data::kClaimTicketId},
+      {"kind", "clouddevices#registrationTicket"},
+      {"oauthClientId", test_data::kClientId},
+      {"userEmail", "user@email.com"},
+      {"deviceDraft.id", test_data::kDeviceId},
+      {"deviceDraft.kind", "clouddevices#device"},
+      {"deviceDraft.channel.supportedType", "xmpp"},
+    });
+  };
+  transport->AddHandler(ticket_url, request_type::kPatch,
+                        base::Bind(email_patch_handler));
+
+  storage->save_count_ = 0;
+  DeviceRegistrationInfo::TestHelper::SetTestTicketId(dev_reg.get());
+  EXPECT_TRUE(dev_reg->FinishRegistration(test_data::kUserAccountAuthCode));
+  EXPECT_EQ(1, storage->save_count_); // The device info must have been saved.
+  EXPECT_EQ(4, transport->GetRequestCount());
+}
diff --git a/buffet/device_registration_storage_keys.h b/buffet/device_registration_storage_keys.h
new file mode 100644
index 0000000..a6c9239
--- /dev/null
+++ b/buffet/device_registration_storage_keys.h
@@ -0,0 +1,31 @@
+// Copyright 2014 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 BUFFET_DEVICE_REGISTRATION_STORAGE_KEYS_H_
+#define BUFFET_DEVICE_REGISTRATION_STORAGE_KEYS_H_
+
+// These are the keys used to identify specific device registration information
+// being saved to a storage. Used mostly internally by DeviceRegistrationInfo
+// but also exposed so that tests can access them.
+namespace buffet {
+namespace storage_keys {
+
+// Persistent keys
+extern const char kClientId[];
+extern const char kClientSecret[];
+extern const char kApiKey[];
+extern const char kRefreshToken[];
+extern const char kDeviceId[];
+extern const char kOAuthURL[];
+extern const char kServiceURL[];
+extern const char kRobotAccount[];
+// Transient keys
+extern const char kDeviceKind[];
+extern const char kSystemName[];
+extern const char kDisplayName[];
+
+}  // namespace storage_keys
+}  // namespace buffet
+
+#endif  // BUFFET_DEVICE_REGISTRATION_STORAGE_KEYS_H_
diff --git a/buffet/http_connection_fake.cc b/buffet/http_connection_fake.cc
index 0507c0b..6a1c3b9 100644
--- a/buffet/http_connection_fake.cc
+++ b/buffet/http_connection_fake.cc
@@ -40,6 +40,8 @@
   CHECK(transport) << "Expecting a fake transport";
   auto handler = transport->GetHandler(request_.GetURL(), request_.GetMethod());
   if (handler.is_null()) {
+    LOG(ERROR) << "Received unexpected " << request_.GetMethod()
+               << " request at " << request_.GetURL();
     response_.ReplyText(status_code::NotFound,
                         "<html><body>Not found</body></html>",
                         mime::text::kHtml);
diff --git a/buffet/http_transport_fake.cc b/buffet/http_transport_fake.cc
index 84d70cb..4a3a781 100644
--- a/buffet/http_transport_fake.cc
+++ b/buffet/http_transport_fake.cc
@@ -4,9 +4,11 @@
 
 #include "buffet/http_transport_fake.h"
 
+#include <base/json/json_reader.h>
 #include <base/json/json_writer.h>
 #include <base/logging.h>
 
+#include "buffet/bind_lambda.h"
 #include "buffet/http_connection_fake.h"
 #include "buffet/http_request.h"
 #include "buffet/mime_utils.h"
@@ -48,6 +50,7 @@
     if (error_msg)
       *error_msg = "Failed to send request headers";
   }
+  request_count_++;
   return connection;
 }
 
@@ -61,6 +64,18 @@
   handlers_.insert(std::make_pair(GetHandlerMapKey(url, method), handler));
 }
 
+void Transport::AddSimpleReplyHandler(const std::string& url,
+                                      const std::string& method,
+                                      int status_code,
+                                      const std::string& reply_text,
+                                      const std::string& mime_type) {
+  auto handler = [status_code, reply_text, mime_type](
+      const ServerRequest& request, ServerResponse* response) {
+    response->ReplyText(status_code, reply_text, mime_type.c_str());
+  };
+  AddHandler(url, method, base::Bind(handler));
+}
+
 Transport::HandlerCallback Transport::GetHandler(
     const std::string& url, const std::string& method) const {
   // First try the exact combination of URL/Method
@@ -92,6 +107,23 @@
   return std::string(chars, data_.size());
 }
 
+std::unique_ptr<base::DictionaryValue>
+    ServerRequestResponseBase::GetDataAsJson() const {
+  if (mime::RemoveParameters(GetHeader(request_header::kContentType)) ==
+      mime::application::kJson) {
+    auto value = base::JSONReader::Read(GetDataAsString());
+    if (value) {
+      base::DictionaryValue* dict = nullptr;
+      if (value->GetAsDictionary(&dict)) {
+        return std::unique_ptr<base::DictionaryValue>(dict);
+      } else {
+        delete value;
+      }
+    }
+  }
+  return std::unique_ptr<base::DictionaryValue>();
+}
+
 void ServerRequestResponseBase::AddHeaders(const HeaderList& headers) {
   for (auto&& pair : headers) {
     if (pair.second.empty())
@@ -150,7 +182,19 @@
   base::JSONWriter::WriteWithOptions(json,
                                      base::JSONWriter::OPTIONS_PRETTY_PRINT,
                                      &text);
-  ReplyText(status_code, text, mime::application::kJson);
+  std::string mime_type = mime::AppendParameter(mime::application::kJson,
+                                                mime::parameters::kCharset,
+                                                "utf-8");
+  ReplyText(status_code, text, mime_type.c_str());
+}
+
+void ServerResponse::ReplyJson(int status_code,
+                               const http::FormFieldList& fields) {
+  base::DictionaryValue json;
+  for (auto&& pair : fields) {
+    json.SetString(pair.first, pair.second);
+  }
+  ReplyJson(status_code, &json);
 }
 
 std::string ServerResponse::GetStatusText() const {
diff --git a/buffet/http_transport_fake.h b/buffet/http_transport_fake.h
index b95599f..a2fb04d 100644
--- a/buffet/http_transport_fake.h
+++ b/buffet/http_transport_fake.h
@@ -11,6 +11,7 @@
 #include <base/values.h>
 
 #include "buffet/http_transport.h"
+#include "buffet/http_utils.h"
 
 namespace chromeos {
 namespace http {
@@ -44,10 +45,22 @@
   // The lookup starts with the most specific data pair to the catch-all (*,*).
   void AddHandler(const std::string& url, const std::string& method,
                   const HandlerCallback& handler);
+  // Simple version of AddHandler. AddSimpleReplyHandler just returns the
+  // specified text response of given MIME type.
+  void AddSimpleReplyHandler(const std::string& url,
+                             const std::string& method,
+                             int status_code,
+                             const std::string& reply_text,
+                             const std::string& mime_type);
   // Retrieve a handler for specific |url| and request |method|.
   HandlerCallback GetHandler(const std::string& url,
                              const std::string& method) const;
 
+  // For tests that want to assert on the number of HTTP requests sent,
+  // these methods can be used to do just that.
+  int GetRequestCount() const { return request_count_; }
+  void ResetRequestCount() { request_count_ = 0; }
+
   // Overload from http::Transport
   virtual std::unique_ptr<http::Connection> CreateConnection(
       std::shared_ptr<http::Transport> transport,
@@ -63,6 +76,8 @@
 
   // A list of user-supplied request handlers.
   std::map<std::string, HandlerCallback> handlers_;
+  // Counter incremented each time a request is made.
+  int request_count_ = 0;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -77,6 +92,7 @@
   void AddData(const void* data, size_t data_size);
   const std::vector<unsigned char>& GetData() const { return data_; }
   std::string GetDataAsString() const;
+  std::unique_ptr<base::DictionaryValue> GetDataAsJson() const;
 
   // Add/retrieve request/response HTTP headers.
   void AddHeaders(const HeaderList& headers);
@@ -148,6 +164,9 @@
                  const char* mime_type);
   // Reply with JSON object. The content type will be "application/json".
   void ReplyJson(int status_code, const base::Value* json);
+  // Special form for JSON response for simple objects that have a flat
+  // list of key-value pairs of string type.
+  void ReplyJson(int status_code, const FormFieldList& fields);
 
   // Specialized overload to send the binary data as an array of simple
   // data elements. Only trivial data types (scalars, POD structures, etc)
diff --git a/buffet/http_utils.cc b/buffet/http_utils.cc
index 2cd8b80..d711cf8 100644
--- a/buffet/http_utils.cc
+++ b/buffet/http_utils.cc
@@ -93,8 +93,11 @@
   std::string data;
   if (json)
     base::JSONWriter::Write(json, &data);
+  std::string mime_type = mime::AppendParameter(mime::application::kJson,
+                                                mime::parameters::kCharset,
+                                                "utf-8");
   return PostBinary(url, data.c_str(), data.size(),
-                    mime::application::kJson, headers, transport);
+                    mime_type.c_str(), headers, transport);
 }
 
 std::unique_ptr<Response> PatchJson(const std::string& url,
@@ -104,8 +107,11 @@
   std::string data;
   if (json)
     base::JSONWriter::Write(json, &data);
+  std::string mime_type = mime::AppendParameter(mime::application::kJson,
+                                                mime::parameters::kCharset,
+                                                "utf-8");
   return SendRequest(request_type::kPatch, url, data.c_str(), data.size(),
-                     mime::application::kJson, headers, transport);
+                     mime_type.c_str(), headers, transport);
 }
 
 std::unique_ptr<base::DictionaryValue> ParseJsonResponse(
diff --git a/buffet/http_utils_unittest.cc b/buffet/http_utils_unittest.cc
index 1453b86..6438660 100644
--- a/buffet/http_utils_unittest.cc
+++ b/buffet/http_utils_unittest.cc
@@ -125,7 +125,8 @@
         {request_header::kIfMatch, "*"},
       }, transport);
   EXPECT_TRUE(response->IsSuccessful());
-  EXPECT_EQ(mime::application::kJson, response->GetContentType());
+  EXPECT_EQ(mime::application::kJson,
+            mime::RemoveParameters(response->GetContentType()));
   auto json = ParseJsonResponse(response.get(), nullptr, nullptr);
   std::string value;
   EXPECT_TRUE(json->GetString("method", &value));
@@ -261,12 +262,13 @@
 TEST(HttpUtils, PostPatchJson) {
   auto JsonHandler = [](const fake::ServerRequest& request,
                         fake::ServerResponse* response) {
-    EXPECT_EQ(mime::application::kJson,
-              request.GetHeader(request_header::kContentType));
-    base::DictionaryValue json;
-    json.SetString("method", request.GetMethod());
-    json.SetString("data", request.GetDataAsString());
-    response->ReplyJson(status_code::Ok, &json);
+    auto mime_type = mime::RemoveParameters(
+        request.GetHeader(request_header::kContentType));
+    EXPECT_EQ(mime::application::kJson, mime_type);
+    response->ReplyJson(status_code::Ok, {
+      {"method", request.GetMethod()},
+      {"data", request.GetDataAsString()},
+    });
   };
   std::shared_ptr<fake::Transport> transport(new fake::Transport);
   transport->AddHandler(kFakeUrl, "*", base::Bind(JsonHandler));
@@ -298,10 +300,8 @@
 TEST(HttpUtils, ParseJsonResponse) {
   auto JsonHandler = [](const fake::ServerRequest& request,
                         fake::ServerResponse* response) {
-    base::DictionaryValue json;
-    json.SetString("data", request.GetFormField("value"));
     int status_code = std::stoi(request.GetFormField("code"));
-    response->ReplyJson(status_code, &json);
+    response->ReplyJson(status_code, {{"data", request.GetFormField("value")}});
   };
   std::shared_ptr<fake::Transport> transport(new fake::Transport);
   transport->AddHandler(kFakeUrl, request_type::kPost, base::Bind(JsonHandler));