diff --git a/mock_system_state.h b/mock_system_state.h
index 73987d5..7d79b77 100644
--- a/mock_system_state.h
+++ b/mock_system_state.h
@@ -5,12 +5,12 @@
 #ifndef CHROMEOS_PLATFORM_UPDATE_ENGINE_MOCK_SYSTEM_STATE_H_
 #define CHROMEOS_PLATFORM_UPDATE_ENGINE_MOCK_SYSTEM_STATE_H_
 
+#include <base/logging.h>
 #include <gmock/gmock.h>
-
-#include <metrics/metrics_library_mock.h>
 #include <policy/mock_device_policy.h>
 
-#include "update_engine/clock.h"
+#include "metrics/metrics_library_mock.h"
+#include "update_engine/fake_clock.h"
 #include "update_engine/fake_hardware.h"
 #include "update_engine/mock_connection_manager.h"
 #include "update_engine/mock_dbus_wrapper.h"
@@ -24,154 +24,240 @@
 
 namespace chromeos_update_engine {
 
-class UpdateAttempterMock;
-
 // Mock the SystemStateInterface so that we could lie that
 // OOBE is completed even when there's no such marker file, etc.
 class MockSystemState : public SystemState {
  public:
   MockSystemState();
 
-  virtual ~MockSystemState();
+  // Base class overrides. All getters return the current implementation of
+  // various members, either the default (fake/mock) or the one set to override
+  // it by client code.
 
-  MOCK_METHOD1(set_device_policy, void(const policy::DevicePolicy*));
-  MOCK_CONST_METHOD0(device_policy, const policy::DevicePolicy*());
-  MOCK_METHOD0(system_rebooted, bool());
-
-  inline virtual ClockInterface* clock() {
+  virtual inline ClockInterface* clock() override {
     return clock_;
   }
 
-  inline virtual ConnectionManager* connection_manager() {
+  virtual inline void set_device_policy(
+      const policy::DevicePolicy* device_policy) override {
+    device_policy_ = device_policy;
+  }
+
+  virtual inline const policy::DevicePolicy* device_policy() override {
+    return device_policy_;
+  }
+
+  virtual inline ConnectionManager* connection_manager() override {
     return connection_manager_;
   }
 
-  inline virtual HardwareInterface* hardware() {
+  virtual inline HardwareInterface* hardware() override {
     return hardware_;
   }
 
-  inline virtual MetricsLibraryInterface* metrics_lib() {
-    return &mock_metrics_lib_;
+  virtual inline MetricsLibraryInterface* metrics_lib() override {
+    return metrics_lib_;
   }
 
-  inline virtual PrefsInterface* prefs() {
+  virtual inline PrefsInterface* prefs() override {
     return prefs_;
   }
 
-  inline virtual PrefsInterface* powerwash_safe_prefs() {
+  virtual inline PrefsInterface* powerwash_safe_prefs() override {
     return powerwash_safe_prefs_;
   }
 
-  inline virtual PayloadStateInterface* payload_state() {
+  virtual inline PayloadStateInterface* payload_state() override {
     return payload_state_;
   }
 
-  inline virtual GpioHandler* gpio_handler() const {
-    return mock_gpio_handler_;
+  virtual inline GpioHandler* gpio_handler() override {
+    return gpio_handler_;
   }
 
-  inline virtual UpdateAttempterMock* update_attempter() const override {
-    return mock_update_attempter_;
+  virtual inline UpdateAttempter* update_attempter() override {
+    return update_attempter_;
   }
 
-  inline virtual OmahaRequestParams* request_params() {
+  virtual inline OmahaRequestParams* request_params() override {
     return request_params_;
   }
 
-  inline virtual P2PManager* p2p_manager() {
+  virtual inline P2PManager* p2p_manager() override {
     return p2p_manager_;
   }
 
-  inline virtual chromeos_policy_manager::PolicyManager* policy_manager() {
+  virtual inline chromeos_policy_manager::PolicyManager* policy_manager()
+      override {
     return policy_manager_;
   }
 
-  // MockSystemState-specific public method.
-  inline void set_connection_manager(ConnectionManager* connection_manager) {
-    connection_manager_ = connection_manager;
+  virtual inline bool system_rebooted() override {
+    return fake_system_rebooted_;
   }
 
-  inline MetricsLibraryMock* mock_metrics_lib() {
-    return &mock_metrics_lib_;
-  }
+  // Setters for the various members, can be used for overriding the default
+  // implementations. For convenience, setting to a null pointer will restore
+  // the default implementation.
 
   inline void set_clock(ClockInterface* clock) {
-    clock_ = clock;
+    clock_ = clock ? clock : &fake_clock_;
+  }
+
+  inline void set_connection_manager(ConnectionManager* connection_manager) {
+    connection_manager_ = (connection_manager ? connection_manager :
+                           &mock_connection_manager_);
   }
 
   inline void set_hardware(HardwareInterface* hardware) {
-    hardware_ = hardware;
+    hardware_ = hardware ? hardware : &fake_hardware_;
   }
 
-  inline FakeHardware* get_fake_hardware() {
-    return &default_hardware_;
+  inline void set_metrics_lib(MetricsLibraryInterface* metrics_lib) {
+    metrics_lib_ = metrics_lib ? metrics_lib : &mock_metrics_lib_;
   }
 
   inline void set_prefs(PrefsInterface* prefs) {
-    prefs_ = prefs;
+    prefs_ = prefs ? prefs : &mock_prefs_;
   }
 
-  inline void set_powerwash_safe_prefs(PrefsInterface* prefs) {
-    powerwash_safe_prefs_ = prefs;
+  inline void set_powerwash_safe_prefs(PrefsInterface* powerwash_safe_prefs) {
+    powerwash_safe_prefs_ = (powerwash_safe_prefs ? powerwash_safe_prefs :
+                             &mock_powerwash_safe_prefs_);
   }
 
-  inline testing::NiceMock<PrefsMock> *mock_prefs() {
-    return &mock_prefs_;
+  inline void set_payload_state(PayloadStateInterface *payload_state) {
+    payload_state_ = payload_state ? payload_state : &mock_payload_state_;
   }
 
-  inline testing::NiceMock<PrefsMock> *mock_powerwash_safe_prefs() {
-    return &mock_powerwash_safe_prefs_;
+  inline void set_gpio_handler(GpioHandler* gpio_handler) {
+    gpio_handler_ = gpio_handler ? gpio_handler : &mock_gpio_handler_;
   }
 
-  inline MockPayloadState* mock_payload_state() {
-    return &mock_payload_state_;
+  inline void set_update_attempter(UpdateAttempter* update_attempter) {
+    update_attempter_ = (update_attempter ? update_attempter :
+                         &mock_update_attempter_);
   }
 
-  inline void set_request_params(OmahaRequestParams* params) {
-    request_params_ = params;
+  inline void set_request_params(OmahaRequestParams* request_params) {
+    request_params_ = (request_params ? request_params :
+                       &default_request_params_);
   }
 
   inline void set_p2p_manager(P2PManager *p2p_manager) {
-    p2p_manager_ = p2p_manager;
+    p2p_manager_ = p2p_manager ? p2p_manager : &mock_p2p_manager_;
   }
 
   inline void set_policy_manager(
       chromeos_policy_manager::PolicyManager *policy_manager) {
-    policy_manager_ = policy_manager;
+    policy_manager_ = policy_manager ? policy_manager : &fake_policy_manager_;
   }
 
-  inline void set_payload_state(PayloadStateInterface *payload_state) {
-    payload_state_ = payload_state;
+  inline void set_system_rebooted(bool system_rebooted) {
+    fake_system_rebooted_ = system_rebooted;
+  }
+
+  // Getters for the built-in default implementations. These return the actual
+  // concrete type of each implementation. For additional safety, they will fail
+  // whenever the requested default was overridden by a different
+  // implementation.
+
+  inline FakeClock* fake_clock() {
+    CHECK(clock_ == &fake_clock_);
+    return &fake_clock_;
+  }
+
+  inline testing::NiceMock<MockConnectionManager>* mock_connection_manager() {
+    CHECK(connection_manager_ == &mock_connection_manager_);
+    return &mock_connection_manager_;
+  }
+
+  inline FakeHardware* fake_hardware() {
+    CHECK(hardware_ == &fake_hardware_);
+    return &fake_hardware_;
+  }
+
+  inline testing::NiceMock<MetricsLibraryMock>* mock_metrics_lib() {
+    CHECK(metrics_lib_ == &mock_metrics_lib_);
+    return &mock_metrics_lib_;
+  }
+
+  inline testing::NiceMock<PrefsMock> *mock_prefs() {
+    CHECK(prefs_ == &mock_prefs_);
+    return &mock_prefs_;
+  }
+
+  inline testing::NiceMock<PrefsMock> *mock_powerwash_safe_prefs() {
+    CHECK(powerwash_safe_prefs_ == &mock_powerwash_safe_prefs_);
+    return &mock_powerwash_safe_prefs_;
+  }
+
+  inline testing::NiceMock<MockPayloadState>* mock_payload_state() {
+    CHECK(payload_state_ == &mock_payload_state_);
+    return &mock_payload_state_;
+  }
+
+  inline testing::NiceMock<MockGpioHandler>* mock_gpio_handler() {
+    CHECK(gpio_handler_ == &mock_gpio_handler_);
+    return &mock_gpio_handler_;
+  }
+
+  inline testing::NiceMock<UpdateAttempterMock>* mock_update_attempter() {
+    CHECK(update_attempter_ == &mock_update_attempter_);
+    return &mock_update_attempter_;
+  }
+
+  inline OmahaRequestParams* default_request_params() {
+    CHECK(request_params_ == &default_request_params_);
+    return &default_request_params_;
+  }
+
+  inline testing::NiceMock<MockP2PManager>* mock_p2p_manager() {
+    CHECK(p2p_manager_ == &mock_p2p_manager_);
+    return &mock_p2p_manager_;
+  }
+
+  inline chromeos_policy_manager::FakePolicyManager* fake_policy_manager() {
+    CHECK(policy_manager_ == &fake_policy_manager_);
+    return &fake_policy_manager_;
   }
 
  private:
-  // These are Mock objects or objects we own.
+  // Default mock/fake implementations (owned).
+  FakeClock fake_clock_;
+  testing::NiceMock<MockConnectionManager> mock_connection_manager_;
+  FakeHardware fake_hardware_;
   testing::NiceMock<MetricsLibraryMock> mock_metrics_lib_;
   testing::NiceMock<PrefsMock> mock_prefs_;
   testing::NiceMock<PrefsMock> mock_powerwash_safe_prefs_;
-  testing::NiceMock<MockP2PManager> mock_p2p_manager_;
   testing::NiceMock<MockPayloadState> mock_payload_state_;
-  testing::NiceMock<MockGpioHandler>* mock_gpio_handler_;
-  testing::NiceMock<UpdateAttempterMock>* mock_update_attempter_;
-  testing::NiceMock<MockConnectionManager>* mock_connection_manager_;
-  MockDBusWrapper dbus_;
-
-  // These are the other object we own.
-  Clock default_clock_;
-  FakeHardware default_hardware_;
-  chromeos_policy_manager::FakePolicyManager fake_policy_manager_;
+  testing::NiceMock<MockGpioHandler> mock_gpio_handler_;
+  testing::NiceMock<UpdateAttempterMock> mock_update_attempter_;
   OmahaRequestParams default_request_params_;
+  testing::NiceMock<MockP2PManager> mock_p2p_manager_;
+  chromeos_policy_manager::FakePolicyManager fake_policy_manager_;
 
-  // These are pointers to objects which caller can override.
+  // Pointers to objects that client code can override. They are initialized to
+  // the default implementations above.
   ClockInterface* clock_;
+  ConnectionManager* connection_manager_;
   HardwareInterface* hardware_;
+  MetricsLibraryInterface* metrics_lib_;
   PrefsInterface* prefs_;
   PrefsInterface* powerwash_safe_prefs_;
-  ConnectionManager* connection_manager_;
+  PayloadStateInterface* payload_state_;
+  GpioHandler* gpio_handler_;
+  UpdateAttempter* update_attempter_;
   OmahaRequestParams* request_params_;
   P2PManager* p2p_manager_;
-  PayloadStateInterface* payload_state_;
   chromeos_policy_manager::PolicyManager* policy_manager_;
+
+  // Other object pointers (not preinitialized).
+  const policy::DevicePolicy* device_policy_;
+
+  // Other data members.
+  MockDBusWrapper dbus_;
+  bool fake_system_rebooted_;
 };
 
 }  // namespace chromeos_update_engine