Standardize usage of virtual/override/final in components/

BUG=417463
TBR=blundell@chromium.org

Review URL: https://codereview.chromium.org/666133002

Cr-Commit-Position: refs/heads/master@{#300456}

16 files changed, 238 insertions, 256 deletions

diff --git a/components/gcm_driver/default_gcm_app_handler.h b/components/gcm_driver/default_gcm_app_handler.h
index ffe382b..bfe76a11 100644
--- a/components/gcm_driver/default_gcm_app_handler.h
+++ b/components/gcm_driver/default_gcm_app_handler.h
@@ -15,18 +15,18 @@ namespace gcm {
 class DefaultGCMAppHandler : public GCMAppHandler {
  public:
   DefaultGCMAppHandler();
-  virtual ~DefaultGCMAppHandler();
+  ~DefaultGCMAppHandler() override;
 
   // Overridden from GCMAppHandler:
-  virtual void ShutdownHandler() override;
-  virtual void OnMessage(const std::string& app_id,
-                         const GCMClient::IncomingMessage& message) override;
-  virtual void OnMessagesDeleted(const std::string& app_id) override;
-  virtual void OnSendError(
+  void ShutdownHandler() override;
+  void OnMessage(const std::string& app_id,
+                 const GCMClient::IncomingMessage& message) override;
+  void OnMessagesDeleted(const std::string& app_id) override;
+  void OnSendError(
       const std::string& app_id,
       const GCMClient::SendErrorDetails& send_error_details) override;
-  virtual void OnSendAcknowledged(const std::string& app_id,
-                                  const std::string& message_id) override;
+  void OnSendAcknowledged(const std::string& app_id,
+                          const std::string& message_id) override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DefaultGCMAppHandler);
diff --git a/components/gcm_driver/fake_gcm_app_handler.h b/components/gcm_driver/fake_gcm_app_handler.h
index 4943534..29fcd29 100644
--- a/components/gcm_driver/fake_gcm_app_handler.h
+++ b/components/gcm_driver/fake_gcm_app_handler.h
@@ -25,7 +25,7 @@ class FakeGCMAppHandler : public GCMAppHandler {
   };
 
   FakeGCMAppHandler();
-  virtual ~FakeGCMAppHandler();
+  ~FakeGCMAppHandler() override;
 
   const Event& received_event() const { return received_event_; }
   const std::string& app_id() const { return app_id_; }
@@ -38,15 +38,15 @@ class FakeGCMAppHandler : public GCMAppHandler {
   void WaitForNotification();
 
   // GCMAppHandler implementation.
-  virtual void ShutdownHandler() override;
-  virtual void OnMessage(const std::string& app_id,
-                         const GCMClient::IncomingMessage& message) override;
-  virtual void OnMessagesDeleted(const std::string& app_id) override;
-  virtual void OnSendError(
+  void ShutdownHandler() override;
+  void OnMessage(const std::string& app_id,
+                 const GCMClient::IncomingMessage& message) override;
+  void OnMessagesDeleted(const std::string& app_id) override;
+  void OnSendError(
       const std::string& app_id,
       const GCMClient::SendErrorDetails& send_error_details) override;
-  virtual void OnSendAcknowledged(const std::string& app_id,
-                                  const std::string& message_id) override;
+  void OnSendAcknowledged(const std::string& app_id,
+                          const std::string& message_id) override;
 
  private:
   void ClearResults();
diff --git a/components/gcm_driver/fake_gcm_client.h b/components/gcm_driver/fake_gcm_client.h
index fa91bbc..f4ac33a 100644
--- a/components/gcm_driver/fake_gcm_client.h
+++ b/components/gcm_driver/fake_gcm_client.h
@@ -32,11 +32,11 @@ class FakeGCMClient : public GCMClient {
   FakeGCMClient(StartMode start_mode,
                 const scoped_refptr<base::SequencedTaskRunner>& ui_thread,
                 const scoped_refptr<base::SequencedTaskRunner>& io_thread);
-  virtual ~FakeGCMClient();
+  ~FakeGCMClient() override;
 
   // Overridden from GCMClient:
   // Called on IO thread.
-  virtual void Initialize(
+  void Initialize(
       const ChromeBuildInfo& chrome_build_info,
       const base::FilePath& store_path,
       const scoped_refptr<base::SequencedTaskRunner>& blocking_task_runner,
@@ -44,23 +44,22 @@ class FakeGCMClient : public GCMClient {
           url_request_context_getter,
       scoped_ptr<Encryptor> encryptor,
       Delegate* delegate) override;
-  virtual void Start() override;
-  virtual void Stop() override;
-  virtual void CheckOut() override;
-  virtual void Register(const std::string& app_id,
-                        const std::vector<std::string>& sender_ids) override;
-  virtual void Unregister(const std::string& app_id) override;
-  virtual void Send(const std::string& app_id,
-                    const std::string& receiver_id,
-                    const OutgoingMessage& message) override;
-  virtual void SetRecording(bool recording) override;
-  virtual void ClearActivityLogs() override;
-  virtual GCMStatistics GetStatistics() const override;
-  virtual void SetAccountTokens(
+  void Start() override;
+  void Stop() override;
+  void CheckOut() override;
+  void Register(const std::string& app_id,
+                const std::vector<std::string>& sender_ids) override;
+  void Unregister(const std::string& app_id) override;
+  void Send(const std::string& app_id,
+            const std::string& receiver_id,
+            const OutgoingMessage& message) override;
+  void SetRecording(bool recording) override;
+  void ClearActivityLogs() override;
+  GCMStatistics GetStatistics() const override;
+  void SetAccountTokens(
       const std::vector<AccountTokenInfo>& account_tokens) override;
-  virtual void UpdateAccountMapping(
-      const AccountMapping& account_mapping) override;
-  virtual void RemoveAccountMapping(const std::string& account_id) override;
+  void UpdateAccountMapping(const AccountMapping& account_mapping) override;
+  void RemoveAccountMapping(const std::string& account_id) override;
 
   // Initiate the loading that has been delayed.
   // Called on UI thread.
diff --git a/components/gcm_driver/fake_gcm_client_factory.h b/components/gcm_driver/fake_gcm_client_factory.h
index 6ccb0e2..949c225 100644
--- a/components/gcm_driver/fake_gcm_client_factory.h
+++ b/components/gcm_driver/fake_gcm_client_factory.h
@@ -24,10 +24,10 @@ class FakeGCMClientFactory : public GCMClientFactory {
       FakeGCMClient::StartMode gcm_client_start_mode,
       const scoped_refptr<base::SequencedTaskRunner>& ui_thread,
       const scoped_refptr<base::SequencedTaskRunner>& io_thread);
-  virtual ~FakeGCMClientFactory();
+  ~FakeGCMClientFactory() override;
 
   // GCMClientFactory:
-  virtual scoped_ptr<GCMClient> BuildInstance() override;
+  scoped_ptr<GCMClient> BuildInstance() override;
 
  private:
   FakeGCMClient::StartMode gcm_client_start_mode_;
diff --git a/components/gcm_driver/fake_gcm_driver.h b/components/gcm_driver/fake_gcm_driver.h
index 366881e..e1e5d02 100644
--- a/components/gcm_driver/fake_gcm_driver.h
+++ b/components/gcm_driver/fake_gcm_driver.h
@@ -14,44 +14,41 @@ namespace gcm {
 class FakeGCMDriver : public GCMDriver {
  public:
   FakeGCMDriver();
-  virtual ~FakeGCMDriver();
+  ~FakeGCMDriver() override;
 
   // GCMDriver overrides:
-  virtual void Shutdown() override;
-  virtual void AddAppHandler(const std::string& app_id,
-                             GCMAppHandler* handler) override;
-  virtual void RemoveAppHandler(const std::string& app_id) override;
-  virtual void OnSignedIn() override;
-  virtual void OnSignedOut() override;
-  virtual void Purge() override;
-  virtual void AddConnectionObserver(GCMConnectionObserver* observer) override;
-  virtual void RemoveConnectionObserver(
-      GCMConnectionObserver* observer) override;
-  virtual void Enable() override;
-  virtual void Disable() override;
-  virtual GCMClient* GetGCMClientForTesting() const override;
-  virtual bool IsStarted() const override;
-  virtual bool IsConnected() const override;
-  virtual void GetGCMStatistics(const GetGCMStatisticsCallback& callback,
-                                bool clear_logs) override;
-  virtual void SetGCMRecording(const GetGCMStatisticsCallback& callback,
-                               bool recording) override;
-  virtual void SetAccountTokens(
+  void Shutdown() override;
+  void AddAppHandler(const std::string& app_id,
+                     GCMAppHandler* handler) override;
+  void RemoveAppHandler(const std::string& app_id) override;
+  void OnSignedIn() override;
+  void OnSignedOut() override;
+  void Purge() override;
+  void AddConnectionObserver(GCMConnectionObserver* observer) override;
+  void RemoveConnectionObserver(GCMConnectionObserver* observer) override;
+  void Enable() override;
+  void Disable() override;
+  GCMClient* GetGCMClientForTesting() const override;
+  bool IsStarted() const override;
+  bool IsConnected() const override;
+  void GetGCMStatistics(const GetGCMStatisticsCallback& callback,
+                        bool clear_logs) override;
+  void SetGCMRecording(const GetGCMStatisticsCallback& callback,
+                       bool recording) override;
+  void SetAccountTokens(
       const std::vector<GCMClient::AccountTokenInfo>& account_tokens) override;
-  virtual void UpdateAccountMapping(
-      const AccountMapping& account_mapping) override;
-  virtual void RemoveAccountMapping(const std::string& account_id) override;
+  void UpdateAccountMapping(const AccountMapping& account_mapping) override;
+  void RemoveAccountMapping(const std::string& account_id) override;
 
  protected:
   // GCMDriver implementation:
-  virtual GCMClient::Result EnsureStarted() override;
-  virtual void RegisterImpl(
-      const std::string& app_id,
-      const std::vector<std::string>& sender_ids) override;
-  virtual void UnregisterImpl(const std::string& app_id) override;
-  virtual void SendImpl(const std::string& app_id,
-                        const std::string& receiver_id,
-                        const GCMClient::OutgoingMessage& message) override;
+  GCMClient::Result EnsureStarted() override;
+  void RegisterImpl(const std::string& app_id,
+                    const std::vector<std::string>& sender_ids) override;
+  void UnregisterImpl(const std::string& app_id) override;
+  void SendImpl(const std::string& app_id,
+                const std::string& receiver_id,
+                const GCMClient::OutgoingMessage& message) override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FakeGCMDriver);
diff --git a/components/gcm_driver/gcm_account_mapper.h b/components/gcm_driver/gcm_account_mapper.h
index dc4c601..5616236 100644
--- a/components/gcm_driver/gcm_account_mapper.h
+++ b/components/gcm_driver/gcm_account_mapper.h
@@ -31,7 +31,7 @@ class GCMAccountMapper : public GCMAppHandler {
   typedef std::vector<AccountMapping> AccountMappings;
 
   explicit GCMAccountMapper(GCMDriver* gcm_driver);
-  virtual ~GCMAccountMapper();
+  ~GCMAccountMapper() override;
 
   void Initialize(const AccountMappings& account_mappings);
 
@@ -41,16 +41,16 @@ class GCMAccountMapper : public GCMAppHandler {
       const std::vector<GCMClient::AccountTokenInfo>& account_tokens);
 
   // Implementation of GCMAppHandler:
-  virtual void ShutdownHandler() override;
-  virtual void OnMessage(const std::string& app_id,
-                         const GCMClient::IncomingMessage& message) override;
-  virtual void OnMessagesDeleted(const std::string& app_id) override;
-  virtual void OnSendError(
+  void ShutdownHandler() override;
+  void OnMessage(const std::string& app_id,
+                 const GCMClient::IncomingMessage& message) override;
+  void OnMessagesDeleted(const std::string& app_id) override;
+  void OnSendError(
       const std::string& app_id,
       const GCMClient::SendErrorDetails& send_error_details) override;
-  virtual void OnSendAcknowledged(const std::string& app_id,
-                                  const std::string& message_id) override;
-  virtual bool CanHandle(const std::string& app_id) const override;
+  void OnSendAcknowledged(const std::string& app_id,
+                          const std::string& message_id) override;
+  bool CanHandle(const std::string& app_id) const override;
 
  private:
   friend class GCMAccountMapperTest;
diff --git a/components/gcm_driver/gcm_account_mapper_unittest.cc b/components/gcm_driver/gcm_account_mapper_unittest.cc
index bf8fdf0..b714e92 100644
--- a/components/gcm_driver/gcm_account_mapper_unittest.cc
+++ b/components/gcm_driver/gcm_account_mapper_unittest.cc
@@ -78,17 +78,15 @@ class CustomFakeGCMDriver : public FakeGCMDriver {
   };
 
   CustomFakeGCMDriver();
-  virtual ~CustomFakeGCMDriver();
-
-  virtual void UpdateAccountMapping(
-      const AccountMapping& account_mapping) override;
-  virtual void RemoveAccountMapping(const std::string& account_id) override;
-  virtual void AddAppHandler(const std::string& app_id,
-                             GCMAppHandler* handler) override;
-  virtual void RemoveAppHandler(const std::string& app_id) override;
-  virtual void RegisterImpl(
-      const std::string& app_id,
-      const std::vector<std::string>& sender_ids) override;
+  ~CustomFakeGCMDriver() override;
+
+  void UpdateAccountMapping(const AccountMapping& account_mapping) override;
+  void RemoveAccountMapping(const std::string& account_id) override;
+  void AddAppHandler(const std::string& app_id,
+                     GCMAppHandler* handler) override;
+  void RemoveAppHandler(const std::string& app_id) override;
+  void RegisterImpl(const std::string& app_id,
+                    const std::vector<std::string>& sender_ids) override;
 
   void CompleteRegister(const std::string& registration_id,
                         GCMClient::Result result);
@@ -114,9 +112,9 @@ class CustomFakeGCMDriver : public FakeGCMDriver {
   bool registration_id_requested() const { return registration_id_requested_; }
 
  protected:
-  virtual void SendImpl(const std::string& app_id,
-                        const std::string& receiver_id,
-                        const GCMClient::OutgoingMessage& message) override;
+  void SendImpl(const std::string& app_id,
+                const std::string& receiver_id,
+                const GCMClient::OutgoingMessage& message) override;
 
  private:
   AccountMapping account_mapping_;
diff --git a/components/gcm_driver/gcm_activity.h b/components/gcm_driver/gcm_activity.h
index 0d3da0c..2209cb0 100644
--- a/components/gcm_driver/gcm_activity.h
+++ b/components/gcm_driver/gcm_activity.h
@@ -25,19 +25,19 @@ struct Activity {
 // Contains relevant data of a connection activity.
 struct ConnectionActivity : Activity {
   ConnectionActivity();
-  virtual ~ConnectionActivity();
+  ~ConnectionActivity() override;
 };
 
 // Contains relevant data of a check-in activity.
 struct CheckinActivity : Activity {
   CheckinActivity();
-  virtual ~CheckinActivity();
+  ~CheckinActivity() override;
 };
 
 // Contains relevant data of a registration/unregistration step.
 struct RegistrationActivity : Activity {
   RegistrationActivity();
-  virtual ~RegistrationActivity();
+  ~RegistrationActivity() override;
 
   std::string app_id;
   std::string sender_ids;  // Comma separated sender ids.
@@ -46,7 +46,7 @@ struct RegistrationActivity : Activity {
 // Contains relevant data of a message receiving event.
 struct ReceivingActivity : Activity {
   ReceivingActivity();
-  virtual ~ReceivingActivity();
+  ~ReceivingActivity() override;
 
   std::string app_id;
   std::string from;
@@ -56,7 +56,7 @@ struct ReceivingActivity : Activity {
 // Contains relevant data of a send-message step.
 struct SendingActivity : Activity {
   SendingActivity();
-  virtual ~SendingActivity();
+  ~SendingActivity() override;
 
   std::string app_id;
   std::string receiver_id;
diff --git a/components/gcm_driver/gcm_channel_status_request.h b/components/gcm_driver/gcm_channel_status_request.h
index e1ddf15..1be074f 100644
--- a/components/gcm_driver/gcm_channel_status_request.h
+++ b/components/gcm_driver/gcm_channel_status_request.h
@@ -42,7 +42,7 @@ class GCMChannelStatusRequest : public net::URLFetcherDelegate {
       const std::string& channel_status_request_url,
       const std::string& user_agent,
       const GCMChannelStatusRequestCallback& callback);
-  virtual ~GCMChannelStatusRequest();
+  ~GCMChannelStatusRequest() override;
 
   void Start();
 
@@ -53,7 +53,7 @@ class GCMChannelStatusRequest : public net::URLFetcherDelegate {
   FRIEND_TEST_ALL_PREFIXES(GCMChannelStatusRequestTest, RequestData);
 
   // Overridden from URLFetcherDelegate:
-  virtual void OnURLFetchComplete(const net::URLFetcher* source) override;
+  void OnURLFetchComplete(const net::URLFetcher* source) override;
 
   bool ParseResponse(const net::URLFetcher* source);
   void RetryWithBackoff(bool update_backoff);
diff --git a/components/gcm_driver/gcm_client_impl.h b/components/gcm_driver/gcm_client_impl.h
index 6abe149..a20cb12 100644
--- a/components/gcm_driver/gcm_client_impl.h
+++ b/components/gcm_driver/gcm_client_impl.h
@@ -80,10 +80,10 @@ class GCMClientImpl
       public ConnectionFactory::ConnectionListener {
  public:
   explicit GCMClientImpl(scoped_ptr<GCMInternalsBuilder> internals_builder);
-  virtual ~GCMClientImpl();
+  ~GCMClientImpl() override;
 
   // GCMClient implementation.
-  virtual void Initialize(
+  void Initialize(
       const ChromeBuildInfo& chrome_build_info,
       const base::FilePath& store_path,
       const scoped_refptr<base::SequencedTaskRunner>& blocking_task_runner,
@@ -91,31 +91,30 @@ class GCMClientImpl
           url_request_context_getter,
       scoped_ptr<Encryptor> encryptor,
       GCMClient::Delegate* delegate) override;
-  virtual void Start() override;
-  virtual void Stop() override;
-  virtual void CheckOut() override;
-  virtual void Register(const std::string& app_id,
-                        const std::vector<std::string>& sender_ids) override;
-  virtual void Unregister(const std::string& app_id) override;
-  virtual void Send(const std::string& app_id,
-                    const std::string& receiver_id,
-                    const OutgoingMessage& message) override;
-  virtual void SetRecording(bool recording) override;
-  virtual void ClearActivityLogs() override;
-  virtual GCMStatistics GetStatistics() const override;
-  virtual void SetAccountTokens(
+  void Start() override;
+  void Stop() override;
+  void CheckOut() override;
+  void Register(const std::string& app_id,
+                const std::vector<std::string>& sender_ids) override;
+  void Unregister(const std::string& app_id) override;
+  void Send(const std::string& app_id,
+            const std::string& receiver_id,
+            const OutgoingMessage& message) override;
+  void SetRecording(bool recording) override;
+  void ClearActivityLogs() override;
+  GCMStatistics GetStatistics() const override;
+  void SetAccountTokens(
       const std::vector<AccountTokenInfo>& account_tokens) override;
-  virtual void UpdateAccountMapping(
-      const AccountMapping& account_mapping) override;
-  virtual void RemoveAccountMapping(const std::string& account_id) override;
+  void UpdateAccountMapping(const AccountMapping& account_mapping) override;
+  void RemoveAccountMapping(const std::string& account_id) override;
 
   // GCMStatsRecorder::Delegate implemenation.
-  virtual void OnActivityRecorded() override;
+  void OnActivityRecorded() override;
 
   // ConnectionFactory::ConnectionListener implementation.
-  virtual void OnConnected(const GURL& current_server,
-                           const net::IPEndPoint& ip_endpoint) override;
-  virtual void OnDisconnected() override;
+  void OnConnected(const GURL& current_server,
+                   const net::IPEndPoint& ip_endpoint) override;
+  void OnDisconnected() override;
 
  private:
   // State representation of the GCMClient.
diff --git a/components/gcm_driver/gcm_client_impl_unittest.cc b/components/gcm_driver/gcm_client_impl_unittest.cc
index 198ed8c..270641b 100644
--- a/components/gcm_driver/gcm_client_impl_unittest.cc
+++ b/components/gcm_driver/gcm_client_impl_unittest.cc
@@ -92,9 +92,9 @@ class FakeMCSClient : public MCSClient {
                 ConnectionFactory* connection_factory,
                 GCMStore* gcm_store,
                 GCMStatsRecorder* recorder);
-  virtual ~FakeMCSClient();
-  virtual void Login(uint64 android_id, uint64 security_token) override;
-  virtual void SendMessage(const MCSMessage& message) override;
+  ~FakeMCSClient() override;
+  void Login(uint64 android_id, uint64 security_token) override;
+  void SendMessage(const MCSMessage& message) override;
 
   uint64 last_android_id() const { return last_android_id_; }
   uint64 last_security_token() const { return last_security_token_; }
@@ -140,9 +140,9 @@ void FakeMCSClient::SendMessage(const MCSMessage& message) {
 class AutoAdvancingTestClock : public base::Clock {
  public:
   explicit AutoAdvancingTestClock(base::TimeDelta auto_increment_time_delta);
-  virtual ~AutoAdvancingTestClock();
+  ~AutoAdvancingTestClock() override;
 
-  virtual base::Time Now() override;
+  base::Time Now() override;
   void Advance(TimeDelta delta);
   int call_count() const { return call_count_; }
 
@@ -175,16 +175,15 @@ void AutoAdvancingTestClock::Advance(base::TimeDelta delta) {
 class FakeGCMInternalsBuilder : public GCMInternalsBuilder {
  public:
   FakeGCMInternalsBuilder(base::TimeDelta clock_step);
-  virtual ~FakeGCMInternalsBuilder();
-
-  virtual scoped_ptr<base::Clock> BuildClock() override;
-  virtual scoped_ptr<MCSClient> BuildMCSClient(
-      const std::string& version,
-      base::Clock* clock,
-      ConnectionFactory* connection_factory,
-      GCMStore* gcm_store,
-      GCMStatsRecorder* recorder) override;
-  virtual scoped_ptr<ConnectionFactory> BuildConnectionFactory(
+  ~FakeGCMInternalsBuilder() override;
+
+  scoped_ptr<base::Clock> BuildClock() override;
+  scoped_ptr<MCSClient> BuildMCSClient(const std::string& version,
+                                       base::Clock* clock,
+                                       ConnectionFactory* connection_factory,
+                                       GCMStore* gcm_store,
+                                       GCMStatsRecorder* recorder) override;
+  scoped_ptr<ConnectionFactory> BuildConnectionFactory(
       const std::vector<GURL>& endpoints,
       const net::BackoffEntry::Policy& backoff_policy,
       const scoped_refptr<net::HttpNetworkSession>& gcm_network_session,
@@ -260,28 +259,26 @@ class GCMClientImplTest : public testing::Test,
                        const std::string& registration_id);
 
   // GCMClient::Delegate overrides (for verification).
-  virtual void OnRegisterFinished(const std::string& app_id,
-                                  const std::string& registration_id,
-                                  GCMClient::Result result) override;
-  virtual void OnUnregisterFinished(const std::string& app_id,
-                                    GCMClient::Result result) override;
-  virtual void OnSendFinished(const std::string& app_id,
-                              const std::string& message_id,
-                              GCMClient::Result result) override {}
-  virtual void OnMessageReceived(const std::string& registration_id,
-                                 const GCMClient::IncomingMessage& message)
-      override;
-  virtual void OnMessagesDeleted(const std::string& app_id) override;
-  virtual void OnMessageSendError(
+  void OnRegisterFinished(const std::string& app_id,
+                          const std::string& registration_id,
+                          GCMClient::Result result) override;
+  void OnUnregisterFinished(const std::string& app_id,
+                            GCMClient::Result result) override;
+  void OnSendFinished(const std::string& app_id,
+                      const std::string& message_id,
+                      GCMClient::Result result) override {}
+  void OnMessageReceived(const std::string& registration_id,
+                         const GCMClient::IncomingMessage& message) override;
+  void OnMessagesDeleted(const std::string& app_id) override;
+  void OnMessageSendError(
       const std::string& app_id,
       const gcm::GCMClient::SendErrorDetails& send_error_details) override;
-  virtual void OnSendAcknowledged(const std::string& app_id,
-                                  const std::string& message_id) override;
-  virtual void OnGCMReady(
-      const std::vector<AccountMapping>& account_mappings) override;
-  virtual void OnActivityRecorded() override {}
-  virtual void OnConnected(const net::IPEndPoint& ip_endpoint) override {}
-  virtual void OnDisconnected() override {}
+  void OnSendAcknowledged(const std::string& app_id,
+                          const std::string& message_id) override;
+  void OnGCMReady(const std::vector<AccountMapping>& account_mappings) override;
+  void OnActivityRecorded() override {}
+  void OnConnected(const net::IPEndPoint& ip_endpoint) override {}
+  void OnDisconnected() override {}
 
   GCMClientImpl* gcm_client() const { return gcm_client_.get(); }
   FakeMCSClient* mcs_client() const {
diff --git a/components/gcm_driver/gcm_driver_desktop.cc b/components/gcm_driver/gcm_driver_desktop.cc
index 35e2a81..fc0c36a 100644
--- a/components/gcm_driver/gcm_driver_desktop.cc
+++ b/components/gcm_driver/gcm_driver_desktop.cc
@@ -35,28 +35,26 @@ class GCMDriverDesktop::IOWorker : public GCMClient::Delegate {
 
   // Overridden from GCMClient::Delegate:
   // Called on IO thread.
-  virtual void OnRegisterFinished(const std::string& app_id,
-                                  const std::string& registration_id,
-                                  GCMClient::Result result) override;
-  virtual void OnUnregisterFinished(const std::string& app_id,
-                                    GCMClient::Result result) override;
-  virtual void OnSendFinished(const std::string& app_id,
-                              const std::string& message_id,
-                              GCMClient::Result result) override;
-  virtual void OnMessageReceived(
-      const std::string& app_id,
-      const GCMClient::IncomingMessage& message) override;
-  virtual void OnMessagesDeleted(const std::string& app_id) override;
-  virtual void OnMessageSendError(
+  void OnRegisterFinished(const std::string& app_id,
+                          const std::string& registration_id,
+                          GCMClient::Result result) override;
+  void OnUnregisterFinished(const std::string& app_id,
+                            GCMClient::Result result) override;
+  void OnSendFinished(const std::string& app_id,
+                      const std::string& message_id,
+                      GCMClient::Result result) override;
+  void OnMessageReceived(const std::string& app_id,
+                         const GCMClient::IncomingMessage& message) override;
+  void OnMessagesDeleted(const std::string& app_id) override;
+  void OnMessageSendError(
       const std::string& app_id,
       const GCMClient::SendErrorDetails& send_error_details) override;
-  virtual void OnSendAcknowledged(const std::string& app_id,
-                                  const std::string& message_id) override;
-  virtual void OnGCMReady(
-      const std::vector<AccountMapping>& account_mappings) override;
-  virtual void OnActivityRecorded() override;
-  virtual void OnConnected(const net::IPEndPoint& ip_endpoint) override;
-  virtual void OnDisconnected() override;
+  void OnSendAcknowledged(const std::string& app_id,
+                          const std::string& message_id) override;
+  void OnGCMReady(const std::vector<AccountMapping>& account_mappings) override;
+  void OnActivityRecorded() override;
+  void OnConnected(const net::IPEndPoint& ip_endpoint) override;
+  void OnDisconnected() override;
 
   // Called on IO thread.
   void Initialize(
diff --git a/components/gcm_driver/gcm_driver_desktop.h b/components/gcm_driver/gcm_driver_desktop.h
index 8cfb733..7267de0 100644
--- a/components/gcm_driver/gcm_driver_desktop.h
+++ b/components/gcm_driver/gcm_driver_desktop.h
@@ -56,33 +56,31 @@ class GCMDriverDesktop : public GCMDriver {
       const scoped_refptr<base::SequencedTaskRunner>& ui_thread,
       const scoped_refptr<base::SequencedTaskRunner>& io_thread,
       const scoped_refptr<base::SequencedTaskRunner>& blocking_task_runner);
-  virtual ~GCMDriverDesktop();
+  ~GCMDriverDesktop() override;
 
   // GCMDriver overrides:
-  virtual void Shutdown() override;
-  virtual void OnSignedIn() override;
-  virtual void OnSignedOut() override;
-  virtual void Purge() override;
-  virtual void AddAppHandler(const std::string& app_id,
-                             GCMAppHandler* handler) override;
-  virtual void RemoveAppHandler(const std::string& app_id) override;
-  virtual void AddConnectionObserver(GCMConnectionObserver* observer) override;
-  virtual void RemoveConnectionObserver(
-      GCMConnectionObserver* observer) override;
-  virtual void Enable() override;
-  virtual void Disable() override;
-  virtual GCMClient* GetGCMClientForTesting() const override;
-  virtual bool IsStarted() const override;
-  virtual bool IsConnected() const override;
-  virtual void GetGCMStatistics(const GetGCMStatisticsCallback& callback,
-                                bool clear_logs) override;
-  virtual void SetGCMRecording(const GetGCMStatisticsCallback& callback,
-                               bool recording) override;
-  virtual void SetAccountTokens(
+  void Shutdown() override;
+  void OnSignedIn() override;
+  void OnSignedOut() override;
+  void Purge() override;
+  void AddAppHandler(const std::string& app_id,
+                     GCMAppHandler* handler) override;
+  void RemoveAppHandler(const std::string& app_id) override;
+  void AddConnectionObserver(GCMConnectionObserver* observer) override;
+  void RemoveConnectionObserver(GCMConnectionObserver* observer) override;
+  void Enable() override;
+  void Disable() override;
+  GCMClient* GetGCMClientForTesting() const override;
+  bool IsStarted() const override;
+  bool IsConnected() const override;
+  void GetGCMStatistics(const GetGCMStatisticsCallback& callback,
+                        bool clear_logs) override;
+  void SetGCMRecording(const GetGCMStatisticsCallback& callback,
+                       bool recording) override;
+  void SetAccountTokens(
       const std::vector<GCMClient::AccountTokenInfo>& account_tokens) override;
-  virtual void UpdateAccountMapping(
-      const AccountMapping& account_mapping) override;
-  virtual void RemoveAccountMapping(const std::string& account_id) override;
+  void UpdateAccountMapping(const AccountMapping& account_mapping) override;
+  void RemoveAccountMapping(const std::string& account_id) override;
 
   // Exposed for testing purpose.
   bool gcm_enabled() const { return gcm_enabled_; }
@@ -92,14 +90,13 @@ class GCMDriverDesktop : public GCMDriver {
 
  protected:
   // GCMDriver implementation:
-  virtual GCMClient::Result EnsureStarted() override;
-  virtual void RegisterImpl(
-      const std::string& app_id,
-      const std::vector<std::string>& sender_ids) override;
-  virtual void UnregisterImpl(const std::string& app_id) override;
-  virtual void SendImpl(const std::string& app_id,
-                        const std::string& receiver_id,
-                        const GCMClient::OutgoingMessage& message) override;
+  GCMClient::Result EnsureStarted() override;
+  void RegisterImpl(const std::string& app_id,
+                    const std::vector<std::string>& sender_ids) override;
+  void UnregisterImpl(const std::string& app_id) override;
+  void SendImpl(const std::string& app_id,
+                const std::string& receiver_id,
+                const GCMClient::OutgoingMessage& message) override;
 
  private:
   class IOWorker;
diff --git a/components/gcm_driver/gcm_driver_desktop_unittest.cc b/components/gcm_driver/gcm_driver_desktop_unittest.cc
index 9c8a353..8d9211b 100644
--- a/components/gcm_driver/gcm_driver_desktop_unittest.cc
+++ b/components/gcm_driver/gcm_driver_desktop_unittest.cc
@@ -46,11 +46,11 @@ const char kUserID1[] = "user1";
 class FakeGCMConnectionObserver : public GCMConnectionObserver {
  public:
   FakeGCMConnectionObserver();
-  virtual ~FakeGCMConnectionObserver();
+  ~FakeGCMConnectionObserver() override;
 
   // gcm::GCMConnectionObserver implementation:
-  virtual void OnConnected(const net::IPEndPoint& ip_endpoint) override;
-  virtual void OnDisconnected() override;
+  void OnConnected(const net::IPEndPoint& ip_endpoint) override;
+  void OnDisconnected() override;
 
   bool connected() const { return connected_; }
 
diff --git a/components/gcm_driver/gcm_stats_recorder_impl.h b/components/gcm_driver/gcm_stats_recorder_impl.h
index 16472e1..a2836be 100644
--- a/components/gcm_driver/gcm_stats_recorder_impl.h
+++ b/components/gcm_driver/gcm_stats_recorder_impl.h
@@ -27,7 +27,7 @@ namespace gcm {
 class GCMStatsRecorderImpl : public GCMStatsRecorder {
  public:
   GCMStatsRecorderImpl();
-  virtual ~GCMStatsRecorderImpl();
+  ~GCMStatsRecorderImpl() override;
 
   // Indicates whether the recorder is currently recording activities or not.
   bool is_recording() const {
@@ -44,52 +44,49 @@ class GCMStatsRecorderImpl : public GCMStatsRecorder {
   void Clear();
 
   // GCMStatsRecorder implementation:
-  virtual void RecordCheckinInitiated(uint64 android_id) override;
-  virtual void RecordCheckinDelayedDueToBackoff(int64 delay_msec) override;
-  virtual void RecordCheckinSuccess() override;
-  virtual void RecordCheckinFailure(std::string status,
-                                    bool will_retry) override;
-  virtual void RecordConnectionInitiated(const std::string& host) override;
-  virtual void RecordConnectionDelayedDueToBackoff(int64 delay_msec) override;
-  virtual void RecordConnectionSuccess() override;
-  virtual void RecordConnectionFailure(int network_error) override;
-  virtual void RecordConnectionResetSignaled(
+  void RecordCheckinInitiated(uint64 android_id) override;
+  void RecordCheckinDelayedDueToBackoff(int64 delay_msec) override;
+  void RecordCheckinSuccess() override;
+  void RecordCheckinFailure(std::string status, bool will_retry) override;
+  void RecordConnectionInitiated(const std::string& host) override;
+  void RecordConnectionDelayedDueToBackoff(int64 delay_msec) override;
+  void RecordConnectionSuccess() override;
+  void RecordConnectionFailure(int network_error) override;
+  void RecordConnectionResetSignaled(
       ConnectionFactory::ConnectionResetReason reason) override;
-  virtual void RecordRegistrationSent(const std::string& app_id,
-                                      const std::string& sender_ids) override;
-  virtual void RecordRegistrationResponse(
-      const std::string& app_id,
-      const std::vector<std::string>& sender_ids,
-      RegistrationRequest::Status status) override;
-  virtual void RecordRegistrationRetryRequested(
+  void RecordRegistrationSent(const std::string& app_id,
+                              const std::string& sender_ids) override;
+  void RecordRegistrationResponse(const std::string& app_id,
+                                  const std::vector<std::string>& sender_ids,
+                                  RegistrationRequest::Status status) override;
+  void RecordRegistrationRetryRequested(
       const std::string& app_id,
       const std::vector<std::string>& sender_ids,
       int retries_left) override;
-  virtual void RecordUnregistrationSent(const std::string& app_id) override;
-  virtual void RecordUnregistrationResponse(
+  void RecordUnregistrationSent(const std::string& app_id) override;
+  void RecordUnregistrationResponse(
       const std::string& app_id,
       UnregistrationRequest::Status status) override;
-  virtual void RecordUnregistrationRetryDelayed(const std::string& app_id,
-                                                int64 delay_msec) override;
-  virtual void RecordDataMessageReceived(
-      const std::string& app_id,
-      const std::string& from,
-      int message_byte_size,
-      bool to_registered_app,
-      ReceivedMessageType message_type) override;
-  virtual void RecordDataSentToWire(const std::string& app_id,
-                                    const std::string& receiver_id,
-                                    const std::string& message_id,
-                                    int queued) override;
-  virtual void RecordNotifySendStatus(const std::string& app_id,
-                                      const std::string& receiver_id,
-                                      const std::string& message_id,
-                                      MCSClient::MessageSendStatus status,
-                                      int byte_size,
-                                      int ttl) override;
-  virtual void RecordIncomingSendError(const std::string& app_id,
-                                       const std::string& receiver_id,
-                                       const std::string& message_id) override;
+  void RecordUnregistrationRetryDelayed(const std::string& app_id,
+                                        int64 delay_msec) override;
+  void RecordDataMessageReceived(const std::string& app_id,
+                                 const std::string& from,
+                                 int message_byte_size,
+                                 bool to_registered_app,
+                                 ReceivedMessageType message_type) override;
+  void RecordDataSentToWire(const std::string& app_id,
+                            const std::string& receiver_id,
+                            const std::string& message_id,
+                            int queued) override;
+  void RecordNotifySendStatus(const std::string& app_id,
+                              const std::string& receiver_id,
+                              const std::string& message_id,
+                              MCSClient::MessageSendStatus status,
+                              int byte_size,
+                              int ttl) override;
+  void RecordIncomingSendError(const std::string& app_id,
+                               const std::string& receiver_id,
+                               const std::string& message_id) override;
 
   // Collect all recorded activities into the struct.
   void CollectActivities(RecordedActivities* recorder_activities) const;
diff --git a/components/gcm_driver/system_encryptor.h b/components/gcm_driver/system_encryptor.h
index 48c75c8..02339ad 100644
--- a/components/gcm_driver/system_encryptor.h
+++ b/components/gcm_driver/system_encryptor.h
@@ -13,13 +13,13 @@ namespace gcm {
 // Encryptor that uses the Chrome password manager's encryptor.
 class SystemEncryptor : public Encryptor {
  public:
-  virtual ~SystemEncryptor();
+  ~SystemEncryptor() override;
 
-  virtual bool EncryptString(const std::string& plaintext,
-                             std::string* ciphertext) override;
+  bool EncryptString(const std::string& plaintext,
+                     std::string* ciphertext) override;
 
-  virtual bool DecryptString(const std::string& ciphertext,
-                             std::string* plaintext) override;
+  bool DecryptString(const std::string& ciphertext,
+                     std::string* plaintext) override;
 };
 
 }  // namespace gcm