diff --git a/SConstruct b/SConstruct
index 720c281..7a3b2ef 100644
--- a/SConstruct
+++ b/SConstruct
@@ -237,6 +237,7 @@
                    policy_manager/evaluation_context.cc
                    policy_manager/event_loop.cc
                    policy_manager/policy_manager.cc
+                   policy_manager/real_device_policy_provider.cc
                    policy_manager/real_random_provider.cc
                    policy_manager/real_shill_provider.cc
                    policy_manager/real_system_provider.cc
@@ -299,6 +300,7 @@
                             policy_manager/fake_state.cc
                             policy_manager/generic_variables_unittest.cc
                             policy_manager/policy_manager_unittest.cc
+                            policy_manager/real_device_policy_provider_unittest.cc
                             policy_manager/real_random_provider_unittest.cc
                             policy_manager/real_shill_provider_unittest.cc
                             policy_manager/real_system_provider_unittest.cc
diff --git a/policy_manager/device_policy_provider.h b/policy_manager/device_policy_provider.h
new file mode 100644
index 0000000..24a3f1f
--- /dev/null
+++ b/policy_manager/device_policy_provider.h
@@ -0,0 +1,62 @@
+// Copyright (c) 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 CHROMEOS_PLATFORM_UPDATE_ENGINE_POLICY_MANAGER_DEVICE_POLICY_PROVIDER_H_
+#define CHROMEOS_PLATFORM_UPDATE_ENGINE_POLICY_MANAGER_DEVICE_POLICY_PROVIDER_H_
+
+#include <set>
+#include <string>
+
+#include <policy/libpolicy.h>
+#include <base/time/time.h>
+
+#include "update_engine/policy_manager/provider.h"
+#include "update_engine/policy_manager/shill_provider.h"
+#include "update_engine/policy_manager/variable.h"
+
+namespace chromeos_policy_manager {
+
+// Provides access to the current DevicePolicy.
+class DevicePolicyProvider : public Provider {
+ public:
+  virtual ~DevicePolicyProvider() {}
+
+  // Variable stating whether the DevicePolicy was loaded.
+  virtual Variable<bool>* var_device_policy_is_loaded() = 0;
+
+  // Variables mapping the information received on the DevicePolicy protobuf.
+  virtual Variable<std::string>* var_release_channel() = 0;
+
+  virtual Variable<bool>* var_release_channel_delegated() = 0;
+
+  virtual Variable<bool>* var_update_disabled() = 0;
+
+  virtual Variable<std::string>* var_target_version_prefix() = 0;
+
+  virtual Variable<base::TimeDelta>* var_scatter_factor() = 0;
+
+  // Variable returing the set of connection types allowed for updates. The
+  // identifiers returned are consistent with the ones returned by the
+  // ShillProvider.
+  virtual Variable<std::set<ConnectionType>>*
+      var_allowed_connection_types_for_update() = 0;
+
+  // Variable stating the name of the device owner. For enterprise enrolled
+  // devices, this will be an empty string.
+  virtual Variable<std::string>* var_get_owner() = 0;
+
+  virtual Variable<bool>* var_http_downloads_enabled() = 0;
+
+  virtual Variable<bool>* var_au_p2p_enabled() = 0;
+
+ protected:
+  DevicePolicyProvider() {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(DevicePolicyProvider);
+};
+
+}  // namespace chromeos_policy_manager
+
+#endif  // CHROMEOS_PLATFORM_UPDATE_ENGINE_POLICY_MANAGER_DEVICE_POLICY_PROVIDER_H_
diff --git a/policy_manager/fake_device_policy_provider.h b/policy_manager/fake_device_policy_provider.h
new file mode 100644
index 0000000..4863ae5
--- /dev/null
+++ b/policy_manager/fake_device_policy_provider.h
@@ -0,0 +1,92 @@
+// Copyright (c) 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 CHROMEOS_PLATFORM_UPDATE_ENGINE_POLICY_MANAGER_FAKE_DEVICE_POLICY_PROVIDER_H_
+#define CHROMEOS_PLATFORM_UPDATE_ENGINE_POLICY_MANAGER_FAKE_DEVICE_POLICY_PROVIDER_H_
+
+#include <set>
+#include <string>
+
+#include "update_engine/policy_manager/device_policy_provider.h"
+#include "update_engine/policy_manager/fake_variable.h"
+
+namespace chromeos_policy_manager {
+
+// Fake implementation of the DevicePolicyProvider base class.
+class FakeDevicePolicyProvider : public DevicePolicyProvider {
+ public:
+  FakeDevicePolicyProvider() {}
+
+  virtual FakeVariable<bool>* var_device_policy_is_loaded() override {
+    return &var_device_policy_is_loaded_;
+  }
+
+  virtual FakeVariable<std::string>* var_release_channel() override {
+    return &var_release_channel_;
+  }
+
+  virtual FakeVariable<bool>* var_release_channel_delegated() override {
+    return &var_release_channel_delegated_;
+  }
+
+  virtual FakeVariable<bool>* var_update_disabled() override {
+    return &var_update_disabled_;
+  }
+
+  virtual FakeVariable<std::string>* var_target_version_prefix() override {
+    return &var_target_version_prefix_;
+  }
+
+  virtual FakeVariable<base::TimeDelta>* var_scatter_factor() override {
+    return &var_scatter_factor_;
+  }
+
+  virtual FakeVariable<std::set<ConnectionType>>*
+      var_allowed_connection_types_for_update() override {
+    return &var_allowed_connection_types_for_update_;
+  }
+
+  virtual FakeVariable<std::string>* var_get_owner() override {
+    return &var_get_owner_;
+  }
+
+  virtual FakeVariable<bool>* var_http_downloads_enabled() override {
+    return &var_http_downloads_enabled_;
+  }
+
+  virtual FakeVariable<bool>* var_au_p2p_enabled() override {
+    return &var_au_p2p_enabled_;
+  }
+
+ private:
+  virtual bool DoInit() override {
+    return true;
+  }
+
+  FakeVariable<bool> var_device_policy_is_loaded_{
+      "policy_is_loaded", kVariableModePoll};
+  FakeVariable<std::string> var_release_channel_{
+      "release_channel", kVariableModePoll};
+  FakeVariable<bool> var_release_channel_delegated_{
+      "release_channel_delegated", kVariableModePoll};
+  FakeVariable<bool> var_update_disabled_{
+      "update_disabled", kVariableModePoll};
+  FakeVariable<std::string> var_target_version_prefix_{
+      "target_version_prefix", kVariableModePoll};
+  FakeVariable<base::TimeDelta> var_scatter_factor_{
+      "scatter_factor", kVariableModePoll};
+  FakeVariable<std::set<ConnectionType>>
+      var_allowed_connection_types_for_update_{
+          "allowed_connection_types_for_update", kVariableModePoll};
+  FakeVariable<std::string> var_get_owner_{"get_owner", kVariableModePoll};
+  FakeVariable<bool> var_http_downloads_enabled_{
+      "http_downloads_enabled", kVariableModePoll};
+  FakeVariable<bool> var_au_p2p_enabled_{"au_p2p_enabled", kVariableModePoll};
+
+  DISALLOW_COPY_AND_ASSIGN(FakeDevicePolicyProvider);
+};
+
+}  // namespace chromeos_policy_manager
+
+#endif  // CHROMEOS_PLATFORM_UPDATE_ENGINE_POLICY_MANAGER_FAKE_DEVICE_POLICY_PROVIDER_H_
diff --git a/policy_manager/fake_state.cc b/policy_manager/fake_state.cc
index 0f0b5f1..2af8de0 100644
--- a/policy_manager/fake_state.cc
+++ b/policy_manager/fake_state.cc
@@ -8,7 +8,8 @@
 
 namespace chromeos_policy_manager {
 
-FakeState::FakeState() : State(new FakeRandomProvider(),
+FakeState::FakeState() : State(new FakeDevicePolicyProvider(),
+                               new FakeRandomProvider(),
                                new FakeShillProvider(),
                                new FakeSystemProvider(),
                                new FakeTimeProvider(),
@@ -17,7 +18,8 @@
 
 FakeState* FakeState::Construct() {
   scoped_ptr<FakeState> fake_state(new FakeState());
-  if (!(fake_state->random_provider()->Init() &&
+  if (!(fake_state->device_policy_provider()->Init() &&
+        fake_state->random_provider()->Init() &&
         fake_state->shill_provider()->Init() &&
         fake_state->system_provider()->Init() &&
         fake_state->time_provider()->Init() &&
diff --git a/policy_manager/fake_state.h b/policy_manager/fake_state.h
index 4e4ead6..edad4aa 100644
--- a/policy_manager/fake_state.h
+++ b/policy_manager/fake_state.h
@@ -5,6 +5,7 @@
 #ifndef CHROMEOS_PLATFORM_UPDATE_ENGINE_POLICY_MANAGER_FAKE_STATE_H_
 #define CHROMEOS_PLATFORM_UPDATE_ENGINE_POLICY_MANAGER_FAKE_STATE_H_
 
+#include "update_engine/policy_manager/fake_device_policy_provider.h"
 #include "update_engine/policy_manager/fake_random_provider.h"
 #include "update_engine/policy_manager/fake_shill_provider.h"
 #include "update_engine/policy_manager/fake_system_provider.h"
@@ -24,6 +25,10 @@
   virtual ~FakeState() {}
 
   // Downcasted getters, to allow access to the fake instances during testing.
+  virtual FakeDevicePolicyProvider* device_policy_provider() override {
+    return reinterpret_cast<FakeDevicePolicyProvider*>(
+        State::device_policy_provider());
+  }
   virtual FakeRandomProvider* random_provider() override {
     return reinterpret_cast<FakeRandomProvider*>(State::random_provider());
   }
diff --git a/policy_manager/generic_variables.h b/policy_manager/generic_variables.h
index 261b96c..9110c9a 100644
--- a/policy_manager/generic_variables.h
+++ b/policy_manager/generic_variables.h
@@ -123,6 +123,63 @@
   const T obj_;
 };
 
+// A Variable class to implement simple Async variables. It provides two methods
+// SetValue and UnsetValue to modify the current value of the variable and
+// notify the registered observers whenever the value changed.
+//
+// The type T needs to be copy-constructable, default-constructable and have an
+// operator== (to determine if the value changed), which makes this class
+// suitable for basic types.
+template<typename T>
+class AsyncCopyVariable : public Variable<T> {
+ public:
+  explicit AsyncCopyVariable(const std::string& name)
+      : Variable<T>(name, kVariableModeAsync), has_value_(false) {}
+
+  AsyncCopyVariable(const std::string& name, const T value)
+      : Variable<T>(name, kVariableModeAsync),
+        has_value_(true), value_(value) {}
+
+  void SetValue(const T& new_value) {
+    bool should_notify = !(has_value_ && new_value == value_);
+    value_ = new_value;
+    has_value_ = true;
+    if (should_notify)
+      this->NotifyValueChanged();
+  }
+
+  void UnsetValue() {
+    if (has_value_) {
+      has_value_ = false;
+      this->NotifyValueChanged();
+    }
+  }
+
+ protected:
+  friend class PmAsyncCopyVariableTest;
+  FRIEND_TEST(PmAsyncCopyVariableTest, ConstructorTest);
+  FRIEND_TEST(PmAsyncCopyVariableTest, SetValueTest);
+  FRIEND_TEST(PmAsyncCopyVariableTest, UnsetValueTest);
+
+  // Variable override.
+  virtual const T* GetValue(base::TimeDelta /* timeout */,
+                            std::string* errmsg) {
+    if (!has_value_) {
+      if (errmsg)
+        *errmsg = "No value set for " + this->GetName();
+      return nullptr;
+    }
+    return new T(value_);
+  }
+
+ private:
+  // Whether the variable has a value set.
+  bool has_value_;
+
+  // Copy of the object to be returned by GetValue().
+  T value_;
+};
+
 }  // namespace chromeos_policy_manager
 
 #endif  // CHROMEOS_PLATFORM_UPDATE_ENGINE_POLICY_MANAGER_GENERIC_VARIABLES_H_
diff --git a/policy_manager/generic_variables_unittest.cc b/policy_manager/generic_variables_unittest.cc
index 7783e9f..490f949 100644
--- a/policy_manager/generic_variables_unittest.cc
+++ b/policy_manager/generic_variables_unittest.cc
@@ -8,8 +8,10 @@
 #include <gtest/gtest.h>
 
 #include "update_engine/policy_manager/pmtest_utils.h"
+#include "update_engine/test_utils.h"
 
 using base::TimeDelta;
+using chromeos_update_engine::RunGMainLoopMaxIterations;
 
 namespace chromeos_policy_manager {
 
@@ -101,4 +103,78 @@
   EXPECT_EQ(5, *copy);
 }
 
+
+class PmAsyncCopyVariableTest : public ::testing::Test {
+ public:
+  void TearDown() {
+    // No remaining event on the main loop.
+    EXPECT_EQ(0, RunGMainLoopMaxIterations(1));
+  }
+
+ protected:
+  TimeDelta default_timeout_ = TimeDelta::FromSeconds(1);
+};
+
+TEST_F(PmAsyncCopyVariableTest, ConstructorTest) {
+  AsyncCopyVariable<int> var("var");
+  PMTEST_EXPECT_NULL(var.GetValue(default_timeout_, NULL));
+  EXPECT_EQ(kVariableModeAsync, var.GetMode());
+}
+
+TEST_F(PmAsyncCopyVariableTest, SetValueTest) {
+  AsyncCopyVariable<int> var("var");
+  var.SetValue(5);
+  scoped_ptr<const int> copy(var.GetValue(default_timeout_, NULL));
+  PMTEST_ASSERT_NOT_NULL(copy.get());
+  EXPECT_EQ(5, *copy);
+  // Execute all the pending observers.
+  RunGMainLoopMaxIterations(100);
+}
+
+TEST_F(PmAsyncCopyVariableTest, UnsetValueTest) {
+  AsyncCopyVariable<int> var("var", 42);
+  var.UnsetValue();
+  PMTEST_EXPECT_NULL(var.GetValue(default_timeout_, NULL));
+  // Execute all the pending observers.
+  RunGMainLoopMaxIterations(100);
+}
+
+class CallCounterObserver : public BaseVariable::ObserverInterface {
+ public:
+  void ValueChanged(BaseVariable* variable) {
+    calls_count_++;
+  }
+
+  int calls_count_ = 0;
+};
+
+TEST_F(PmAsyncCopyVariableTest, ObserverCalledTest) {
+  AsyncCopyVariable<int> var("var", 42);
+  CallCounterObserver observer;
+  var.AddObserver(&observer);
+  EXPECT_EQ(0, observer.calls_count_);
+
+  // Check that a different value fires the notification.
+  var.SetValue(5);
+  RunGMainLoopMaxIterations(100);
+  EXPECT_EQ(1, observer.calls_count_);
+
+  // Check the same value doesn't.
+  var.SetValue(5);
+  RunGMainLoopMaxIterations(100);
+  EXPECT_EQ(1, observer.calls_count_);
+
+  // Check that unsetting a previously set value fires the notification.
+  var.UnsetValue();
+  RunGMainLoopMaxIterations(100);
+  EXPECT_EQ(2, observer.calls_count_);
+
+  // Check that unsetting again doesn't.
+  var.UnsetValue();
+  RunGMainLoopMaxIterations(100);
+  EXPECT_EQ(2, observer.calls_count_);
+
+  var.RemoveObserver(&observer);
+}
+
 }  // namespace chromeos_policy_manager
diff --git a/policy_manager/real_device_policy_provider.cc b/policy_manager/real_device_policy_provider.cc
new file mode 100644
index 0000000..4e192a0
--- /dev/null
+++ b/policy_manager/real_device_policy_provider.cc
@@ -0,0 +1,135 @@
+// Copyright (c) 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 "update_engine/policy_manager/real_device_policy_provider.h"
+
+#include <base/logging.h>
+#include <base/time/time.h>
+#include <policy/device_policy.h>
+
+#include "update_engine/policy_manager/generic_variables.h"
+#include "update_engine/policy_manager/real_shill_provider.h"
+#include "update_engine/utils.h"
+
+using base::TimeDelta;
+using policy::DevicePolicy;
+using std::set;
+using std::string;
+
+namespace {
+
+const int kDevicePolicyRefreshRateInMinutes = 60;
+
+}  // namespace
+
+namespace chromeos_policy_manager {
+
+RealDevicePolicyProvider::~RealDevicePolicyProvider() {
+  CancelMainLoopEvent(scheduled_refresh_);
+}
+
+bool RealDevicePolicyProvider::DoInit() {
+  CHECK(policy_provider_ != nullptr);
+
+  // On Init() we try to get the device policy and keep updating it.
+  RefreshDevicePolicyAndReschedule();
+
+  return true;
+}
+
+void RealDevicePolicyProvider::RefreshDevicePolicyAndReschedule() {
+  RefreshDevicePolicy();
+  scheduled_refresh_ = RunFromMainLoopAfterTimeout(
+      base::Bind(&RealDevicePolicyProvider::RefreshDevicePolicyAndReschedule,
+                 base::Unretained(this)),
+      TimeDelta::FromMinutes(kDevicePolicyRefreshRateInMinutes));
+}
+
+template<typename T>
+void RealDevicePolicyProvider::UpdateVariable(
+    AsyncCopyVariable<T>* var,
+    bool (policy::DevicePolicy::*getter_method)(T*) const) {
+  T new_value;
+  if (policy_provider_->device_policy_is_loaded() &&
+      (policy_provider_->GetDevicePolicy().*getter_method)(&new_value)) {
+    var->SetValue(new_value);
+  } else {
+    var->UnsetValue();
+  }
+}
+
+template<typename T>
+void RealDevicePolicyProvider::UpdateVariable(
+    AsyncCopyVariable<T>* var,
+    bool (RealDevicePolicyProvider::*getter_method)(T*) const) {
+  T new_value;
+  if (policy_provider_->device_policy_is_loaded() &&
+      (this->*getter_method)(&new_value)) {
+    var->SetValue(new_value);
+  } else {
+    var->UnsetValue();
+  }
+}
+
+bool RealDevicePolicyProvider::ConvertAllowedConnectionTypesForUpdate(
+      set<ConnectionType>* allowed_types) const {
+  set<string> allowed_types_str;
+  if (!policy_provider_->GetDevicePolicy()
+      .GetAllowedConnectionTypesForUpdate(&allowed_types_str)) {
+    return false;
+  }
+  allowed_types->clear();
+  for (auto& type_str : allowed_types_str) {
+    ConnectionType type = ShillConnector::ParseConnectionType(type_str.c_str());
+    if (type != ConnectionType::kUnknown) {
+      allowed_types->insert(type);
+    } else {
+      LOG(WARNING) << "Policy includes unknown connection type: " << type_str;
+    }
+  }
+  return true;
+}
+
+bool RealDevicePolicyProvider::ConvertScatterFactor(
+    base::TimeDelta* scatter_factor) const {
+  int64 scatter_factor_in_seconds;
+  if (!policy_provider_->GetDevicePolicy().GetScatterFactorInSeconds(
+      &scatter_factor_in_seconds)) {
+    return false;
+  }
+  if (scatter_factor_in_seconds < 0) {
+    LOG(WARNING) << "Ignoring negative scatter factor: "
+                 << scatter_factor_in_seconds;
+    return false;
+  }
+  *scatter_factor = base::TimeDelta::FromSeconds(scatter_factor_in_seconds);
+  return true;
+}
+
+void RealDevicePolicyProvider::RefreshDevicePolicy() {
+  if (!policy_provider_->Reload()) {
+    LOG(INFO) << "No device policies/settings present.";
+  }
+
+  var_device_policy_is_loaded_.SetValue(
+      policy_provider_->device_policy_is_loaded());
+
+  UpdateVariable(&var_release_channel_, &DevicePolicy::GetReleaseChannel);
+  UpdateVariable(&var_release_channel_delegated_,
+                 &DevicePolicy::GetReleaseChannelDelegated);
+  UpdateVariable(&var_update_disabled_, &DevicePolicy::GetUpdateDisabled);
+  UpdateVariable(&var_target_version_prefix_,
+                 &DevicePolicy::GetTargetVersionPrefix);
+  UpdateVariable(&var_scatter_factor_,
+                 &RealDevicePolicyProvider::ConvertScatterFactor);
+  UpdateVariable(
+      &var_allowed_connection_types_for_update_,
+      &RealDevicePolicyProvider::ConvertAllowedConnectionTypesForUpdate);
+  UpdateVariable(&var_get_owner_, &DevicePolicy::GetOwner);
+  UpdateVariable(&var_http_downloads_enabled_,
+                 &DevicePolicy::GetHttpDownloadsEnabled);
+  UpdateVariable(&var_au_p2p_enabled_, &DevicePolicy::GetAuP2PEnabled);
+}
+
+}  // namespace chromeos_policy_manager
diff --git a/policy_manager/real_device_policy_provider.h b/policy_manager/real_device_policy_provider.h
new file mode 100644
index 0000000..cb0eb2b
--- /dev/null
+++ b/policy_manager/real_device_policy_provider.h
@@ -0,0 +1,136 @@
+// Copyright (c) 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 CHROMEOS_PLATFORM_UPDATE_ENGINE_POLICY_MANAGER_REAL_DEVICE_POLICY_PROVIDER_H_
+#define CHROMEOS_PLATFORM_UPDATE_ENGINE_POLICY_MANAGER_REAL_DEVICE_POLICY_PROVIDER_H_
+
+#include <set>
+#include <string>
+
+#include <gtest/gtest_prod.h>  // for FRIEND_TEST
+#include <policy/libpolicy.h>
+
+#include "update_engine/policy_manager/device_policy_provider.h"
+#include "update_engine/policy_manager/event_loop.h"
+#include "update_engine/policy_manager/generic_variables.h"
+
+namespace chromeos_policy_manager {
+
+// DevicePolicyProvider concrete implementation.
+class RealDevicePolicyProvider : public DevicePolicyProvider {
+ public:
+  explicit RealDevicePolicyProvider(policy::PolicyProvider* policy_provider)
+      : policy_provider_(policy_provider) {}
+  ~RealDevicePolicyProvider();
+
+  virtual Variable<bool>* var_device_policy_is_loaded() override {
+    return &var_device_policy_is_loaded_;
+  }
+
+  virtual Variable<std::string>* var_release_channel() override {
+    return &var_release_channel_;
+  }
+
+  virtual Variable<bool>* var_release_channel_delegated() override {
+    return &var_release_channel_delegated_;
+  }
+
+  virtual Variable<bool>* var_update_disabled() override {
+    return &var_update_disabled_;
+  }
+
+  virtual Variable<std::string>* var_target_version_prefix() override {
+    return &var_target_version_prefix_;
+  }
+
+  virtual Variable<base::TimeDelta>* var_scatter_factor() override {
+    return &var_scatter_factor_;
+  }
+
+  virtual Variable<std::set<ConnectionType>>*
+      var_allowed_connection_types_for_update() override {
+    return &var_allowed_connection_types_for_update_;
+  }
+
+  virtual Variable<std::string>* var_get_owner() override {
+    return &var_get_owner_;
+  }
+
+  virtual Variable<bool>* var_http_downloads_enabled() override {
+    return &var_http_downloads_enabled_;
+  }
+
+  virtual Variable<bool>* var_au_p2p_enabled() override {
+    return &var_au_p2p_enabled_;
+  }
+
+ private:
+  friend class PmRealDevicePolicyProviderTest;
+  FRIEND_TEST(PmRealDevicePolicyProviderTest, RefreshScheduledTest);
+  FRIEND_TEST(PmRealDevicePolicyProviderTest, NonExistentDevicePolicyReloaded);
+  FRIEND_TEST(PmRealDevicePolicyProviderTest, ValuesUpdated);
+
+  // Provider override.
+  bool DoInit() override;
+
+  // Schedules a call to periodically refresh the device policy.
+  void RefreshDevicePolicyAndReschedule();
+
+  // Reloads the device policy and updates all the exposed variables.
+  void RefreshDevicePolicy();
+
+  // Updates the async variable |var| based on the result value of the method
+  // passed, which is a DevicePolicy getter method.
+  template<typename T>
+  void UpdateVariable(AsyncCopyVariable<T>* var,
+                      bool (policy::DevicePolicy::*getter_method)(T*) const);
+
+  // Updates the async variable |var| based on the result value of the getter
+  // method passed, which is a wrapper getter on this class.
+  template<typename T>
+  void UpdateVariable(
+      AsyncCopyVariable<T>* var,
+      bool (RealDevicePolicyProvider::*getter_method)(T*) const);
+
+  // Wrapper for DevicePolicy::GetScatterFactorInSeconds() that converts the
+  // result to a base::TimeDelta. It returns the same value as
+  // GetScatterFactorInSeconds().
+  bool ConvertScatterFactor(base::TimeDelta* scatter_factor) const;
+
+  // Wrapper for DevicePolicy::GetAllowedConnectionTypesForUpdate() that
+  // converts the result to a set of ConnectionType elements instead of strings.
+  bool ConvertAllowedConnectionTypesForUpdate(
+      std::set<ConnectionType>* allowed_types) const;
+
+  // Used for fetching information about the device policy.
+  policy::PolicyProvider* policy_provider_;
+
+  // Used to schedule refreshes of the device policy.
+  EventId scheduled_refresh_ = kEventIdNull;
+
+  // Variable exposing whether the policy is loaded.
+  AsyncCopyVariable<bool> var_device_policy_is_loaded_{
+      "policy_is_loaded", false};
+
+  // Variables mapping the exposed methods from the policy::DevicePolicy.
+  AsyncCopyVariable<std::string> var_release_channel_{"release_channel"};
+  AsyncCopyVariable<bool> var_release_channel_delegated_{
+      "release_channel_delegated"};
+  AsyncCopyVariable<bool> var_update_disabled_{"update_disabled"};
+  AsyncCopyVariable<std::string> var_target_version_prefix_{
+      "target_version_prefix"};
+  AsyncCopyVariable<base::TimeDelta> var_scatter_factor_{"scatter_factor"};
+  AsyncCopyVariable<std::set<ConnectionType>>
+      var_allowed_connection_types_for_update_{
+          "allowed_connection_types_for_update"};
+  AsyncCopyVariable<std::string> var_get_owner_{"get_owner"};
+  AsyncCopyVariable<bool> var_http_downloads_enabled_{"http_downloads_enabled"};
+  AsyncCopyVariable<bool> var_au_p2p_enabled_{"au_p2p_enabled"};
+
+  DISALLOW_COPY_AND_ASSIGN(RealDevicePolicyProvider);
+};
+
+}  // namespace chromeos_policy_manager
+
+#endif  // CHROMEOS_PLATFORM_UPDATE_ENGINE_POLICY_MANAGER_REAL_DEVICE_POLICY_PROVIDER_H_
diff --git a/policy_manager/real_device_policy_provider_unittest.cc b/policy_manager/real_device_policy_provider_unittest.cc
new file mode 100644
index 0000000..2d14bbc
--- /dev/null
+++ b/policy_manager/real_device_policy_provider_unittest.cc
@@ -0,0 +1,176 @@
+// Copyright (c) 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 "update_engine/policy_manager/real_device_policy_provider.h"
+
+#include <base/memory/scoped_ptr.h>
+#include <gtest/gtest.h>
+#include <policy/mock_device_policy.h>
+#include <policy/mock_libpolicy.h>
+
+#include "update_engine/policy_manager/pmtest_utils.h"
+#include "update_engine/test_utils.h"
+
+using base::TimeDelta;
+using chromeos_update_engine::RunGMainLoopMaxIterations;
+using std::set;
+using std::string;
+using testing::AtLeast;
+using testing::DoAll;
+using testing::Mock;
+using testing::Return;
+using testing::ReturnRef;
+using testing::SetArgumentPointee;
+using testing::_;
+
+namespace chromeos_policy_manager {
+
+class PmRealDevicePolicyProviderTest : public ::testing::Test {
+ protected:
+  virtual void SetUp() {
+    provider_.reset(new RealDevicePolicyProvider(&mock_policy_provider_));
+    // By default, we have a device policy loaded. Tests can call
+    // SetUpNonExistentDevicePolicy() to override this.
+    SetUpExistentDevicePolicy();
+  }
+
+  virtual void TearDown() {
+    // Check for leaked callbacks on the main loop.
+    EXPECT_EQ(0, RunGMainLoopMaxIterations(100));
+  }
+
+  void SetUpNonExistentDevicePolicy() {
+    ON_CALL(mock_policy_provider_, Reload())
+        .WillByDefault(Return(false));
+    ON_CALL(mock_policy_provider_, device_policy_is_loaded())
+        .WillByDefault(Return(false));
+    EXPECT_CALL(mock_policy_provider_, GetDevicePolicy()).Times(0);
+  }
+
+  void SetUpExistentDevicePolicy() {
+    // Setup the default behavior of the mocked PolicyProvider.
+    ON_CALL(mock_policy_provider_, Reload())
+        .WillByDefault(Return(true));
+    ON_CALL(mock_policy_provider_, device_policy_is_loaded())
+        .WillByDefault(Return(true));
+    ON_CALL(mock_policy_provider_, GetDevicePolicy())
+        .WillByDefault(ReturnRef(mock_device_policy_));
+  }
+
+  // Calls GetValue and expects its result to be the passed one.
+  template<typename T>
+  void ExpectVariableValue(const T& expected, Variable<T>* variable) {
+    scoped_ptr<const T> value(variable->GetValue(default_timeout_, nullptr));
+    PMTEST_ASSERT_NOT_NULL(value.get()) << "Variable: " << variable->GetName();
+    EXPECT_EQ(expected, *value) << "Variable: " << variable->GetName();
+  }
+
+  // Calls GetValue and expects its result to be NULL.
+  template<typename T>
+  void ExpectVariableNotSet(Variable<T>* variable) {
+    scoped_ptr<const T> value(variable->GetValue(default_timeout_, nullptr));
+    PMTEST_EXPECT_NULL(value.get()) << "Variable: " << variable->GetName();
+  }
+
+  TimeDelta default_timeout_ = TimeDelta::FromSeconds(1);
+  testing::NiceMock<policy::MockDevicePolicy> mock_device_policy_;
+  testing::NiceMock<policy::MockPolicyProvider> mock_policy_provider_;
+  scoped_ptr<RealDevicePolicyProvider> provider_;
+};
+
+TEST_F(PmRealDevicePolicyProviderTest, RefreshScheduledTest) {
+  // Check that the RefreshPolicy gets scheduled by checking the EventId.
+  EXPECT_TRUE(provider_->Init());
+  EXPECT_NE(kEventIdNull, provider_->scheduled_refresh_);
+}
+
+TEST_F(PmRealDevicePolicyProviderTest, FirstReload) {
+  // Checks that the policy is reloaded and the DevicePolicy is consulted.
+  EXPECT_CALL(mock_policy_provider_, Reload());
+  EXPECT_TRUE(provider_->Init());
+}
+
+TEST_F(PmRealDevicePolicyProviderTest, NonExistentDevicePolicyReloaded) {
+  // Checks that the policy is reloaded by RefreshDevicePolicy().
+  SetUpNonExistentDevicePolicy();
+  EXPECT_CALL(mock_policy_provider_, Reload()).Times(2);
+  EXPECT_TRUE(provider_->Init());
+  // Force the policy refresh.
+  provider_->RefreshDevicePolicy();
+}
+
+TEST_F(PmRealDevicePolicyProviderTest, NonExistentDevicePolicyEmptyVariables) {
+  SetUpNonExistentDevicePolicy();
+  EXPECT_CALL(mock_policy_provider_, GetDevicePolicy()).Times(0);
+  EXPECT_TRUE(provider_->Init());
+
+  ExpectVariableValue(false, provider_->var_device_policy_is_loaded());
+
+  ExpectVariableNotSet(provider_->var_release_channel());
+  ExpectVariableNotSet(provider_->var_release_channel_delegated());
+  ExpectVariableNotSet(provider_->var_update_disabled());
+  ExpectVariableNotSet(provider_->var_target_version_prefix());
+  ExpectVariableNotSet(provider_->var_scatter_factor());
+  ExpectVariableNotSet(provider_->var_allowed_connection_types_for_update());
+  ExpectVariableNotSet(provider_->var_get_owner());
+  ExpectVariableNotSet(provider_->var_http_downloads_enabled());
+  ExpectVariableNotSet(provider_->var_au_p2p_enabled());
+}
+
+TEST_F(PmRealDevicePolicyProviderTest, ValuesUpdated) {
+  SetUpNonExistentDevicePolicy();
+  EXPECT_TRUE(provider_->Init());
+  Mock::VerifyAndClearExpectations(&mock_policy_provider_);
+
+  // Reload the policy with a good one and set some values as present. The
+  // remaining values are false.
+  SetUpExistentDevicePolicy();
+  EXPECT_CALL(mock_device_policy_, GetReleaseChannel(_))
+      .WillOnce(DoAll(SetArgumentPointee<0>(string("mychannel")),
+                      Return(true)));
+  EXPECT_CALL(mock_device_policy_, GetAllowedConnectionTypesForUpdate(_))
+      .WillOnce(Return(false));
+
+  provider_->RefreshDevicePolicy();
+
+  ExpectVariableValue(true, provider_->var_device_policy_is_loaded());
+
+  // Test that at least one variable is set, to ensure the refresh ocurred.
+  ExpectVariableValue(string("mychannel"), provider_->var_release_channel());
+  ExpectVariableNotSet(provider_->var_allowed_connection_types_for_update());
+}
+
+TEST_F(PmRealDevicePolicyProviderTest, ScatterFactorConverted) {
+  SetUpExistentDevicePolicy();
+  EXPECT_CALL(mock_device_policy_, GetScatterFactorInSeconds(_))
+      .WillOnce(DoAll(SetArgumentPointee<0>(1234), Return(true)));
+  EXPECT_TRUE(provider_->Init());
+
+  ExpectVariableValue(base::TimeDelta::FromSeconds(1234),
+                      provider_->var_scatter_factor());
+}
+
+TEST_F(PmRealDevicePolicyProviderTest, NegativeScatterFactorIgnored) {
+  SetUpExistentDevicePolicy();
+  EXPECT_CALL(mock_device_policy_, GetScatterFactorInSeconds(_))
+      .WillOnce(DoAll(SetArgumentPointee<0>(-1), Return(true)));
+  EXPECT_TRUE(provider_->Init());
+
+  ExpectVariableNotSet(provider_->var_scatter_factor());
+}
+
+TEST_F(PmRealDevicePolicyProviderTest, AllowedTypesConverted) {
+  SetUpExistentDevicePolicy();
+  EXPECT_CALL(mock_device_policy_, GetAllowedConnectionTypesForUpdate(_))
+      .WillOnce(DoAll(SetArgumentPointee<0>(
+                          set<string>{"bluetooth", "wifi", "not-a-type"}),
+                      Return(true)));
+  EXPECT_TRUE(provider_->Init());
+
+  ExpectVariableValue(set<ConnectionType>{ConnectionType::kWifi,
+                                          ConnectionType::kBluetooth},
+                      provider_->var_allowed_connection_types_for_update());
+}
+
+}  // namespace chromeos_policy_manager
diff --git a/policy_manager/real_shill_provider.cc b/policy_manager/real_shill_provider.cc
index a503bc2..03e7f18 100644
--- a/policy_manager/real_shill_provider.cc
+++ b/policy_manager/real_shill_provider.cc
@@ -94,7 +94,7 @@
     }
     if (type_str) {
       success = true;
-      *conn_type_p = ParseConnType(type_str);
+      *conn_type_p = ParseConnectionType(type_str);
     }
     g_hash_table_unref(hash_table);
   }
@@ -114,7 +114,7 @@
                                 path, interface);
 }
 
-ConnectionType ShillConnector::ParseConnType(const char* str) {
+ConnectionType ShillConnector::ParseConnectionType(const char* str) {
   for (unsigned i = 0; i < arraysize(shill_conn_str_to_type); i++)
     if (!strcmp(str, shill_conn_str_to_type[i].str))
       return shill_conn_str_to_type[i].type;
diff --git a/policy_manager/real_shill_provider.h b/policy_manager/real_shill_provider.h
index a0619e2..13f0fe4 100644
--- a/policy_manager/real_shill_provider.h
+++ b/policy_manager/real_shill_provider.h
@@ -51,6 +51,9 @@
     return GetProperties(manager_proxy_, result_p);
   }
 
+  // Converts a shill connection type string into a symbolic value.
+  static ConnectionType ParseConnectionType(const char* str);
+
  private:
   // Issues a GetProperties call through a given |proxy|, storing the result to
   // |*result_p|. Returns |true| on success.
@@ -79,9 +82,6 @@
   // Return a DBus proxy for a given |path| and |interface| within shill.
   DBusGProxy* GetProxy(const char* path, const char* interface);
 
-  // Converts a shill connection type string into a symbolic value.
-  ConnectionType ParseConnType(const char* str);
-
   DISALLOW_COPY_AND_ASSIGN(ShillConnector);
 };
 
diff --git a/policy_manager/state.h b/policy_manager/state.h
index 09f1b3d..b81a88e 100644
--- a/policy_manager/state.h
+++ b/policy_manager/state.h
@@ -5,6 +5,7 @@
 #ifndef CHROMEOS_PLATFORM_UPDATE_ENGINE_POLICY_MANAGER_STATE_H_
 #define CHROMEOS_PLATFORM_UPDATE_ENGINE_POLICY_MANAGER_STATE_H_
 
+#include "update_engine/policy_manager/device_policy_provider.h"
 #include "update_engine/policy_manager/random_provider.h"
 #include "update_engine/policy_manager/shill_provider.h"
 #include "update_engine/policy_manager/system_provider.h"
@@ -18,9 +19,11 @@
 class State {
  public:
   virtual ~State() {}
-  State(RandomProvider* random_provider, ShillProvider* shill_provider,
+  State(DevicePolicyProvider* device_policy_provider,
+        RandomProvider* random_provider, ShillProvider* shill_provider,
         SystemProvider* system_provider, TimeProvider* time_provider,
         UpdaterProvider* updater_provider) :
+      device_policy_provider_(device_policy_provider),
       random_provider_(random_provider),
       shill_provider_(shill_provider),
       system_provider_(system_provider),
@@ -28,6 +31,9 @@
       updater_provider_(updater_provider) {}
 
   // These methods return the given provider.
+  virtual DevicePolicyProvider* device_policy_provider() {
+    return device_policy_provider_.get();
+  }
   virtual RandomProvider* random_provider() { return random_provider_.get(); }
   virtual ShillProvider* shill_provider() { return shill_provider_.get(); }
   virtual SystemProvider* system_provider() { return system_provider_.get(); }
@@ -38,6 +44,7 @@
 
  private:
   // Instances of the providers.
+  scoped_ptr<DevicePolicyProvider> device_policy_provider_;
   scoped_ptr<RandomProvider> random_provider_;
   scoped_ptr<ShillProvider> shill_provider_;
   scoped_ptr<SystemProvider> system_provider_;
diff --git a/policy_manager/state_factory.cc b/policy_manager/state_factory.cc
index a5f0df9..b5bfb7f 100644
--- a/policy_manager/state_factory.cc
+++ b/policy_manager/state_factory.cc
@@ -7,6 +7,7 @@
 #include <base/logging.h>
 
 #include "update_engine/clock_interface.h"
+#include "update_engine/policy_manager/real_device_policy_provider.h"
 #include "update_engine/policy_manager/real_random_provider.h"
 #include "update_engine/policy_manager/real_shill_provider.h"
 #include "update_engine/policy_manager/real_system_provider.h"
@@ -15,9 +16,12 @@
 
 namespace chromeos_policy_manager {
 
-State* DefaultStateFactory(chromeos_update_engine::DBusWrapperInterface* dbus,
+State* DefaultStateFactory(policy::PolicyProvider* policy_provider,
+                           chromeos_update_engine::DBusWrapperInterface* dbus,
                            chromeos_update_engine::SystemState* system_state) {
   chromeos_update_engine::ClockInterface* const clock = system_state->clock();
+  scoped_ptr<RealDevicePolicyProvider> device_policy_provider(
+      new RealDevicePolicyProvider(policy_provider));
   scoped_ptr<RealRandomProvider> random_provider(new RealRandomProvider());
   scoped_ptr<RealShillProvider> shill_provider(
       new RealShillProvider(dbus, clock));
@@ -26,7 +30,8 @@
   scoped_ptr<RealUpdaterProvider> updater_provider(
       new RealUpdaterProvider(system_state));
 
-  if (!(random_provider->Init() &&
+  if (!(device_policy_provider->Init() &&
+        random_provider->Init() &&
         shill_provider->Init() &&
         system_provider->Init() &&
         time_provider->Init() &&
@@ -35,7 +40,8 @@
     return NULL;
   }
 
-  return new State(random_provider.release(),
+  return new State(device_policy_provider.release(),
+                   random_provider.release(),
                    shill_provider.release(),
                    system_provider.release(),
                    time_provider.release(),
diff --git a/policy_manager/state_factory.h b/policy_manager/state_factory.h
index 4272258..bc60ba1 100644
--- a/policy_manager/state_factory.h
+++ b/policy_manager/state_factory.h
@@ -16,8 +16,10 @@
 // ownership of the passed interfaces, which need to remain available during the
 // life of this instance.  Returns null if one of the underlying providers fails
 // to initialize.
-State* DefaultStateFactory(chromeos_update_engine::DBusWrapperInterface* dbus,
-                           chromeos_update_engine::SystemState* system_state);
+State* DefaultStateFactory(
+    policy::PolicyProvider* policy_provider,
+    chromeos_update_engine::DBusWrapperInterface* dbus,
+    chromeos_update_engine::SystemState* system_state);
 
 }  // namespace chromeos_policy_manager
 
diff --git a/policy_manager/variable.h b/policy_manager/variable.h
index bf610c1..ae2b99e 100644
--- a/policy_manager/variable.h
+++ b/policy_manager/variable.h
@@ -57,6 +57,8 @@
       LOG(WARNING) << "Variable " << name_ << " deleted with "
                    << observer_list_.size() << " observers.";
     }
+    DCHECK(observer_list_.empty()) << "Don't destroy the variable without "
+                                      "removing the observers.";
   }
 
   // Returns the variable name as a string.
@@ -172,6 +174,9 @@
   // directly from the variable.
   friend class EvaluationContext;
 
+  friend class PmRealDevicePolicyProviderTest;
+  FRIEND_TEST(PmRealDevicePolicyProviderTest,
+              NonExistentDevicePolicyEmptyVariables);
   friend class PmRealRandomProviderTest;
   FRIEND_TEST(PmRealRandomProviderTest, GetRandomValues);
   friend class PmRealShillProviderTest;
diff --git a/real_system_state.cc b/real_system_state.cc
index 9964155..9384228 100644
--- a/real_system_state.cc
+++ b/real_system_state.cc
@@ -45,8 +45,8 @@
                                            kMaxP2PFilesToKeep));
 
   // Initialize the PolicyManager using the default State Factory.
-  if (!policy_manager_.Init(
-          chromeos_policy_manager::DefaultStateFactory(&dbus_, this))) {
+  if (!policy_manager_.Init(chromeos_policy_manager::DefaultStateFactory(
+      &policy_provider_, &dbus_, this))) {
     LOG(ERROR) << "Failed to initialize the policy manager.";
     return false;
   }
diff --git a/real_system_state.h b/real_system_state.h
index b9c0a26..32d972b 100644
--- a/real_system_state.h
+++ b/real_system_state.h
@@ -8,8 +8,8 @@
 #include "update_engine/system_state.h"
 
 #include <policy/device_policy.h>
+#include <metrics/metrics_library.h>
 
-#include "metrics/metrics_library.h"
 #include "update_engine/clock.h"
 #include "update_engine/connection_manager.h"
 #include "update_engine/gpio_handler.h"
@@ -144,6 +144,8 @@
 
   chromeos_policy_manager::PolicyManager policy_manager_;
 
+  policy::PolicyProvider policy_provider_;
+
   // If true, this is the first instance of the update engine since the system
   // rebooted. Important for tracking whether you are running instance of the
   // update engine on first boot or due to a crash/restart.