diff --git a/dbus_service.cc b/dbus_service.cc
index 447a900..5a46b51 100644
--- a/dbus_service.cc
+++ b/dbus_service.cc
@@ -9,6 +9,7 @@
 #include <base/logging.h>
 
 #include "update_engine/marshal.glibmarshal.h"
+#include "update_engine/omaha_request_params.h"
 #include "update_engine/utils.h"
 
 using std::string;
@@ -111,7 +112,12 @@
                                          gchar* track,
                                          GError **error) {
   if (track) {
-    LOG(INFO) << "TODO: Setting track to: " << track;
+    LOG(INFO) << "Setting track to: " << track;
+    if (!chromeos_update_engine::OmahaRequestDeviceParams::SetDeviceTrack(
+            track)) {
+      *error = NULL;
+      return FALSE;
+    }
   }
   return TRUE;
 }
diff --git a/omaha_request_params.cc b/omaha_request_params.cc
index 9f6e82b..03327b2 100644
--- a/omaha_request_params.cc
+++ b/omaha_request_params.cc
@@ -11,16 +11,21 @@
 #include <map>
 #include <string>
 
-#include "base/file_util.h"
-#include "base/string_util.h"
+#include <base/file_util.h>
+#include <base/string_util.h>
+
 #include "update_engine/simple_key_value_store.h"
 #include "update_engine/utils.h"
 
