Standardize usage of virtual/override/final in components/

components/gcm_driver/gcm_client_impl_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/gcm_driver/gcm_client_impl.h"
 
 #include "base/command_line.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 74 matching lines @@
   }
   return email_token_map;
 }
 
 class FakeMCSClient : public MCSClient {
  public:
   FakeMCSClient(base::Clock* clock,
                 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_; }
   uint8 last_message_tag() const { return last_message_tag_; }
   const mcs_proto::DataMessageStanza& last_data_message_stanza() const {
     return last_data_message_stanza_;
   }
 
  private:
   uint64 last_android_id_;
@@ skipping 25 matching lines @@
   if (last_message_tag_ == kDataMessageStanzaTag) {
     last_data_message_stanza_.CopyFrom(
         reinterpret_cast<const mcs_proto::DataMessageStanza&>(
             message.GetProtobuf()));
   }
 }
 
 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_; }
 
  private:
   int call_count_;
   base::TimeDelta auto_increment_time_delta_;
   base::Time now_;
 
   DISALLOW_COPY_AND_ASSIGN(AutoAdvancingTestClock);
 };
@@ skipping 12 matching lines @@
   return now_;
 }
 
 void AutoAdvancingTestClock::Advance(base::TimeDelta delta) {
   now_ += delta;
 }
 
 class FakeGCMInternalsBuilder : public GCMInternalsBuilder {
  public:
   FakeGCMInternalsBuilder(base::TimeDelta clock_step);
-  virtual ~FakeGCMInternalsBuilder();
+  ~FakeGCMInternalsBuilder() override;
 
-  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(
+  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,
       const scoped_refptr<net::HttpNetworkSession>& http_network_session,
       net::NetLog* net_log,
       GCMStatsRecorder* recorder) override;
 
  private:
   base::TimeDelta clock_step_;
 };
@@ skipping 55 matching lines @@
   void CompleteRegistration(const std::string& registration_id);
   void CompleteUnregistration(const std::string& app_id);
   void VerifyPendingRequestFetcherDeleted();
 
   bool ExistsRegistration(const std::string& app_id) const;
   void AddRegistration(const std::string& app_id,
                        const std::vector<std::string>& sender_ids,
                        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 {
     return reinterpret_cast<FakeMCSClient*>(gcm_client_->mcs_client_.get());
   }
   ConnectionFactory* connection_factory() const {
     return gcm_client_->connection_factory_.get();
   }
 
   const GCMClientImpl::CheckinInfo& device_checkin_info() const {
@@ skipping 746 matching lines @@
 TEST_F(GCMClientImplStartAndStopTest, StartStopAndRestartImmediately) {
   // Start the GCM and then stop and restart it immediately.
   gcm_client()->Start();
   gcm_client()->Stop();
   gcm_client()->Start();
 
   PumpLoopUntilIdle();
 }
 
 }  // namespace gcm