replace OVERRIDE and FINAL with override and final in components/

components/gcm_driver/gcm_driver_desktop_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_driver_desktop.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
@@ skipping 30 matching lines @@
 const char kTestAppID1[] = "TestApp1";
 const char kTestAppID2[] = "TestApp2";
 const char kUserID1[] = "user1";
 
 class FakeGCMConnectionObserver : public GCMConnectionObserver {
  public:
   FakeGCMConnectionObserver();
   virtual ~FakeGCMConnectionObserver();
 
   // gcm::GCMConnectionObserver implementation:
-  virtual void OnConnected(const net::IPEndPoint& ip_endpoint) OVERRIDE;
-  virtual void OnDisconnected() OVERRIDE;
+  virtual void OnConnected(const net::IPEndPoint& ip_endpoint) override;
+  virtual void OnDisconnected() override;
 
   bool connected() const { return connected_; }
 
  private:
   bool connected_;
 };
 
 FakeGCMConnectionObserver::FakeGCMConnectionObserver() : connected_(false) {
 }
 
@@ skipping 31 matching lines @@
  public:
   enum WaitToFinish {
     DO_NOT_WAIT,
     WAIT
   };
 
   GCMDriverTest();
   virtual ~GCMDriverTest();
 
   // testing::Test:
-  virtual void SetUp() OVERRIDE;
-  virtual void TearDown() OVERRIDE;
+  virtual void SetUp() override;
+  virtual void TearDown() override;
 
   GCMDriverDesktop* driver() { return driver_.get(); }
   FakeGCMAppHandler* gcm_app_handler() { return gcm_app_handler_.get(); }
   FakeGCMConnectionObserver* gcm_connection_observer() {
     return gcm_connection_observer_.get();
   }
   const std::string& registration_id() const { return registration_id_; }
   GCMClient::Result registration_result() const { return registration_result_; }
   const std::string& send_message_id() const { return send_message_id_; }
   GCMClient::Result send_result() const { return send_result_; }
@@ skipping 542 matching lines @@
   EXPECT_EQ(GCMClient::SUCCESS, send_result());
 }
 
 // Tests a single instance of GCMDriver.
 class GCMDriverFunctionalTest : public GCMDriverTest {
  public:
   GCMDriverFunctionalTest();
   virtual ~GCMDriverFunctionalTest();
 
   // GCMDriverTest:
-  virtual void SetUp() OVERRIDE;
+  virtual void SetUp() override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(GCMDriverFunctionalTest);
 };
 
 GCMDriverFunctionalTest::GCMDriverFunctionalTest() {
 }
 
 GCMDriverFunctionalTest::~GCMDriverFunctionalTest() {
 }
@@ skipping 264 matching lines @@
   EXPECT_EQ(kTestAppID1, gcm_app_handler()->app_id());
 }
 
 // Tests a single instance of GCMDriver.
 class GCMChannelStatusSyncerTest : public GCMDriverTest {
  public:
   GCMChannelStatusSyncerTest();
   virtual ~GCMChannelStatusSyncerTest();
 
   // testing::Test:
-  virtual void SetUp() OVERRIDE;
+  virtual void SetUp() override;
 
   void CompleteGCMChannelStatusRequest(bool enabled, int poll_interval_seconds);
   bool CompareDelaySeconds(bool expected_delay_seconds,
                            bool actual_delay_seconds);
 
   GCMChannelStatusSyncer* syncer() {
     return driver()->gcm_channel_status_syncer_for_testing();
   }
 
  private:
@@ skipping 216 matching lines @@
   // After start-up, the request should still be scheduled at the expected
   // updated interval.
   actual_delay_seconds =
       syncer()->current_request_delay_interval().InSeconds();
   EXPECT_TRUE(CompareDelaySeconds(expected_delay_seconds, actual_delay_seconds))
       << "expected delay: " << expected_delay_seconds
       << " actual delay: " << actual_delay_seconds;
 }
 
 }  // namespace gcm