+#define CALL_MEMBER_FN(object, member) ((object).*(member))
+
 using std::map;
 using std::string;
 
 namespace chromeos_update_engine {
 
+const char OmahaRequestParams::kUpdateTrackKey[] = "CHROMEOS_RELEASE_TRACK";
+
 const char* const OmahaRequestParams::kAppId(
     "{87efface-864d-49a5-9bb3-4b050a7c227a}");
 const char* const OmahaRequestParams::kOsPlatform("Chrome OS");
@@ -30,17 +35,24 @@
 
 static const char kHWIDPath[] = "/sys/devices/platform/chromeos_acpi/HWID";
 
+OmahaRequestDeviceParams::OmahaRequestDeviceParams() :
+    force_build_type_(false),
+    forced_official_build_(false) {}
+
 bool OmahaRequestDeviceParams::Init(const std::string& in_app_version,
                                     const std::string& in_update_url) {
   os_platform = OmahaRequestParams::kOsPlatform;
   os_version = OmahaRequestParams::kOsVersion;
   app_version = in_app_version.empty() ?
-      GetLsbValue("CHROMEOS_RELEASE_VERSION", "") : in_app_version;
+      GetLsbValue("CHROMEOS_RELEASE_VERSION", "", NULL) : in_app_version;
   os_sp = app_version + "_" + GetMachineType();
-  os_board = GetLsbValue("CHROMEOS_RELEASE_BOARD", "");
+  os_board = GetLsbValue("CHROMEOS_RELEASE_BOARD", "", NULL);
   app_id = OmahaRequestParams::kAppId;
   app_lang = "en-US";
-  app_track = GetLsbValue("CHROMEOS_RELEASE_TRACK", "");
+  app_track = GetLsbValue(
+      kUpdateTrackKey,
+      "",
+      &chromeos_update_engine::OmahaRequestDeviceParams::IsValidTrack);
   hardware_class = GetHardwareClass();
   struct stat stbuf;
 
@@ -51,13 +63,38 @@
                (errno == ENOENT);
 
   update_url = in_update_url.empty() ?
-      GetLsbValue("CHROMEOS_AUSERVER", OmahaRequestParams::kUpdateUrl) :
+      GetLsbValue("CHROMEOS_AUSERVER", OmahaRequestParams::kUpdateUrl, NULL) :
       in_update_url;
   return true;
 }
 
-string OmahaRequestDeviceParams::GetLsbValue(
-    const string& key, const string& default_value) const {
+bool OmahaRequestDeviceParams::SetTrack(const std::string& track) {
+  TEST_AND_RETURN_FALSE(IsValidTrack(track));
+  FilePath kFile(root_ + utils::kStatefulPartition + "/etc/lsb-release");
+  string file_data;
+  map<string, string> data;
+  if (file_util::ReadFileToString(kFile, &file_data)) {
+    data = simple_key_value_store::ParseString(file_data);
+  }
+  data[kUpdateTrackKey] = track;
+  file_data = simple_key_value_store::AssembleString(data);
+  TEST_AND_RETURN_FALSE(file_util::CreateDirectory(kFile.DirName()));
+  TEST_AND_RETURN_FALSE(
+      file_util::WriteFile(kFile, file_data.data(), file_data.size()) ==
+      static_cast<int>(file_data.size()));
+  app_track = track;
+  return true;
+}
+
+bool OmahaRequestDeviceParams::SetDeviceTrack(const std::string& track) {
+  OmahaRequestDeviceParams params;
+  TEST_AND_RETURN_FALSE(params.Init("", ""));
+  return params.SetTrack(track);
+}
+
+string OmahaRequestDeviceParams::GetLsbValue(const string& key,
+                                             const string& default_value,
+                                             ValueValidator validator) const {
   string files[] = {string(utils::kStatefulPartition) + "/etc/lsb-release",
                     "/etc/lsb-release"};
   for (unsigned int i = 0; i < arraysize(files); ++i) {
@@ -68,8 +105,13 @@
       continue;
 
     map<string, string> data = simple_key_value_store::ParseString(file_data);
-    if (utils::MapContainsKey(data, key))
-      return data[key];
+    if (utils::MapContainsKey(data, key)) {
+      const string& value = data[key];
+      if (validator && !CALL_MEMBER_FN(*this, validator)(value)) {
+        continue;
+      }
+      return value;
+    }
   }
   // not found
   return default_value;
@@ -93,4 +135,18 @@
   return hwid;
 }
 
+bool OmahaRequestDeviceParams::IsOfficialBuild() const {
+  return force_build_type_ ? forced_official_build_ : utils::IsOfficialBuild();
+}
+
+bool OmahaRequestDeviceParams::IsValidTrack(const std::string& track) const {
+  return IsOfficialBuild() ?
+      (track == "beta-channel" || track == "dev-channel") : true;
+}
+
+void OmahaRequestDeviceParams::SetBuildTypeOfficial(bool is_official) {
+  force_build_type_ = true;
+  forced_official_build_ = is_official;
+}
+
 }  // namespace chromeos_update_engine
diff --git a/omaha_request_params.h b/omaha_request_params.h
index 551a3a3..d7d2493 100644
--- a/omaha_request_params.h
+++ b/omaha_request_params.h
@@ -7,7 +7,8 @@
 
 #include <string>
 
-#include "base/basictypes.h"
+#include <base/basictypes.h>
+#include <gtest/gtest_prod.h>  // for FRIEND_TEST
 
 // This gathers local system information and prepares info used by the
 // Omaha request action.
@@ -55,6 +56,8 @@
 
   std::string update_url;
 
+  static const char kUpdateTrackKey[];
+
   // Suggested defaults
   static const char* const kAppId;
   static const char* const kOsPlatform;
@@ -64,7 +67,7 @@
 
 class OmahaRequestDeviceParams : public OmahaRequestParams {
  public:
-  OmahaRequestDeviceParams() {}
+  OmahaRequestDeviceParams();
 
   // Initializes all the data in the object. Non-empty
   // |in_app_version| or |in_update_url| prevents automatic detection
@@ -72,15 +75,40 @@
   bool Init(const std::string& in_app_version,
             const std::string& in_update_url);
 
+  // Permanently changes the release track to |track|. Returns true on success,
+  // false otherwise.
+  bool SetTrack(const std::string& track);
+  static bool SetDeviceTrack(const std::string& track);
+
   // For unit-tests.
   void set_root(const std::string& root) { root_ = root; }
 
+  // Force build type for testing purposes.
+  void SetBuildTypeOfficial(bool is_official);
+
  private:
+  FRIEND_TEST(OmahaRequestDeviceParamsTest, IsValidTrackTest);
+
+  // Use a validator that is a non-static member of this class so that its
+  // inputs can be mocked in unit tests (e.g., build type for IsValidTrack).
+  typedef bool(OmahaRequestDeviceParams::*ValueValidator)(
+      const std::string&) const;
+
+  // Returns true if this is an official build, false otherwise.
+  bool IsOfficialBuild() const;
+
+  // Returns true if |track| is a valid track, false otherwise. This method
+  // restricts the track value only if the image is official (see
+  // IsOfficialBuild).
+  bool IsValidTrack(const std::string& track) const;
+
   // Fetches the value for a given key from
-  // /mnt/stateful_partition/etc/lsb-release if possible. Failing that,
-  // it looks for the key in /etc/lsb-release.
+  // /mnt/stateful_partition/etc/lsb-release if possible. Failing that, it looks
+  // for the key in /etc/lsb-release. If |validator| is non-NULL, uses it to
+  // validate and ignore invalid valies.
   std::string GetLsbValue(const std::string& key,
-                          const std::string& default_value) const;
+                          const std::string& default_value,
+                          ValueValidator validator) const;
 
   // Gets the machine type (e.g. "i686").
   std::string GetMachineType() const;
@@ -92,6 +120,10 @@
   // When reading files, prepend root_ to the paths. Useful for testing.
   std::string root_;
 
+  // Force build type for testing purposes.
+  bool force_build_type_;
+  bool forced_official_build_;
+
   DISALLOW_COPY_AND_ASSIGN(OmahaRequestDeviceParams);
 };
 
