diff --git a/update_manager/chromeos_policy.h b/update_manager/chromeos_policy.h
index 889adbd..7c23612 100644
--- a/update_manager/chromeos_policy.h
+++ b/update_manager/chromeos_policy.h
@@ -35,11 +35,11 @@
   virtual ~ChromeOSPolicy() {}
 
   // Policy overrides.
-  virtual EvalStatus UpdateCheckAllowed(
+  EvalStatus UpdateCheckAllowed(
       EvaluationContext* ec, State* state, std::string* error,
       UpdateCheckParams* result) const override;
 
-  virtual EvalStatus UpdateCanStart(
+  EvalStatus UpdateCanStart(
       EvaluationContext* ec,
       State* state,
       std::string* error,
@@ -47,7 +47,7 @@
       const bool interactive,
       const UpdateState& update_state) const override;
 
-  virtual EvalStatus UpdateDownloadAllowed(
+  EvalStatus UpdateDownloadAllowed(
       EvaluationContext* ec,
       State* state,
       std::string* error,
@@ -55,9 +55,7 @@
 
  protected:
   // Policy override.
-  virtual std::string PolicyName() const override {
-    return "ChromeOSPolicy";
-  }
+  std::string PolicyName() const override { return "ChromeOSPolicy"; }
 
  private:
   friend class UmChromeOSPolicyTest;
diff --git a/update_manager/default_policy.h b/update_manager/default_policy.h
index 2fb1a06..526476c 100644
--- a/update_manager/default_policy.h
+++ b/update_manager/default_policy.h
@@ -52,11 +52,11 @@
   virtual ~DefaultPolicy() {}
 
   // Policy overrides.
-  virtual EvalStatus UpdateCheckAllowed(
+  EvalStatus UpdateCheckAllowed(
       EvaluationContext* ec, State* state, std::string* error,
       UpdateCheckParams* result) const override;
 
-  virtual EvalStatus UpdateCanStart(
+  EvalStatus UpdateCanStart(
       EvaluationContext* ec,
       State* state,
       std::string* error,
@@ -73,7 +73,7 @@
     return EvalStatus::kSucceeded;
   }
 
-  virtual EvalStatus UpdateDownloadAllowed(
+  EvalStatus UpdateDownloadAllowed(
       EvaluationContext* ec,
       State* state,
       std::string* error,
@@ -84,9 +84,7 @@
 
  protected:
   // Policy override.
-  virtual std::string PolicyName() const override {
-    return "DefaultPolicy";
-  }
+  std::string PolicyName() const override { return "DefaultPolicy"; }
 
  private:
   // A clock interface.
diff --git a/update_manager/fake_config_provider.h b/update_manager/fake_config_provider.h
index fab01d1..5624943 100644
--- a/update_manager/fake_config_provider.h
+++ b/update_manager/fake_config_provider.h
@@ -15,7 +15,7 @@
  public:
   FakeConfigProvider() {}
 
-  virtual FakeVariable<bool>* var_is_oobe_enabled() override {
+  FakeVariable<bool>* var_is_oobe_enabled() override {
     return &var_is_oobe_enabled_;
   }
 
diff --git a/update_manager/fake_device_policy_provider.h b/update_manager/fake_device_policy_provider.h
index 6f53393..54e419a 100644
--- a/update_manager/fake_device_policy_provider.h
+++ b/update_manager/fake_device_policy_provider.h
@@ -18,44 +18,44 @@
  public:
   FakeDevicePolicyProvider() {}
 
-  virtual FakeVariable<bool>* var_device_policy_is_loaded() override {
+  FakeVariable<bool>* var_device_policy_is_loaded() override {
     return &var_device_policy_is_loaded_;
   }
 
-  virtual FakeVariable<std::string>* var_release_channel() override {
+  FakeVariable<std::string>* var_release_channel() override {
     return &var_release_channel_;
   }
 
-  virtual FakeVariable<bool>* var_release_channel_delegated() override {
+  FakeVariable<bool>* var_release_channel_delegated() override {
     return &var_release_channel_delegated_;
   }
 
-  virtual FakeVariable<bool>* var_update_disabled() override {
+  FakeVariable<bool>* var_update_disabled() override {
     return &var_update_disabled_;
   }
 
-  virtual FakeVariable<std::string>* var_target_version_prefix() override {
+  FakeVariable<std::string>* var_target_version_prefix() override {
     return &var_target_version_prefix_;
   }
 
-  virtual FakeVariable<base::TimeDelta>* var_scatter_factor() override {
+  FakeVariable<base::TimeDelta>* var_scatter_factor() override {
     return &var_scatter_factor_;
   }
 
-  virtual FakeVariable<std::set<ConnectionType>>*
+  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 {
+  FakeVariable<std::string>* var_get_owner() override {
     return &var_get_owner_;
   }
 
-  virtual FakeVariable<bool>* var_http_downloads_enabled() override {
+  FakeVariable<bool>* var_http_downloads_enabled() override {
     return &var_http_downloads_enabled_;
   }
 
-  virtual FakeVariable<bool>* var_au_p2p_enabled() override {
+  FakeVariable<bool>* var_au_p2p_enabled() override {
     return &var_au_p2p_enabled_;
   }
 
diff --git a/update_manager/fake_random_provider.h b/update_manager/fake_random_provider.h
index 4483635..9f2bc35 100644
--- a/update_manager/fake_random_provider.h
+++ b/update_manager/fake_random_provider.h
@@ -15,7 +15,7 @@
  public:
   FakeRandomProvider() {}
 
-  virtual FakeVariable<uint64_t>* var_seed() override { return &var_seed_; }
+  FakeVariable<uint64_t>* var_seed() override { return &var_seed_; }
 
  private:
   FakeVariable<uint64_t> var_seed_{"seed", kVariableModePoll};
diff --git a/update_manager/fake_shill_provider.h b/update_manager/fake_shill_provider.h
index fb38c61..12cfe1d 100644
--- a/update_manager/fake_shill_provider.h
+++ b/update_manager/fake_shill_provider.h
@@ -15,20 +15,20 @@
  public:
   FakeShillProvider() {}
 
-  virtual FakeVariable<bool>* var_is_connected() override {
+  FakeVariable<bool>* var_is_connected() override {
     return &var_is_connected_;
   }
 
-  virtual FakeVariable<ConnectionType>* var_conn_type() override {
+  FakeVariable<ConnectionType>* var_conn_type() override {
     return &var_conn_type_;
   }
 
-  virtual FakeVariable<ConnectionTethering>*
+  FakeVariable<ConnectionTethering>*
       var_conn_tethering() override {
     return &var_conn_tethering_;
   }
 
-  virtual FakeVariable<base::Time>* var_conn_last_changed() override {
+  FakeVariable<base::Time>* var_conn_last_changed() override {
     return &var_conn_last_changed_;
   }
 
diff --git a/update_manager/fake_state.h b/update_manager/fake_state.h
index f47aa78..9c1ff01 100644
--- a/update_manager/fake_state.h
+++ b/update_manager/fake_state.h
@@ -34,31 +34,31 @@
   virtual ~FakeState() {}
 
   // Downcasted getters to access the fake instances during testing.
-  virtual FakeConfigProvider* config_provider() override {
+  FakeConfigProvider* config_provider() override {
     return &config_provider_;
   }
 
-  virtual FakeDevicePolicyProvider* device_policy_provider() override {
+  FakeDevicePolicyProvider* device_policy_provider() override {
     return &device_policy_provider_;
   }
 
-  virtual FakeRandomProvider* random_provider() override {
+  FakeRandomProvider* random_provider() override {
     return &random_provider_;
   }
 
-  virtual FakeShillProvider* shill_provider() override {
+  FakeShillProvider* shill_provider() override {
     return &shill_provider_;
   }
 
-  virtual FakeSystemProvider* system_provider() override {
+  FakeSystemProvider* system_provider() override {
     return &system_provider_;
   }
 
-  virtual FakeTimeProvider* time_provider() override {
+  FakeTimeProvider* time_provider() override {
     return &time_provider_;
   }
 
-  virtual FakeUpdaterProvider* updater_provider() override {
+  FakeUpdaterProvider* updater_provider() override {
     return &updater_provider_;
   }
 
diff --git a/update_manager/fake_system_provider.h b/update_manager/fake_system_provider.h
index 47cd5ac..6b7151b 100644
--- a/update_manager/fake_system_provider.h
+++ b/update_manager/fake_system_provider.h
@@ -15,19 +15,19 @@
  public:
   FakeSystemProvider() {}
 
-  virtual FakeVariable<bool>* var_is_normal_boot_mode() override {
+  FakeVariable<bool>* var_is_normal_boot_mode() override {
     return &var_is_normal_boot_mode_;
   }
 
-  virtual FakeVariable<bool>* var_is_official_build() override {
+  FakeVariable<bool>* var_is_official_build() override {
     return &var_is_official_build_;
   }
 
-  virtual FakeVariable<bool>* var_is_oobe_complete() override {
+  FakeVariable<bool>* var_is_oobe_complete() override {
     return &var_is_oobe_complete_;
   }
 
-  virtual FakeVariable<bool>* var_is_boot_device_removable() override {
+  FakeVariable<bool>* var_is_boot_device_removable() override {
     return &var_is_boot_device_removable_;
   }
 
diff --git a/update_manager/fake_time_provider.h b/update_manager/fake_time_provider.h
index 97858a3..a60405b 100644
--- a/update_manager/fake_time_provider.h
+++ b/update_manager/fake_time_provider.h
@@ -15,13 +15,8 @@
  public:
   FakeTimeProvider() {}
 
-  virtual FakeVariable<base::Time>* var_curr_date() override {
-    return &var_curr_date_;
-  }
-
-  virtual FakeVariable<int>* var_curr_hour() override {
-    return &var_curr_hour_;
-  }
+  FakeVariable<base::Time>* var_curr_date() override { return &var_curr_date_; }
+  FakeVariable<int>* var_curr_hour() override { return &var_curr_hour_; }
 
  private:
   FakeVariable<base::Time> var_curr_date_{"curr_date", kVariableModePoll};
diff --git a/update_manager/fake_updater_provider.h b/update_manager/fake_updater_provider.h
index fa3b869..f2295a5 100644
--- a/update_manager/fake_updater_provider.h
+++ b/update_manager/fake_updater_provider.h
@@ -17,61 +17,59 @@
  public:
   FakeUpdaterProvider() {}
 
-  virtual FakeVariable<base::Time>* var_updater_started_time() override {
+  FakeVariable<base::Time>* var_updater_started_time() override {
     return &var_updater_started_time_;
   }
 
-  virtual FakeVariable<base::Time>* var_last_checked_time() override {
+  FakeVariable<base::Time>* var_last_checked_time() override {
     return &var_last_checked_time_;
   }
 
-  virtual FakeVariable<base::Time>* var_update_completed_time() override {
+  FakeVariable<base::Time>* var_update_completed_time() override {
     return &var_update_completed_time_;
   }
 
-  virtual FakeVariable<double>* var_progress() override {
+  FakeVariable<double>* var_progress() override {
     return &var_progress_;
   }
 
-  virtual FakeVariable<Stage>* var_stage() override {
+  FakeVariable<Stage>* var_stage() override {
     return &var_stage_;
   }
 
-  virtual FakeVariable<std::string>* var_new_version() override {
+  FakeVariable<std::string>* var_new_version() override {
     return &var_new_version_;
   }
 
-  virtual FakeVariable<int64_t>* var_payload_size() override {
+  FakeVariable<int64_t>* var_payload_size() override {
     return &var_payload_size_;
   }
 
-  virtual FakeVariable<std::string>* var_curr_channel() override {
+  FakeVariable<std::string>* var_curr_channel() override {
     return &var_curr_channel_;
   }
 
-  virtual FakeVariable<std::string>* var_new_channel() override {
+  FakeVariable<std::string>* var_new_channel() override {
     return &var_new_channel_;
   }
 
-  virtual FakeVariable<bool>* var_p2p_enabled() override {
+  FakeVariable<bool>* var_p2p_enabled() override {
     return &var_p2p_enabled_;
   }
 
-  virtual FakeVariable<bool>* var_cellular_enabled() override {
+  FakeVariable<bool>* var_cellular_enabled() override {
     return &var_cellular_enabled_;
   }
 
-  virtual FakeVariable<unsigned int>*
-      var_consecutive_failed_update_checks() override {
+  FakeVariable<unsigned int>* var_consecutive_failed_update_checks() override {
     return &var_consecutive_failed_update_checks_;
   }
 
-  virtual FakeVariable<unsigned int>*
-      var_server_dictated_poll_interval() override {
+  FakeVariable<unsigned int>* var_server_dictated_poll_interval() override {
     return &var_server_dictated_poll_interval_;
   }
 
-  virtual FakeVariable<bool>* var_interactive_update_requested() override {
+  FakeVariable<bool>* var_interactive_update_requested() override {
     return &var_interactive_update_requested_;
   }
 
diff --git a/update_manager/real_device_policy_provider.h b/update_manager/real_device_policy_provider.h
index c86a2f5..4b75d68 100644
--- a/update_manager/real_device_policy_provider.h
+++ b/update_manager/real_device_policy_provider.h
@@ -27,44 +27,44 @@
   // Initializes the provider and returns whether it succeeded.
   bool Init();
 
-  virtual Variable<bool>* var_device_policy_is_loaded() override {
+  Variable<bool>* var_device_policy_is_loaded() override {
     return &var_device_policy_is_loaded_;
   }
 
-  virtual Variable<std::string>* var_release_channel() override {
+  Variable<std::string>* var_release_channel() override {
     return &var_release_channel_;
   }
 
-  virtual Variable<bool>* var_release_channel_delegated() override {
+  Variable<bool>* var_release_channel_delegated() override {
     return &var_release_channel_delegated_;
   }
 
-  virtual Variable<bool>* var_update_disabled() override {
+  Variable<bool>* var_update_disabled() override {
     return &var_update_disabled_;
   }
 
-  virtual Variable<std::string>* var_target_version_prefix() override {
+  Variable<std::string>* var_target_version_prefix() override {
     return &var_target_version_prefix_;
   }
 
-  virtual Variable<base::TimeDelta>* var_scatter_factor() override {
+  Variable<base::TimeDelta>* var_scatter_factor() override {
     return &var_scatter_factor_;
   }
 
-  virtual Variable<std::set<ConnectionType>>*
+  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 {
+  Variable<std::string>* var_get_owner() override {
     return &var_get_owner_;
   }
 
-  virtual Variable<bool>* var_http_downloads_enabled() override {
+  Variable<bool>* var_http_downloads_enabled() override {
     return &var_http_downloads_enabled_;
   }
 
-  virtual Variable<bool>* var_au_p2p_enabled() override {
+  Variable<bool>* var_au_p2p_enabled() override {
     return &var_au_p2p_enabled_;
   }
 
diff --git a/update_manager/real_random_provider.h b/update_manager/real_random_provider.h
index b243a55..2e36d6f 100644
--- a/update_manager/real_random_provider.h
+++ b/update_manager/real_random_provider.h
@@ -16,7 +16,7 @@
  public:
   RealRandomProvider() {}
 
-  virtual Variable<uint64_t>* var_seed() override { return var_seed_.get(); }
+  Variable<uint64_t>* var_seed() override { return var_seed_.get(); }
 
   // Initializes the provider and returns whether it succeeded.
   bool Init();
diff --git a/update_manager/real_shill_provider.h b/update_manager/real_shill_provider.h
index 68f095e..382aa1e 100644
--- a/update_manager/real_shill_provider.h
+++ b/update_manager/real_shill_provider.h
@@ -34,19 +34,19 @@
   // Initializes the provider and returns whether it succeeded.
   bool Init();
 
-  virtual Variable<bool>* var_is_connected() override {
+  Variable<bool>* var_is_connected() override {
     return &var_is_connected_;
   }
 
-  virtual Variable<ConnectionType>* var_conn_type() override {
+  Variable<ConnectionType>* var_conn_type() override {
     return &var_conn_type_;
   }
 
-  virtual Variable<ConnectionTethering>* var_conn_tethering() override {
+  Variable<ConnectionTethering>* var_conn_tethering() override {
     return &var_conn_tethering_;
   }
 
-  virtual Variable<base::Time>* var_conn_last_changed() override {
+  Variable<base::Time>* var_conn_last_changed() override {
     return &var_conn_last_changed_;
   }
 
diff --git a/update_manager/real_state.h b/update_manager/real_state.h
index 69632fb..1e2d10e 100644
--- a/update_manager/real_state.h
+++ b/update_manager/real_state.h
@@ -32,25 +32,25 @@
       updater_provider_(updater_provider) {}
 
   // These methods return the given provider.
-  virtual ConfigProvider* config_provider() override {
+  ConfigProvider* config_provider() override {
     return config_provider_.get();
   }
-  virtual DevicePolicyProvider* device_policy_provider() override {
+  DevicePolicyProvider* device_policy_provider() override {
     return device_policy_provider_.get();
   }
-  virtual RandomProvider* random_provider() override {
+  RandomProvider* random_provider() override {
     return random_provider_.get();
   }
-  virtual ShillProvider* shill_provider() override {
+  ShillProvider* shill_provider() override {
     return shill_provider_.get();
   }
-  virtual SystemProvider* system_provider() override {
+  SystemProvider* system_provider() override {
     return system_provider_.get();
   }
-  virtual TimeProvider* time_provider() override {
+  TimeProvider* time_provider() override {
     return time_provider_.get();
   }
-  virtual UpdaterProvider* updater_provider() override {
+  UpdaterProvider* updater_provider() override {
     return updater_provider_.get();
   }
 
diff --git a/update_manager/real_system_provider.h b/update_manager/real_system_provider.h
index d1e20be..c040855 100644
--- a/update_manager/real_system_provider.h
+++ b/update_manager/real_system_provider.h
@@ -24,19 +24,19 @@
   // Initializes the provider and returns whether it succeeded.
   bool Init();
 
-  virtual Variable<bool>* var_is_normal_boot_mode() override {
+  Variable<bool>* var_is_normal_boot_mode() override {
     return var_is_normal_boot_mode_.get();
   }
 
-  virtual Variable<bool>* var_is_official_build() override {
+  Variable<bool>* var_is_official_build() override {
     return var_is_official_build_.get();
   }
 
-  virtual Variable<bool>* var_is_oobe_complete() override {
+  Variable<bool>* var_is_oobe_complete() override {
     return var_is_oobe_complete_.get();
   }
 
-  virtual Variable<bool>* var_is_boot_device_removable() override {
+  Variable<bool>* var_is_boot_device_removable() override {
     return var_is_boot_device_removable_.get();
   }
 
diff --git a/update_manager/real_time_provider.h b/update_manager/real_time_provider.h
index 069d2d2..ff5598e 100644
--- a/update_manager/real_time_provider.h
+++ b/update_manager/real_time_provider.h
@@ -22,11 +22,11 @@
   // Initializes the provider and returns whether it succeeded.
   bool Init();
 
-  virtual Variable<base::Time>* var_curr_date() override {
+  Variable<base::Time>* var_curr_date() override {
     return var_curr_date_.get();
   }
 
-  virtual Variable<int>* var_curr_hour() override {
+  Variable<int>* var_curr_hour() override {
     return var_curr_hour_.get();
   }
 
diff --git a/update_manager/real_updater_provider.cc b/update_manager/real_updater_provider.cc
index 7dae714..c525b8f 100644
--- a/update_manager/real_updater_provider.cc
+++ b/update_manager/real_updater_provider.cc
@@ -78,8 +78,7 @@
       : UpdaterVariableBase<Time>(name, kVariableModePoll, system_state) {}
 
  private:
-  virtual const Time* GetValue(TimeDelta /* timeout */,
-                               string* errmsg) override {
+  const Time* GetValue(TimeDelta /* timeout */, string* errmsg) override {
     GetStatusHelper raw(system_state(), errmsg);
     if (!raw.is_success())
       return NULL;
@@ -98,8 +97,7 @@
       : UpdaterVariableBase<double>(name, kVariableModePoll, system_state) {}
 
  private:
-  virtual const double* GetValue(TimeDelta /* timeout */,
-                                 string* errmsg) override {
+  const double* GetValue(TimeDelta /* timeout */, string* errmsg) override {
     GetStatusHelper raw(system_state(), errmsg);
     if (!raw.is_success())
       return NULL;
@@ -132,8 +130,7 @@
   static const CurrOpStrToStage curr_op_str_to_stage[];
 
   // Note: the method is defined outside the class so arraysize can work.
-  virtual const Stage* GetValue(TimeDelta /* timeout */,
-                                string* errmsg) override;
+  const Stage* GetValue(TimeDelta /* timeout */, string* errmsg) override;
 
   DISALLOW_COPY_AND_ASSIGN(StageVariable);
 };
@@ -175,8 +172,7 @@
       : UpdaterVariableBase<string>(name, kVariableModePoll, system_state) {}
 
  private:
-  virtual const string* GetValue(TimeDelta /* timeout */,
-                                 string* errmsg) override {
+  const string* GetValue(TimeDelta /* timeout */, string* errmsg) override {
     GetStatusHelper raw(system_state(), errmsg);
     if (!raw.is_success())
       return NULL;
@@ -194,8 +190,7 @@
       : UpdaterVariableBase<int64_t>(name, kVariableModePoll, system_state) {}
 
  private:
-  virtual const int64_t* GetValue(TimeDelta /* timeout */,
-                                 string* errmsg) override {
+  const int64_t* GetValue(TimeDelta /* timeout */, string* errmsg) override {
     GetStatusHelper raw(system_state(), errmsg);
     if (!raw.is_success())
       return NULL;
@@ -225,8 +220,7 @@
       : UpdaterVariableBase<Time>(name, kVariableModePoll, system_state) {}
 
  private:
-  virtual const Time* GetValue(TimeDelta /* timeout */,
-                               string* errmsg) override {
+  const Time* GetValue(TimeDelta /* timeout */, string* errmsg) override {
     Time update_boottime;
     if (!system_state()->update_attempter()->GetBootTimeAtUpdate(
             &update_boottime)) {
@@ -256,8 +250,7 @@
       : UpdaterVariableBase<string>(name, kVariableModePoll, system_state) {}
 
  private:
-  virtual const string* GetValue(TimeDelta /* timeout */,
-                                 string* errmsg) override {
+  const string* GetValue(TimeDelta /* timeout */, string* errmsg) override {
     OmahaRequestParams* request_params = system_state()->request_params();
     string channel = request_params->current_channel();
     if (channel.empty()) {
@@ -278,8 +271,7 @@
       : UpdaterVariableBase<string>(name, kVariableModePoll, system_state) {}
 
  private:
-  virtual const string* GetValue(TimeDelta /* timeout */,
-                                 string* errmsg) override {
+  const string* GetValue(TimeDelta /* timeout */, string* errmsg) override {
     OmahaRequestParams* request_params = system_state()->request_params();
     string channel = request_params->target_channel();
     if (channel.empty()) {
@@ -302,8 +294,7 @@
         key_(key), default_val_(default_val) {}
 
  private:
-  virtual const bool* GetValue(TimeDelta /* timeout */,
-                               string* errmsg) override {
+  const bool* GetValue(TimeDelta /* timeout */, string* errmsg) override {
     bool result = default_val_;
     chromeos_update_engine::PrefsInterface* prefs = system_state()->prefs();
     if (prefs && prefs->Exists(key_) && !prefs->GetBoolean(key_, &result)) {
@@ -331,8 +322,8 @@
                                           system_state) {}
 
  private:
-  virtual const unsigned int* GetValue(TimeDelta /* timeout */,
-                                       string* /* errmsg */) override {
+  const unsigned int* GetValue(TimeDelta /* timeout */,
+                               string* /* errmsg */) override {
     return new unsigned int(
         system_state()->update_attempter()->consecutive_failed_update_checks());
   }
@@ -350,8 +341,8 @@
                                           system_state) {}
 
  private:
-  virtual const unsigned int* GetValue(TimeDelta /* timeout */,
-                                       string* /* errmsg */) override {
+  const unsigned int* GetValue(TimeDelta /* timeout */,
+                               string* /* errmsg */) override {
     return new unsigned int(
         system_state()->update_attempter()->server_dictated_poll_interval());
   }
@@ -373,8 +364,8 @@
   }
 
  private:
-  virtual const bool* GetValue(TimeDelta /* timeout */,
-                               string* /* errmsg */) override {
+  const bool* GetValue(TimeDelta /* timeout */,
+                       string* /* errmsg */) override {
     return new bool(interactive_update_requested_);
   }
 
diff --git a/update_manager/real_updater_provider.h b/update_manager/real_updater_provider.h
index 6a3bc19..5c40acd 100644
--- a/update_manager/real_updater_provider.h
+++ b/update_manager/real_updater_provider.h
@@ -29,61 +29,59 @@
   // Initializes the provider and returns whether it succeeded.
   bool Init() { return true; }
 
-  virtual Variable<base::Time>* var_updater_started_time() override {
+  Variable<base::Time>* var_updater_started_time() override {
     return &var_updater_started_time_;
   }
 
-  virtual Variable<base::Time>* var_last_checked_time() override {
+  Variable<base::Time>* var_last_checked_time() override {
     return var_last_checked_time_.get();
   }
 
-  virtual Variable<base::Time>* var_update_completed_time() override {
+  Variable<base::Time>* var_update_completed_time() override {
     return var_update_completed_time_.get();
   }
 
-  virtual Variable<double>* var_progress() override {
+  Variable<double>* var_progress() override {
     return var_progress_.get();
   }
 
-  virtual Variable<Stage>* var_stage() override {
+  Variable<Stage>* var_stage() override {
     return var_stage_.get();
   }
 
-  virtual Variable<std::string>* var_new_version() override {
+  Variable<std::string>* var_new_version() override {
     return var_new_version_.get();
   }
 
-  virtual Variable<int64_t>* var_payload_size() override {
+  Variable<int64_t>* var_payload_size() override {
     return var_payload_size_.get();
   }
 
-  virtual Variable<std::string>* var_curr_channel() override {
+  Variable<std::string>* var_curr_channel() override {
     return var_curr_channel_.get();
   }
 
-  virtual Variable<std::string>* var_new_channel() override {
+  Variable<std::string>* var_new_channel() override {
     return var_new_channel_.get();
   }
 
-  virtual Variable<bool>* var_p2p_enabled() override {
+  Variable<bool>* var_p2p_enabled() override {
     return var_p2p_enabled_.get();
   }
 
-  virtual Variable<bool>* var_cellular_enabled() override {
+  Variable<bool>* var_cellular_enabled() override {
     return var_cellular_enabled_.get();
   }
 
-  virtual Variable<unsigned int>*
-      var_consecutive_failed_update_checks() override {
+  Variable<unsigned int>* var_consecutive_failed_update_checks() override {
     return var_consecutive_failed_update_checks_.get();
   }
 
-  virtual Variable<unsigned int>*
-      var_server_dictated_poll_interval() override {
+  Variable<unsigned int>* var_server_dictated_poll_interval() override {
     return var_server_dictated_poll_interval_.get();
   }
 
-  virtual Variable<bool>* var_interactive_update_requested() override {
+  Variable<bool>* var_interactive_update_requested() override {
     return var_interactive_update_requested_.get();
   }
 
diff --git a/update_manager/update_manager_unittest.cc b/update_manager/update_manager_unittest.cc
index cb9b61b..f6a1c01 100644
--- a/update_manager/update_manager_unittest.cc
+++ b/update_manager/update_manager_unittest.cc
@@ -58,7 +58,7 @@
 
 class UmUpdateManagerTest : public ::testing::Test {
  protected:
-  virtual void SetUp() {
+  void SetUp() override {
     fake_state_ = new FakeState();
     umut_.reset(new UpdateManager(&fake_clock_, TimeDelta::FromSeconds(5),
                                   TimeDelta::FromSeconds(1), fake_state_));
@@ -76,9 +76,9 @@
  public:
   explicit FailingPolicy(int* num_called_p) : num_called_p_(num_called_p) {}
   FailingPolicy() : FailingPolicy(nullptr) {}
-  virtual EvalStatus UpdateCheckAllowed(EvaluationContext* ec, State* state,
-                                        string* error,
-                                        UpdateCheckParams* result) const {
+  EvalStatus UpdateCheckAllowed(EvaluationContext* ec, State* state,
+                                string* error,
+                                UpdateCheckParams* result) const override {
     if (num_called_p_)
       (*num_called_p_)++;
     *error = "FailingPolicy failed.";
@@ -86,7 +86,7 @@
   }
 
  protected:
-  virtual std::string PolicyName() const override { return "FailingPolicy"; }
+  std::string PolicyName() const override { return "FailingPolicy"; }
 
  private:
   int* num_called_p_;
@@ -94,14 +94,14 @@
 
 // The LazyPolicy always returns EvalStatus::kAskMeAgainLater.
 class LazyPolicy : public DefaultPolicy {
-  virtual EvalStatus UpdateCheckAllowed(EvaluationContext* ec, State* state,
-                                        string* error,
-                                        UpdateCheckParams* result) const {
+  EvalStatus UpdateCheckAllowed(EvaluationContext* ec, State* state,
+                                string* error,
+                                UpdateCheckParams* result) const override {
     return EvalStatus::kAskMeAgainLater;
   }
 
  protected:
-  virtual std::string PolicyName() const override { return "LazyPolicy"; }
+  std::string PolicyName() const override { return "LazyPolicy"; }
 };
 
 // A policy that sleeps for a predetermined amount of time, then checks for a
@@ -114,9 +114,9 @@
   DelayPolicy(int sleep_secs, Time time_threshold, int* num_called_p)
       : sleep_secs_(sleep_secs), time_threshold_(time_threshold),
         num_called_p_(num_called_p) {}
-  virtual EvalStatus UpdateCheckAllowed(EvaluationContext* ec, State* state,
-                                        string* error,
-                                        UpdateCheckParams* result) const {
+  EvalStatus UpdateCheckAllowed(EvaluationContext* ec, State* state,
+                                string* error,
+                                UpdateCheckParams* result) const override {
     if (num_called_p_)
       (*num_called_p_)++;
 
@@ -134,7 +134,7 @@
   }
 
  protected:
-  virtual std::string PolicyName() const override { return "DelayPolicy"; }
+  std::string PolicyName() const override { return "DelayPolicy"; }
 
  private:
   int sleep_secs_;