diff --git a/policy_manager/fake_state.cc b/policy_manager/fake_state.cc
index 8bbf452..6fa663b 100644
--- a/policy_manager/fake_state.cc
+++ b/policy_manager/fake_state.cc
@@ -8,24 +8,15 @@
 
 namespace chromeos_policy_manager {
 
-FakeState::FakeState() : State(new FakeConfigProvider(),
-                               new FakeDevicePolicyProvider(),
-                               new FakeRandomProvider(),
-                               new FakeShillProvider(),
-                               new FakeSystemProvider(),
-                               new FakeTimeProvider(),
-                               new FakeUpdaterProvider()) {
-}
-
 FakeState* FakeState::Construct() {
   scoped_ptr<FakeState> fake_state(new FakeState());
-  if (!(fake_state->config_provider()->Init() &&
-        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() &&
-        fake_state->updater_provider()->Init())) {
+  if (!(fake_state->config_provider_.Init() &&
+        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() &&
+        fake_state->updater_provider_.Init())) {
     return NULL;
   }
   return fake_state.release();
diff --git a/policy_manager/fake_state.h b/policy_manager/fake_state.h
index 4f9243b..9489050 100644
--- a/policy_manager/fake_state.h
+++ b/policy_manager/fake_state.h
@@ -27,37 +27,43 @@
 
   // Downcasted getters, to allow access to the fake instances during testing.
   virtual FakeConfigProvider* config_provider() override {
-    return reinterpret_cast<FakeConfigProvider*>(State::config_provider());
+    return &config_provider_;
   }
 
   virtual FakeDevicePolicyProvider* device_policy_provider() override {
-    return reinterpret_cast<FakeDevicePolicyProvider*>(
-        State::device_policy_provider());
+    return &device_policy_provider_;
   }
 
   virtual FakeRandomProvider* random_provider() override {
-    return reinterpret_cast<FakeRandomProvider*>(State::random_provider());
+    return &random_provider_;
   }
 
   virtual FakeShillProvider* shill_provider() override {
-    return reinterpret_cast<FakeShillProvider*>(State::shill_provider());
+    return &shill_provider_;
   }
 
   virtual FakeSystemProvider* system_provider() override {
-    return reinterpret_cast<FakeSystemProvider*>(State::system_provider());
+    return &system_provider_;
   }
 
   virtual FakeTimeProvider* time_provider() override {
-    return reinterpret_cast<FakeTimeProvider*>(State::time_provider());
+    return &time_provider_;
   }
 
   virtual FakeUpdaterProvider* updater_provider() override {
-    return reinterpret_cast<FakeUpdaterProvider*>(State::updater_provider());
+    return &updater_provider_;
   }
 
  private:
-  // Creates a FakeState instance using FakeProviders.
-  FakeState();
+  FakeState() {}
+
+  FakeConfigProvider config_provider_;
+  FakeDevicePolicyProvider device_policy_provider_;
+  FakeRandomProvider random_provider_;
+  FakeShillProvider shill_provider_;
+  FakeSystemProvider system_provider_;
+  FakeTimeProvider time_provider_;
+  FakeUpdaterProvider updater_provider_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeState);
 };
diff --git a/policy_manager/real_state.h b/policy_manager/real_state.h
new file mode 100644
index 0000000..7349d58
--- /dev/null
+++ b/policy_manager/real_state.h
@@ -0,0 +1,70 @@
+// 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_STATE_H_
+#define CHROMEOS_PLATFORM_UPDATE_ENGINE_POLICY_MANAGER_REAL_STATE_H_
+
+#include <base/memory/scoped_ptr.h>
+
+#include "update_engine/policy_manager/state.h"
+
+namespace chromeos_policy_manager {
+
+// State concrete implementation.
+class RealState : public State {
+ public:
+  virtual ~RealState() {}
+
+  RealState(ConfigProvider* config_provider,
+            DevicePolicyProvider* device_policy_provider,
+            RandomProvider* random_provider,
+            ShillProvider* shill_provider,
+            SystemProvider* system_provider,
+            TimeProvider* time_provider,
+            UpdaterProvider* updater_provider) :
+      config_provider_(config_provider),
+      device_policy_provider_(device_policy_provider),
+      random_provider_(random_provider),
+      shill_provider_(shill_provider),
+      system_provider_(system_provider),
+      time_provider_(time_provider),
+      updater_provider_(updater_provider) {}
+
+  // These methods return the given provider.
+  virtual ConfigProvider* config_provider() override {
+    return config_provider_.get();
+  }
+  virtual DevicePolicyProvider* device_policy_provider() override {
+    return device_policy_provider_.get();
+  }
+  virtual RandomProvider* random_provider() override {
+    return random_provider_.get();
+  }
+  virtual ShillProvider* shill_provider() override {
+    return shill_provider_.get();
+  }
+  virtual SystemProvider* system_provider() override {
+    return system_provider_.get();
+  }
+  virtual TimeProvider* time_provider() override {
+    return time_provider_.get();
+  }
+  virtual UpdaterProvider* updater_provider() override {
+    return updater_provider_.get();
+  }
+
+ private:
+  // Instances of the providers.
+  scoped_ptr<ConfigProvider> config_provider_;
+  scoped_ptr<DevicePolicyProvider> device_policy_provider_;
+  scoped_ptr<RandomProvider> random_provider_;
+  scoped_ptr<ShillProvider> shill_provider_;
+  scoped_ptr<SystemProvider> system_provider_;
+  scoped_ptr<TimeProvider> time_provider_;
+  scoped_ptr<UpdaterProvider> updater_provider_;
+};
+
+}  // namespace chromeos_policy_manager
+
+#endif  // CHROMEOS_PLATFORM_UPDATE_ENGINE_POLICY_MANAGER_REAL_STATE_H_
diff --git a/policy_manager/state.h b/policy_manager/state.h
index 23c2d6e..39abbad 100644
--- a/policy_manager/state.h
+++ b/policy_manager/state.h
@@ -20,43 +20,21 @@
 class State {
  public:
   virtual ~State() {}
-  State(ConfigProvider* config_provider,
-        DevicePolicyProvider* device_policy_provider,
-        RandomProvider* random_provider,
-        ShillProvider* shill_provider,
-        SystemProvider* system_provider,
-        TimeProvider* time_provider,
-        UpdaterProvider* updater_provider) :
-      config_provider_(config_provider),
-      device_policy_provider_(device_policy_provider),
-      random_provider_(random_provider),
-      shill_provider_(shill_provider),
-      system_provider_(system_provider),
-      time_provider_(time_provider),
-      updater_provider_(updater_provider) {}
 
   // These methods return the given provider.
-  virtual ConfigProvider* config_provider() { return config_provider_.get(); }
-  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(); }
-  virtual TimeProvider* time_provider() { return time_provider_.get(); }
-  virtual UpdaterProvider* updater_provider() {
-    return updater_provider_.get();
-  }
+  virtual ConfigProvider* config_provider() = 0;
+  virtual DevicePolicyProvider* device_policy_provider() = 0;
+  virtual RandomProvider* random_provider() = 0;
+  virtual ShillProvider* shill_provider() = 0;
+  virtual SystemProvider* system_provider() = 0;
+  virtual TimeProvider* time_provider() = 0;
+  virtual UpdaterProvider* updater_provider() = 0;
+
+ protected:
+  State() {}
 
  private:
-  // Instances of the providers.
-  scoped_ptr<ConfigProvider> config_provider_;
-  scoped_ptr<DevicePolicyProvider> device_policy_provider_;
-  scoped_ptr<RandomProvider> random_provider_;
-  scoped_ptr<ShillProvider> shill_provider_;
-  scoped_ptr<SystemProvider> system_provider_;
-  scoped_ptr<TimeProvider> time_provider_;
-  scoped_ptr<UpdaterProvider> updater_provider_;
+  DISALLOW_COPY_AND_ASSIGN(State);
 };
 
 }  // namespace chromeos_policy_manager
diff --git a/policy_manager/state_factory.cc b/policy_manager/state_factory.cc
index 5866a12..f9054de 100644
--- a/policy_manager/state_factory.cc
+++ b/policy_manager/state_factory.cc
@@ -11,6 +11,7 @@
 #include "update_engine/policy_manager/real_config_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_state.h"
 #include "update_engine/policy_manager/real_system_provider.h"
 #include "update_engine/policy_manager/real_time_provider.h"
 #include "update_engine/policy_manager/real_updater_provider.h"
@@ -44,13 +45,13 @@
     return NULL;
   }
 
-  return new State(config_provider.release(),
-                   device_policy_provider.release(),
-                   random_provider.release(),
-                   shill_provider.release(),
-                   system_provider.release(),
-                   time_provider.release(),
-                   updater_provider.release());
+  return new RealState(config_provider.release(),
+                       device_policy_provider.release(),
+                       random_provider.release(),
+                       shill_provider.release(),
+                       system_provider.release(),
+                       time_provider.release(),
+                       updater_provider.release());
 }
 
 }  // namespace chromeos_policy_manager