diff --git a/omaha_request_params_unittest.cc b/omaha_request_params_unittest.cc
index 0150a00..c136e06 100644
--- a/omaha_request_params_unittest.cc
+++ b/omaha_request_params_unittest.cc
@@ -28,12 +28,16 @@
     ASSERT_EQ(0, System(string("mkdir -p ") + kTestDir + "/etc"));
     ASSERT_EQ(0, System(string("mkdir -p ") + kTestDir +
                         utils::kStatefulPartition + "/etc"));
+    params_.set_root(string("./") + kTestDir);
+    params_.SetBuildTypeOfficial(false);
   }
 
   virtual void TearDown() {
     EXPECT_EQ(0, System(string("rm -rf ") + kTestDir));
   }
 
+  OmahaRequestDeviceParams params_;
+
   static const string kTestDir;
 };
 
@@ -43,11 +47,9 @@
 bool OmahaRequestDeviceParamsTest::DoTest(OmahaRequestParams* out,
                                           const string& app_version,
                                           const string& omaha_url) {
-  OmahaRequestDeviceParams params;
-  params.set_root(string("./") + kTestDir);
-  bool success = params.Init(app_version, omaha_url);
+  bool success = params_.Init(app_version, omaha_url);
   if (out)
-    *out = params;
+    *out = params_;
   return success;
 }
 
@@ -227,4 +229,157 @@
   EXPECT_EQ("sample hardware class", out.hardware_class);
 }
 
