replace OVERRIDE and FINAL with override and 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 75 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;
+  virtual void Login(uint64 android_id, uint64 security_token) override;
+  virtual 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 27 matching lines @@
         reinterpret_cast<const mcs_proto::DataMessageStanza&>(
             message.GetProtobuf()));
   }
 }
 
 class AutoAdvancingTestClock : public base::Clock {
  public:
   explicit AutoAdvancingTestClock(base::TimeDelta auto_increment_time_delta);
   virtual ~AutoAdvancingTestClock();
 
-  virtual base::Time Now() OVERRIDE;
+  virtual 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 14 matching lines @@
 
 void AutoAdvancingTestClock::Advance(base::TimeDelta delta) {
   now_ += delta;
 }
 
 class FakeGCMInternalsBuilder : public GCMInternalsBuilder {
  public:
   FakeGCMInternalsBuilder(base::TimeDelta clock_step);
   virtual ~FakeGCMInternalsBuilder();
 
-  virtual scoped_ptr<base::Clock> BuildClock() 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;
+      GCMStatsRecorder* recorder) override;
   virtual 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;
+      GCMStatsRecorder* recorder) override;
 
  private:
   base::TimeDelta clock_step_;
 };
 
 FakeGCMInternalsBuilder::FakeGCMInternalsBuilder(base::TimeDelta clock_step)
     : clock_step_(clock_step) {
 }
 
 FakeGCMInternalsBuilder::~FakeGCMInternalsBuilder() {}
@@ skipping 25 matching lines @@
 }
 
 }  // namespace
 
 class GCMClientImplTest : public testing::Test,
                           public GCMClient::Delegate {
  public:
   GCMClientImplTest();
   virtual ~GCMClientImplTest();
 
-  virtual void SetUp() OVERRIDE;
+  virtual void SetUp() override;
 
   void BuildGCMClient(base::TimeDelta clock_step);
   void InitializeGCMClient();
   void StartGCMClient();
   void ReceiveMessageFromMCS(const MCSMessage& message);
   void ReceiveOnMessageSentToMCS(
       const std::string& app_id,
       const std::string& message_id,
       const MCSClient::MessageSendStatus status);
   void CompleteCheckin(uint64 android_id,
                        uint64 security_token,
                        const std::string& digest,
                        const std::map<std::string, std::string>& settings);
   void CompleteRegistration(const std::string& registration_id);
   void CompleteUnregistration(const std::string& app_id);
 
   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;
+                                  GCMClient::Result result) override;
   virtual void OnUnregisterFinished(const std::string& app_id,
-                                    GCMClient::Result result) OVERRIDE;
+                                    GCMClient::Result result) override;
   virtual void OnSendFinished(const std::string& app_id,
                               const std::string& message_id,
-                              GCMClient::Result result) OVERRIDE {}
+                              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;
+      override;
+  virtual void OnMessagesDeleted(const std::string& app_id) override;
   virtual void OnMessageSendError(
       const std::string& app_id,
-      const gcm::GCMClient::SendErrorDetails& send_error_details) OVERRIDE;
+      const gcm::GCMClient::SendErrorDetails& send_error_details) override;
   virtual void OnSendAcknowledged(const std::string& app_id,
-                                  const std::string& message_id) OVERRIDE;
+                                  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 {}
+      const std::vector<AccountMapping>& account_mappings) override;
+  virtual void OnActivityRecorded() override {}
+  virtual void OnConnected(const net::IPEndPoint& ip_endpoint) override {}
+  virtual 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 453 matching lines @@
   EXPECT_EQ(MESSAGE_SEND_ACK, last_event());
   EXPECT_EQ(kAppId, last_app_id());
   EXPECT_EQ("007", last_message_id());
 }
 
 class GCMClientImplCheckinTest : public GCMClientImplTest {
  public:
   GCMClientImplCheckinTest();
   virtual ~GCMClientImplCheckinTest();
 
-  virtual void SetUp() OVERRIDE;
+  virtual void SetUp() override;
 };
 
 GCMClientImplCheckinTest::GCMClientImplCheckinTest() {
 }
 
 GCMClientImplCheckinTest::~GCMClientImplCheckinTest() {
 }
 
 void GCMClientImplCheckinTest::SetUp() {
   testing::Test::SetUp();
@@ skipping 208 matching lines @@
   EXPECT_TRUE(device_checkin_info().accounts_set);
   EXPECT_EQ(MakeEmailToTokenMap(account_tokens),
             device_checkin_info().account_tokens);
 }
 
 class GCMClientImplStartAndStopTest : public GCMClientImplTest {
 public:
   GCMClientImplStartAndStopTest();
   virtual ~GCMClientImplStartAndStopTest();
 
-  virtual void SetUp() OVERRIDE;
+  virtual void SetUp() override;
 };
 
 GCMClientImplStartAndStopTest::GCMClientImplStartAndStopTest() {
 }
 
 GCMClientImplStartAndStopTest::~GCMClientImplStartAndStopTest() {
 }
 
 void GCMClientImplStartAndStopTest::SetUp() {
   testing::Test::SetUp();
@@ skipping 28 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