replace OVERRIDE and FINAL with override and final in sync/

sync/internal_api/attachments/attachment_downloader_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 "sync/internal_api/public/attachments/attachment_downloader.h"
 
 #include "base/bind.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 26 matching lines @@
   void RespondToAccessTokenRequest(GoogleServiceAuthError error);
 
   int num_invalidate_token() const { return num_invalidate_token_; }
 
  protected:
   virtual void FetchOAuth2Token(RequestImpl* request,
                                 const std::string& account_id,
                                 net::URLRequestContextGetter* getter,
                                 const std::string& client_id,
                                 const std::string& client_secret,
-                                const ScopeSet& scopes) OVERRIDE;
+                                const ScopeSet& scopes) override;
 
   virtual void InvalidateOAuth2Token(const std::string& account_id,
                                      const std::string& client_id,
                                      const ScopeSet& scopes,
-                                     const std::string& access_token) OVERRIDE;
+                                     const std::string& access_token) override;
 
  private:
   base::WeakPtr<RequestImpl> last_request_;
   int num_invalidate_token_;
 };
 
 void MockOAuth2TokenService::RespondToAccessTokenRequest(
     GoogleServiceAuthError error) {
   EXPECT_TRUE(last_request_ != NULL);
   std::string access_token;
@@ skipping 32 matching lines @@
 }
 
 class TokenServiceProvider
     : public OAuth2TokenServiceRequest::TokenServiceProvider,
       base::NonThreadSafe {
  public:
   TokenServiceProvider(OAuth2TokenService* token_service);
 
   // OAuth2TokenService::TokenServiceProvider implementation.
   virtual scoped_refptr<base::SingleThreadTaskRunner>
-      GetTokenServiceTaskRunner() OVERRIDE;
-  virtual OAuth2TokenService* GetTokenService() OVERRIDE;
+      GetTokenServiceTaskRunner() override;
+  virtual OAuth2TokenService* GetTokenService() override;
 
  private:
   virtual ~TokenServiceProvider();
 
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   OAuth2TokenService* token_service_;
 };
 
 TokenServiceProvider::TokenServiceProvider(OAuth2TokenService* token_service)
     : task_runner_(base::ThreadTaskRunnerHandle::Get()),
@@ skipping 16 matching lines @@
 
 }  // namespace
 
 class AttachmentDownloaderImplTest : public testing::Test {
  protected:
   typedef std::map<AttachmentId, AttachmentDownloader::DownloadResult>
       ResultsMap;
 
   AttachmentDownloaderImplTest() : num_completed_downloads_(0) {}
 
-  virtual void SetUp() OVERRIDE;
-  virtual void TearDown() OVERRIDE;
+  virtual void SetUp() override;
+  virtual void TearDown() override;
 
   AttachmentDownloader* downloader() { return attachment_downloader_.get(); }
 
   MockOAuth2TokenService* token_service() { return token_service_.get(); }
 
   int num_completed_downloads() { return num_completed_downloads_; }
 
   AttachmentDownloader::DownloadCallback download_callback(
       const AttachmentId& id) {
     return base::Bind(&AttachmentDownloaderImplTest::DownloadDone,
@@ skipping 194 matching lines @@
       GoogleServiceAuthError::AuthErrorNone());
   RunMessageLoop();
   // Fail URLFetcher. This should trigger download failure. Access token
   // shouldn't be invalidated.
   CompleteDownload(net::HTTP_SERVICE_UNAVAILABLE);
   EXPECT_EQ(0, token_service()->num_invalidate_token());
   VerifyDownloadResult(id1, AttachmentDownloader::DOWNLOAD_TRANSIENT_ERROR);
 }
 
 }  // namespace syncer