+TEST_F(OmahaRequestDeviceParamsTest, OverrideTest) {
+  ASSERT_TRUE(WriteFileString(
+      kTestDir + "/etc/lsb-release",
+      "CHROMEOS_RELEASE_BOARD=arm-generic\n"
+      "CHROMEOS_RELEASE_FOO=bar\n"
+      "CHROMEOS_RELEASE_VERSION=0.2.2.3\n"
+      "CHROMEOS_RELEASE_TRACK=footrack\n"
+      "CHROMEOS_AUSERVER=http://www.google.com"));
+  ASSERT_TRUE(WriteFileString(
+      kTestDir + utils::kStatefulPartition + "/etc/lsb-release",
+      "CHROMEOS_RELEASE_BOARD=x86-generic\n"
+      "CHROMEOS_RELEASE_TRACK=bartrack\n"
+      "CHROMEOS_AUSERVER=http://www.google.com"));
+  OmahaRequestParams out;
+  EXPECT_TRUE(DoTest(&out, "", ""));
+  EXPECT_EQ("Chrome OS", out.os_platform);
+  EXPECT_EQ(string("0.2.2.3_") + GetMachineType(), out.os_sp);
+  EXPECT_EQ("x86-generic", out.os_board);
+  EXPECT_EQ("{87efface-864d-49a5-9bb3-4b050a7c227a}", out.app_id);
+  EXPECT_EQ("0.2.2.3", out.app_version);
+  EXPECT_EQ("en-US", out.app_lang);
+  EXPECT_EQ("", out.hardware_class);
+  EXPECT_TRUE(out.delta_okay);
+  EXPECT_EQ("bartrack", out.app_track);
+  EXPECT_EQ("http://www.google.com", out.update_url);
+}
+
+TEST_F(OmahaRequestDeviceParamsTest, SetTrackSimpleTest) {
+  ASSERT_TRUE(WriteFileString(
+      kTestDir + "/etc/lsb-release",
+      "CHROMEOS_RELEASE_BOARD=arm-generic\n"
+      "CHROMEOS_RELEASE_FOO=bar\n"
+      "CHROMEOS_RELEASE_VERSION=0.2.2.3\n"
+      "CHROMEOS_RELEASE_TRACK=footrack\n"
+      "CHROMEOS_AUSERVER=http://www.google.com"));
+  {
+    OmahaRequestDeviceParams params;
+    params.set_root(string("./") + kTestDir);
+    params.SetBuildTypeOfficial(false);
+    EXPECT_TRUE(params.Init("", ""));
+    params.SetTrack("zootrack");
+  }
+  OmahaRequestParams out;
+  EXPECT_TRUE(DoTest(&out, "", ""));
+  EXPECT_EQ("arm-generic", out.os_board);
+  EXPECT_EQ("zootrack", out.app_track);
+}
+
+TEST_F(OmahaRequestDeviceParamsTest, SetTrackPreserveTest) {
+  ASSERT_TRUE(WriteFileString(
+      kTestDir + "/etc/lsb-release",
+      "CHROMEOS_RELEASE_BOARD=arm-generic\n"
+      "CHROMEOS_RELEASE_FOO=bar\n"
+      "CHROMEOS_RELEASE_VERSION=0.2.2.3\n"
+      "CHROMEOS_RELEASE_TRACK=footrack\n"
+      "CHROMEOS_AUSERVER=http://www.google.com"));
+  ASSERT_TRUE(WriteFileString(
+      kTestDir + utils::kStatefulPartition + "/etc/lsb-release",
+      "CHROMEOS_RELEASE_BOARD=x86-generic\n"
+      "CHROMEOS_RELEASE_TRACK=bartrack"));
+  {
+    OmahaRequestDeviceParams params;
+    params.set_root(string("./") + kTestDir);
+    params.SetBuildTypeOfficial(false);
+    EXPECT_TRUE(params.Init("", ""));
+    params.SetTrack("zootrack");
+  }
+  OmahaRequestParams out;
+  EXPECT_TRUE(DoTest(&out, "", ""));
+  EXPECT_EQ("x86-generic", out.os_board);
+  EXPECT_EQ("zootrack", out.app_track);
+}
+
+TEST_F(OmahaRequestDeviceParamsTest, SetTrackInvalidTest) {
+  ASSERT_TRUE(WriteFileString(
+      kTestDir + "/etc/lsb-release",
+      "CHROMEOS_RELEASE_BOARD=arm-generic\n"
+      "CHROMEOS_RELEASE_FOO=bar\n"
+      "CHROMEOS_RELEASE_VERSION=0.2.2.3\n"
+      "CHROMEOS_RELEASE_TRACK=footrack\n"
+      "CHROMEOS_AUSERVER=http://www.google.com"));
+  {
+    OmahaRequestDeviceParams params;
+    params.set_root(string("./") + kTestDir);
+    params.SetBuildTypeOfficial(true);
+    EXPECT_TRUE(params.Init("", ""));
+    params.SetTrack("zootrack");
+  }
+  OmahaRequestParams out;
+  EXPECT_TRUE(DoTest(&out, "", ""));
+  EXPECT_EQ("arm-generic", out.os_board);
+  EXPECT_EQ("footrack", out.app_track);
+}
+
+TEST_F(OmahaRequestDeviceParamsTest, IsValidTrackTest) {
+  params_.SetBuildTypeOfficial(true);
+  EXPECT_TRUE(params_.IsValidTrack("beta-channel"));
+  EXPECT_TRUE(params_.IsValidTrack("dev-channel"));
+  EXPECT_FALSE(params_.IsValidTrack("some-channel"));
+  EXPECT_FALSE(params_.IsValidTrack(""));
+  params_.SetBuildTypeOfficial(false);
+  EXPECT_TRUE(params_.IsValidTrack("beta-channel"));
+  EXPECT_TRUE(params_.IsValidTrack("dev-channel"));
+  EXPECT_TRUE(params_.IsValidTrack("some-channel"));
+  EXPECT_TRUE(params_.IsValidTrack(""));
+}
+
+TEST_F(OmahaRequestDeviceParamsTest, InvalidTrackTest) {
+  ASSERT_TRUE(WriteFileString(
+      kTestDir + "/etc/lsb-release",
+      "CHROMEOS_RELEASE_BOARD=arm-generic\n"
+      "CHROMEOS_RELEASE_FOO=bar\n"
+      "CHROMEOS_RELEASE_VERSION=0.2.2.3\n"
+      "CHROMEOS_RELEASE_TRACK=footrack\n"
+      "CHROMEOS_AUSERVER=http://www.google.com"));
+  params_.SetBuildTypeOfficial(true);
+  OmahaRequestParams out;
+  EXPECT_TRUE(DoTest(&out, "", ""));
+  EXPECT_EQ("Chrome OS", out.os_platform);
+  EXPECT_EQ(string("0.2.2.3_") + GetMachineType(), out.os_sp);
+  EXPECT_EQ("arm-generic", out.os_board);
+  EXPECT_EQ("{87efface-864d-49a5-9bb3-4b050a7c227a}", out.app_id);
+  EXPECT_EQ("0.2.2.3", out.app_version);
+  EXPECT_EQ("en-US", out.app_lang);
+  EXPECT_EQ("", out.hardware_class);
+  EXPECT_TRUE(out.delta_okay);
+  EXPECT_EQ("", out.app_track);
+  EXPECT_EQ("http://www.google.com", out.update_url);
+}
+
+TEST_F(OmahaRequestDeviceParamsTest, ValidTrackTest) {
+  ASSERT_TRUE(WriteFileString(
+      kTestDir + "/etc/lsb-release",
+      "CHROMEOS_RELEASE_BOARD=arm-generic\n"
+      "CHROMEOS_RELEASE_FOO=bar\n"
+      "CHROMEOS_RELEASE_VERSION=0.2.2.3\n"
+      "CHROMEOS_RELEASE_TRACK=dev-channel\n"
+      "CHROMEOS_AUSERVER=http://www.google.com"));
+  params_.SetBuildTypeOfficial(true);
+  OmahaRequestParams out;
+  EXPECT_TRUE(DoTest(&out, "", ""));
+  EXPECT_EQ("Chrome OS", out.os_platform);
+  EXPECT_EQ(string("0.2.2.3_") + GetMachineType(), out.os_sp);
+  EXPECT_EQ("arm-generic", out.os_board);
+  EXPECT_EQ("{87efface-864d-49a5-9bb3-4b050a7c227a}", out.app_id);
+  EXPECT_EQ("0.2.2.3", out.app_version);
+  EXPECT_EQ("en-US", out.app_lang);
+  EXPECT_EQ("", out.hardware_class);
+  EXPECT_TRUE(out.delta_okay);
+  EXPECT_EQ("dev-channel", out.app_track);
+  EXPECT_EQ("http://www.google.com", out.update_url);
+}
+
 }  // namespace chromeos_update_engine
diff --git a/update_engine_client.cc b/update_engine_client.cc
index a662242..20c86a5 100644
--- a/update_engine_client.cc
+++ b/update_engine_client.cc
@@ -189,7 +189,7 @@
                                                    &error);
   CHECK_EQ(rc, true) << "Error setting the track: "
                      << GetGErrorMessage(error);
-  LOG(INFO) << "TODO: Track permanently set to: " << track;
+  LOG(INFO) << "Track permanently set to: " << track;
 }
 
 static gboolean CompleteUpdateSource(gpointer data) {