diff --git a/payload_state.cc b/payload_state.cc
new file mode 100644
index 0000000..b153fa7
--- /dev/null
+++ b/payload_state.cc
@@ -0,0 +1,129 @@
+// Copyright (c) 2012 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 "update_engine/payload_state.h"
+
+#include <base/logging.h>
+#include <base/stringprintf.h>
+
+#include "update_engine/omaha_request_action.h"
+#include "update_engine/prefs.h"
+
+using std::string;
+
+namespace chromeos_update_engine {
+
+// Returns a string containing that subset of the fields from the OmahaResponse
+// which we're interested in persisting for the purpose of detecting whether
+// we should clear the rest of the payload state when we get a new
+// OmahaResponse.
+static string GetFilteredResponse(const OmahaResponse& response) {
+  string mini_response = StringPrintf("NumURLs = %d\n",
+                                      response.payload_urls.size());
+
+  for (size_t i = 0; i < response.payload_urls.size(); i++)
+    mini_response += StringPrintf("Url%d = %s\n",
+                                  i, response.payload_urls[i].c_str());
+
+  mini_response += StringPrintf("Payload Size = %llu\n"
+                                "Payload Sha256 Hash = %s\n"
+                                "Metadata Size = %llu\n"
+                                "Metadata Signature = %s\n",
+                                response.size,
+                                response.hash.c_str(),
+                                response.metadata_size,
+                                response.metadata_signature.c_str());
+  return mini_response;
+}
+
+bool PayloadState::Initialize(PrefsInterface* prefs) {
+  CHECK(prefs);
+  prefs_ = prefs;
+  LoadResponse();
+  LoadUrlIndex();
+  LogPayloadState();
+  return true;
+}
+
+void PayloadState::LogPayloadState() {
+  LOG(INFO) << "Current Payload State:\n"
+            << "Current Response = \n" << response_
+            << "Current URL Index = " << url_index_;
+}
+
+void PayloadState::SetResponse(const OmahaResponse& omaha_response) {
+  CHECK(prefs_);
+  num_urls_ = omaha_response.payload_urls.size();
+  string new_response = GetFilteredResponse(omaha_response);
+  bool has_response_changed = (response_ != new_response);
+  response_ = new_response;
+  LOG(INFO) << "Stored Response = \n" << response_;
+  prefs_->SetString(kPrefsCurrentResponse, response_);
+
+  if (has_response_changed) {
+    LOG(INFO) << "Resetting all payload state as this is a new response";
+    SetUrlIndex(0);
+  }
+}
+
+void PayloadState::UpdateFailed(ActionExitCode error) {
+  LOG(INFO) << "Updating payload state for error code: " << error;
+
+  if (!num_urls_) {
+    // Since we don't persist num_urls_, it's possible that we get an error in
+    // our communication to Omaha before even OmahaRequestAction code had a
+    // chance to call SetResponse (which sets num_urls_). So we should not
+    // advance the url_index_ in such cases.
+    LOG(INFO) << "Ignoring failures until we get a valid Omaha response.";
+    return;
+  }
+
+  // chromium-os:37206: Classify the errors and advance the URL index at
+  // different rates for different errors in the next CL. Until then, advance
+  // URL index on every single error.
+  uint32_t next_url_index = GetUrlIndex() + 1;
+  if (next_url_index < num_urls_) {
+    LOG(INFO) << "Advancing the URL index for next attempt";
+  } else {
+    LOG(INFO) << "Resetting the current URL index (" << GetUrlIndex() << ") to "
+              << "0 as we only have " << num_urls_ << " URL(s)";
+    next_url_index = 0;
+
+    // TODO(jaysri): This is the place where we should increment the
+    // payload_attempt_number so that we can back-off appropriately.
+  }
+
+  SetUrlIndex(next_url_index);
+}
+
+string PayloadState::LoadResponse() {
+  CHECK(prefs_);
+  string stored_value;
+  if (prefs_->Exists(kPrefsCurrentResponse) &&
+      prefs_->GetString(kPrefsCurrentResponse, &stored_value)) {
+    response_ = stored_value;
+  }
+  return response_;
+}
+
+uint32_t PayloadState::LoadUrlIndex() {
+  CHECK(prefs_);
+  int64_t stored_value;
+  if (prefs_->Exists(kPrefsCurrentUrlIndex) &&
+      prefs_->GetInt64(kPrefsCurrentUrlIndex, &stored_value)) {
+    url_index_ = stored_value;
+  }
+  return url_index_;
+}
+
+void PayloadState::SetUrlIndex(uint32_t url_index) {
+  CHECK(prefs_);
+  // TODO(jaysri): When we implement failure count, make sure to reset
+  // the failure count when url index changes.
+  url_index_ = url_index;
+  LOG(INFO) << "Current URL Index = " << url_index_;
+  prefs_->SetInt64(kPrefsCurrentUrlIndex, url_index_);
+}
+
+}  // namespace chromeos_update_engine