platform2: sweep the lint errors identified by the updated linter

cpplint.py has been updated and identified new issues in existing
code. Stuff like overridden functions that specify 'override' should
not be marked as 'virtual', and constructors with no parameters
should not be marked as 'explicit'.

BUG=None
TEST=cpplint.py `find ./platform2 -name *.cc -or -name *.h`

Change-Id: Ibb9de43286d874d076ffd5ebb1b13c36ec794f01
Reviewed-on: https://chromium-review.googlesource.com/211950
Reviewed-by: Alex Vakulenko <avakulenko@chromium.org>
Commit-Queue: Alex Vakulenko <avakulenko@chromium.org>
Tested-by: Alex Vakulenko <avakulenko@chromium.org>

25 files changed, 178 insertions, 231 deletions

diff --git a/fake_hardware.h b/fake_hardware.h
index 5b48ce23..ff80009b 100644
--- a/fake_hardware.h
+++ b/fake_hardware.h
@@ -31,53 +31,45 @@ class FakeHardware : public HardwareInterface {
       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 062cbbb5..3a4f6b78 100644
--- a/fake_system_state.h
+++ b/fake_system_state.h
@@ -33,63 +33,52 @@ class FakeSystemState : public SystemState {
   // 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 7ab879a0..1fa2edf9 100644
--- a/hardware.h
+++ b/hardware.h
@@ -18,22 +18,22 @@ namespace chromeos_update_engine {
 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 4a383d09..1a15f3a7 100644
--- a/payload_generator/delta_diff_generator.cc
+++ b/payload_generator/delta_diff_generator.cc
@@ -262,8 +262,7 @@ bool DeltaReadFiles(Graph* graph,
 // 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 81e16744..47c71aee 100644
--- a/real_system_state.h
+++ b/real_system_state.h
@@ -34,63 +34,52 @@ class RealSystemState : public SystemState {
   // 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 ec4cba2a..f29b4e82 100644
--- a/update_attempter.h
+++ b/update_attempter.h
@@ -30,7 +30,7 @@ class MetricsLibraryInterface;
 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 889adbd7..7c23612d 100644
--- a/update_manager/chromeos_policy.h
+++ b/update_manager/chromeos_policy.h
@@ -35,11 +35,11 @@ class ChromeOSPolicy : public Policy {
   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 @@ class ChromeOSPolicy : public Policy {
       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 @@ class ChromeOSPolicy : public Policy {
 
  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 2fb1a06b..526476ca 100644
--- a/update_manager/default_policy.h
+++ b/update_manager/default_policy.h
@@ -52,11 +52,11 @@ class DefaultPolicy : public Policy {
   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 @@ class DefaultPolicy : public Policy {
     return EvalStatus::kSucceeded;
   }
 
-  virtual EvalStatus UpdateDownloadAllowed(
+  EvalStatus UpdateDownloadAllowed(
       EvaluationContext* ec,
       State* state,
       std::string* error,
@@ -84,9 +84,7 @@ class DefaultPolicy : public Policy {
 
  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 fab01d17..56249438 100644
--- a/update_manager/fake_config_provider.h
+++ b/update_manager/fake_config_provider.h
@@ -15,7 +15,7 @@ class FakeConfigProvider : public ConfigProvider {
  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 6f53393d..54e419a8 100644
--- a/update_manager/fake_device_policy_provider.h
+++ b/update_manager/fake_device_policy_provider.h
@@ -18,44 +18,44 @@ class FakeDevicePolicyProvider : public DevicePolicyProvider {
  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 4483635d..9f2bc353 100644
--- a/update_manager/fake_random_provider.h
+++ b/update_manager/fake_random_provider.h
@@ -15,7 +15,7 @@ class FakeRandomProvider : public RandomProvider {
  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 fb38c61c..12cfe1d2 100644
--- a/update_manager/fake_shill_provider.h
+++ b/update_manager/fake_shill_provider.h
@@ -15,20 +15,20 @@ class FakeShillProvider : public ShillProvider {
  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 f47aa78c..9c1ff01a 100644
--- a/update_manager/fake_state.h
+++ b/update_manager/fake_state.h
@@ -34,31 +34,31 @@ class FakeState : public State {
   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 47cd5ac5..6b7151b5 100644
--- a/update_manager/fake_system_provider.h
+++ b/update_manager/fake_system_provider.h
@@ -15,19 +15,19 @@ class FakeSystemProvider : public SystemProvider {
  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 97858a3f..a60405bb 100644
--- a/update_manager/fake_time_provider.h
+++ b/update_manager/fake_time_provider.h
@@ -15,13 +15,8 @@ class FakeTimeProvider : public TimeProvider {
  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 fa3b869c..f2295a58 100644
--- a/update_manager/fake_updater_provider.h
+++ b/update_manager/fake_updater_provider.h
@@ -17,61 +17,59 @@ class FakeUpdaterProvider : public UpdaterProvider {
  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 c86a2f55..4b75d68a 100644
--- a/update_manager/real_device_policy_provider.h
+++ b/update_manager/real_device_policy_provider.h
@@ -27,44 +27,44 @@ class RealDevicePolicyProvider : public DevicePolicyProvider {
   // 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 b243a558..2e36d6f5 100644
--- a/update_manager/real_random_provider.h
+++ b/update_manager/real_random_provider.h
@@ -16,7 +16,7 @@ class RealRandomProvider : public RandomProvider {
  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 68f095e6..382aa1e7 100644
--- a/update_manager/real_shill_provider.h
+++ b/update_manager/real_shill_provider.h
@@ -34,19 +34,19 @@ class RealShillProvider : public ShillProvider {
   // 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 69632fbe..1e2d10e1 100644
--- a/update_manager/real_state.h
+++ b/update_manager/real_state.h
@@ -32,25 +32,25 @@ class RealState : public State {
       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 d1e20bee..c0408551 100644
--- a/update_manager/real_system_provider.h
+++ b/update_manager/real_system_provider.h
@@ -24,19 +24,19 @@ class RealSystemProvider : public SystemProvider {
   // 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 069d2d21..ff5598eb 100644
--- a/update_manager/real_time_provider.h
+++ b/update_manager/real_time_provider.h
@@ -22,11 +22,11 @@ class RealTimeProvider : public TimeProvider {
   // 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 7dae7144..c525b8f0 100644
--- a/update_manager/real_updater_provider.cc
+++ b/update_manager/real_updater_provider.cc
@@ -78,8 +78,7 @@ class LastCheckedTimeVariable : public UpdaterVariableBase<Time> {
       : 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 @@ class ProgressVariable : public UpdaterVariableBase<double> {
       : 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 @@ class StageVariable : public UpdaterVariableBase<Stage> {
   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 @@ class NewVersionVariable : public UpdaterVariableBase<string> {
       : 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 @@ class PayloadSizeVariable : public UpdaterVariableBase<int64_t> {
       : 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 @@ class UpdateCompletedTimeVariable : public UpdaterVariableBase<Time> {
       : 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 @@ class CurrChannelVariable : public UpdaterVariableBase<string> {
       : 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 @@ class NewChannelVariable : public UpdaterVariableBase<string> {
       : 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 @@ class BooleanPrefVariable : public UpdaterVariableBase<bool> {
         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 @@ class ConsecutiveFailedUpdateChecksVariable
                                           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 @@ class ServerDictatedPollIntervalVariable
                                           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 @@ class InteractiveUpdateRequestedVariable : public UpdaterVariableBase<bool> {
   }
 
  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 6a3bc197..5c40acdc 100644
--- a/update_manager/real_updater_provider.h
+++ b/update_manager/real_updater_provider.h
@@ -29,61 +29,59 @@ class RealUpdaterProvider : public UpdaterProvider {
   // 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 cb9b61bc..f6a1c01d 100644
--- a/update_manager/update_manager_unittest.cc
+++ b/update_manager/update_manager_unittest.cc
@@ -58,7 +58,7 @@ namespace chromeos_update_manager {
 
 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 @@ class FailingPolicy : public DefaultPolicy {
  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 @@ class FailingPolicy : public DefaultPolicy {
   }
 
  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 @@ class FailingPolicy : public DefaultPolicy {
 
 // 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 @@ class DelayPolicy : public DefaultPolicy {
   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 @@ class DelayPolicy : public DefaultPolicy {
   }
 
  protected:
-  virtual std::string PolicyName() const override { return "DelayPolicy"; }
+  std::string PolicyName() const override { return "DelayPolicy"; }
 
  private:
   int sleep_secs_;