replace OVERRIDE and FINAL with override and final in components/

components/invalidation/gcm_network_channel_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 "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "components/invalidation/gcm_network_channel.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer {
 
 class TestGCMNetworkChannelDelegate : public GCMNetworkChannelDelegate {
  public:
   TestGCMNetworkChannelDelegate()
       : register_call_count_(0) {}
 
   virtual void Initialize(
-      GCMNetworkChannelDelegate::ConnectionStateCallback callback) OVERRIDE {
+      GCMNetworkChannelDelegate::ConnectionStateCallback callback) override {
     connection_state_callback = callback;
   }
 
-  virtual void RequestToken(RequestTokenCallback callback) OVERRIDE {
+  virtual void RequestToken(RequestTokenCallback callback) override {
     request_token_callback = callback;
   }
 
-  virtual void InvalidateToken(const std::string& token) OVERRIDE {
+  virtual void InvalidateToken(const std::string& token) override {
     invalidated_token = token;
   }
 
-  virtual void Register(RegisterCallback callback) OVERRIDE {
+  virtual void Register(RegisterCallback callback) override {
     ++register_call_count_;
     register_callback = callback;
   }
 
-  virtual void SetMessageReceiver(MessageCallback callback) OVERRIDE {
+  virtual void SetMessageReceiver(MessageCallback callback) override {
     message_callback = callback;
   }
 
   RequestTokenCallback request_token_callback;
   std::string invalidated_token;
   RegisterCallback register_callback;
   int register_call_count_;
   MessageCallback message_callback;
   ConnectionStateCallback connection_state_callback;
 };
@@ skipping 30 matching lines @@
   TestGCMNetworkChannel(
       scoped_refptr<net::URLRequestContextGetter> request_context_getter,
       scoped_ptr<GCMNetworkChannelDelegate> delegate)
       :  GCMNetworkChannel(request_context_getter, delegate.Pass()) {
     ResetRegisterBackoffEntryForTest(&kTestBackoffPolicy);
   }
 
  protected:
   // On Android GCMNetworkChannel::BuildUrl hits NOTREACHED(). I still want
   // tests to run.
-  virtual GURL BuildUrl(const std::string& registration_id) OVERRIDE {
+  virtual GURL BuildUrl(const std::string& registration_id) override {
     return GURL("http://test.url.com");
   }
 };
 
 class GCMNetworkChannelTest;
 
 // Test needs to capture setting echo-token header on http request.
 // This class is going to do that.
 class TestNetworkChannelURLFetcher : public net::FakeURLFetcher {
  public:
   TestNetworkChannelURLFetcher(GCMNetworkChannelTest* test,
                                const GURL& url,
                                net::URLFetcherDelegate* delegate,
                                const std::string& response_data,
                                net::HttpStatusCode response_code,
                                net::URLRequestStatus::Status status)
       : net::FakeURLFetcher(url,
                             delegate,
                             response_data,
                             response_code,
                             status),
         test_(test) {}
 
-  virtual void AddExtraRequestHeader(const std::string& header_line) OVERRIDE;
+  virtual void AddExtraRequestHeader(const std::string& header_line) override;
 
  private:
   GCMNetworkChannelTest* test_;
 };
 
 class GCMNetworkChannelTest
     : public ::testing::Test,
       public SyncNetworkChannel::Observer {
  public:
   GCMNetworkChannelTest()
@@ skipping 36 matching lines @@
                                   std::string* output) {
     GCMNetworkChannel::Base64EncodeURLSafe(input, output);
   }
 
   static bool Base64DecodeURLSafe(const std::string& input,
                                   std::string* output) {
     return GCMNetworkChannel::Base64DecodeURLSafe(input, output);
   }
 
   virtual void OnNetworkChannelStateChanged(
-      InvalidatorState invalidator_state) OVERRIDE {
+      InvalidatorState invalidator_state) override {
     last_invalidator_state_ = invalidator_state;
   }
 
   void OnIncomingMessage(std::string incoming_message) {
   }
 
   GCMNetworkChannel* network_channel() {
     return gcm_network_channel_.get();
   }
 
@@ skipping 324 matching lines @@
   delegate()->request_token_callback.Run(
       GoogleServiceAuthError::AuthErrorNone(), "access.token");
   RunLoopUntilIdle();
   EXPECT_EQ(url_fetchers_created_count(), 3);
   // Echo_token should be from second message.
   EXPECT_EQ("echo.token", get_last_echo_token());
 }
 #endif
 
 }  // namespace syncer