diff --git a/fake_hardware.h b/fake_hardware.h
index 5b48ce2..ff80009 100644
--- a/fake_hardware.h
+++ b/fake_hardware.h
@@ -31,53 +31,45 @@
       ec_version_("Fake EC v1.0a") {}
 
   // HardwareInterface methods.
-  virtual std::string BootKernelDevice() const override {
-    return kernel_device_;
-  }
+  std::string BootKernelDevice() const override { return kernel_device_; }
 
-  virtual std::string BootDevice() const override { return boot_device_; }
+  std::string BootDevice() const override { return boot_device_; }
 
-  virtual bool IsBootDeviceRemovable() const override {
+  bool IsBootDeviceRemovable() const override {
     return is_boot_device_removable_;
   }
 
-  virtual std::vector<std::string> GetKernelDevices() const override {
+  std::vector<std::string> GetKernelDevices() const override {
     return kernel_devices_;
   }
 
-  virtual bool IsKernelBootable(const std::string& kernel_device,
-                                bool* bootable) const override {
+  bool IsKernelBootable(const std::string& kernel_device,
+                        bool* bootable) const override {
     auto i = is_bootable_.find(kernel_device);
     *bootable = (i != is_bootable_.end()) ? i->second : true;
     return true;
   }
 
-  virtual bool MarkKernelUnbootable(const std::string& kernel_device) override {
+  bool MarkKernelUnbootable(const std::string& kernel_device) override {
     is_bootable_[kernel_device] = false;
     return true;
   }
 
-  virtual bool IsOfficialBuild() const override { return is_official_build_; }
+  bool IsOfficialBuild() const override { return is_official_build_; }
 
-  virtual bool IsNormalBootMode() const override {
-    return is_normal_boot_mode_;
-  }
+  bool IsNormalBootMode() const override { return is_normal_boot_mode_; }
 
-  virtual bool IsOOBEComplete(base::Time* out_time_of_oobe) const override {
+  bool IsOOBEComplete(base::Time* out_time_of_oobe) const override {
     if (out_time_of_oobe != nullptr)
       *out_time_of_oobe = oobe_timestamp_;
     return is_oobe_complete_;
   }
 
-  virtual std::string GetHardwareClass() const override {
-    return hardware_class_;
-  }
+  std::string GetHardwareClass() const override { return hardware_class_; }
 
-  virtual std::string GetFirmwareVersion() const override {
-    return firmware_version_;
-  }
+  std::string GetFirmwareVersion() const override { return firmware_version_; }
 
-  virtual std::string GetECVersion() const override { return ec_version_; }
+  std::string GetECVersion() const override { return ec_version_; }
 
   // Setters
   void SetBootDevice(const std::string& boot_device) {
diff --git a/fake_system_state.h b/fake_system_state.h
index 062cbbb..3a4f6b7 100644
--- a/fake_system_state.h
+++ b/fake_system_state.h
@@ -33,63 +33,52 @@
   // various members, either the default (fake/mock) or the one set to override
   // it by client code.
 
-  virtual inline ClockInterface* clock() override {
-    return clock_;
-  }
+  inline ClockInterface* clock() override { return clock_; }
 
-  virtual inline void set_device_policy(
+  inline void set_device_policy(
       const policy::DevicePolicy* device_policy) override {
     device_policy_ = device_policy;
   }
 
-  virtual inline const policy::DevicePolicy* device_policy() override {
+  inline const policy::DevicePolicy* device_policy() override {
     return device_policy_;
   }
 
-  virtual inline ConnectionManager* connection_manager() override {
+  inline ConnectionManager* connection_manager() override {
     return connection_manager_;
   }
 
-  virtual inline HardwareInterface* hardware() override {
-    return hardware_;
-  }
+  inline HardwareInterface* hardware() override { return hardware_; }
 
-  virtual inline MetricsLibraryInterface* metrics_lib() override {
+  inline MetricsLibraryInterface* metrics_lib() override {
     return metrics_lib_;
   }
 
-  virtual inline PrefsInterface* prefs() override {
-    return prefs_;
-  }
+  inline PrefsInterface* prefs() override { return prefs_; }
 
-  virtual inline PrefsInterface* powerwash_safe_prefs() override {
+  inline PrefsInterface* powerwash_safe_prefs() override {
     return powerwash_safe_prefs_;
   }
 
-  virtual inline PayloadStateInterface* payload_state() override {
+  inline PayloadStateInterface* payload_state() override {
     return payload_state_;
   }
 
-  virtual inline UpdateAttempter* update_attempter() override {
+  inline UpdateAttempter* update_attempter() override {
     return update_attempter_;
   }
 
-  virtual inline OmahaRequestParams* request_params() override {
+  inline OmahaRequestParams* request_params() override {
     return request_params_;
   }
 
-  virtual inline P2PManager* p2p_manager() override {
-    return p2p_manager_;
-  }
+  inline P2PManager* p2p_manager() override { return p2p_manager_; }
 
-  virtual inline chromeos_update_manager::UpdateManager* update_manager()
-      override {
+  inline chromeos_update_manager::UpdateManager* update_manager() override {
     return update_manager_;
   }
 
-  virtual inline bool system_rebooted() override {
-    return fake_system_rebooted_;
-  }
+  inline bool system_rebooted() override { return fake_system_rebooted_; }
 
   // Setters for the various members, can be used for overriding the default
   // implementations. For convenience, setting to a null pointer will restore
diff --git a/hardware.h b/hardware.h
index 7ab879a..1fa2edf 100644
--- a/hardware.h
+++ b/hardware.h
@@ -18,22 +18,22 @@
 class Hardware : public HardwareInterface {
  public:
   Hardware();
-  virtual ~Hardware() override;
+  ~Hardware() override;
 
   // HardwareInterface methods.
-  virtual std::string BootKernelDevice() const override;
-  virtual std::string BootDevice() const override;
-  virtual bool IsBootDeviceRemovable() const override;
-  virtual std::vector<std::string> GetKernelDevices() const override;
-  virtual bool IsKernelBootable(const std::string& kernel_device,
-                                bool* bootable) const override;
-  virtual bool MarkKernelUnbootable(const std::string& kernel_device) override;
-  virtual bool IsOfficialBuild() const override;
-  virtual bool IsNormalBootMode() const override;
-  virtual bool IsOOBEComplete(base::Time* out_time_of_oobe) const override;
-  virtual std::string GetHardwareClass() const override;
-  virtual std::string GetFirmwareVersion() const override;
-  virtual std::string GetECVersion() const override;
+  std::string BootKernelDevice() const override;
+  std::string BootDevice() const override;
+  bool IsBootDeviceRemovable() const override;
+  std::vector<std::string> GetKernelDevices() const override;
+  bool IsKernelBootable(const std::string& kernel_device,
+                        bool* bootable) const override;
+  bool MarkKernelUnbootable(const std::string& kernel_device) override;
+  bool IsOfficialBuild() const override;
+  bool IsNormalBootMode() const override;
+  bool IsOOBEComplete(base::Time* out_time_of_oobe) const override;
+  std::string GetHardwareClass() const override;
+  std::string GetFirmwareVersion() const override;
+  std::string GetECVersion() const override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Hardware);
diff --git a/payload_generator/delta_diff_generator.cc b/payload_generator/delta_diff_generator.cc
index 4a383d0..1a15f3a 100644
--- a/payload_generator/delta_diff_generator.cc
+++ b/payload_generator/delta_diff_generator.cc
@@ -262,8 +262,7 @@
 // these blocks.
 class DummyExtentAllocator {
  public:
-  explicit DummyExtentAllocator()
-      : next_block_(kTempBlockStart) {}
+  DummyExtentAllocator() : next_block_(kTempBlockStart) {}
   vector<Extent> Allocate(const uint64_t block_count) {
     vector<Extent> ret(1);
     ret[0].set_start_block(next_block_);
diff --git a/real_system_state.h b/real_system_state.h
index 81e1674..47c71ae 100644
--- a/real_system_state.h
+++ b/real_system_state.h
@@ -34,63 +34,52 @@
   // separately from construction. Returns |true| on success.
   bool Initialize();
 
-  virtual inline void set_device_policy(
+  inline void set_device_policy(
       const policy::DevicePolicy* device_policy) override {
     device_policy_ = device_policy;
   }
 
-  virtual inline const policy::DevicePolicy* device_policy() override {
+  inline const policy::DevicePolicy* device_policy() override {
     return device_policy_;
   }
 
-  virtual inline ClockInterface* clock() override {
-    return &clock_;
-  }
+  inline ClockInterface* clock() override { return &clock_; }
 
-  virtual inline ConnectionManager* connection_manager() override {
+  inline ConnectionManager* connection_manager() override {
     return &connection_manager_;
   }
 
-  virtual inline HardwareInterface* hardware() override {
-    return &hardware_;
-  }
+  inline HardwareInterface* hardware() override { return &hardware_; }
 
-  virtual inline MetricsLibraryInterface* metrics_lib() override {
+  inline MetricsLibraryInterface* metrics_lib() override {
     return &metrics_lib_;
   }
 
-  virtual inline PrefsInterface* prefs() override {
-    return &prefs_;
-  }
+  inline PrefsInterface* prefs() override { return &prefs_; }
 
-  virtual inline PrefsInterface* powerwash_safe_prefs() override {
+  inline PrefsInterface* powerwash_safe_prefs() override {
       return &powerwash_safe_prefs_;
     }
 
-  virtual inline PayloadStateInterface* payload_state() override {
+  inline PayloadStateInterface* payload_state() override {
     return &payload_state_;
   }
 
-  virtual inline UpdateAttempter* update_attempter() override {
+  inline UpdateAttempter* update_attempter() override {
     return &update_attempter_;
   }
 
-  virtual inline OmahaRequestParams* request_params() override {
+  inline OmahaRequestParams* request_params() override {
     return &request_params_;
   }
 
-  virtual inline P2PManager* p2p_manager() override {
-    return p2p_manager_.get();
-  }
+  inline P2PManager* p2p_manager() override { return p2p_manager_.get(); }
 
-  virtual inline chromeos_update_manager::UpdateManager* update_manager()
-      override {
+  inline chromeos_update_manager::UpdateManager* update_manager() override {
     return update_manager_.get();
   }
 
-  virtual inline bool system_rebooted() override {
-    return system_rebooted_;
-  }
+  inline bool system_rebooted() override { return system_rebooted_; }
 
  private:
   // Interface for the clock.
diff --git a/update_attempter.h b/update_attempter.h
index ec4cba2..f29b4e8 100644
--- a/update_attempter.h
+++ b/update_attempter.h
@@ -30,7 +30,7 @@
 struct UpdateEngineService;
 
 namespace policy {
-  class PolicyProvider;
+class PolicyProvider;
 }
 
 namespace chromeos_update_engine {
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_;