replace OVERRIDE and FINAL with override and final in google_apis/

google_apis/drive/request_sender_unittest.cc

 // Copyright 2013 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 "google_apis/drive/request_sender.h"
 
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "google_apis/drive/base_requests.h"
 #include "google_apis/drive/dummy_auth_service.h"
@@ skipping 14 matching lines @@
   AUTH_FAILURE,
 };
 
 // AuthService for testing purpose. It accepts kTestRefreshToken and returns
 // kTestAccessToken + {"1", "2", "3", ...}.
 class TestAuthService : public DummyAuthService {
  public:
   TestAuthService() : auth_try_count_(0) {}
 
   virtual void StartAuthentication(
-      const AuthStatusCallback& callback) OVERRIDE {
+      const AuthStatusCallback& callback) override {
     // RequestSender should clear the rejected access token before starting
     // to request another one.
     EXPECT_FALSE(HasAccessToken());
 
     ++auth_try_count_;
 
     if (refresh_token() == kTestRefreshToken) {
       const std::string token =
           kTestAccessToken + base::IntToString(auth_try_count_);
       set_access_token(token);
@@ skipping 44 matching lines @@
   const std::string& passed_access_token() const {
     return passed_access_token_;
   }
 
   const ReAuthenticateCallback& passed_reauth_callback() const {
     return passed_reauth_callback_;
   }
 
   virtual void Start(const std::string& access_token,
                      const std::string& custom_user_agent,
-                     const ReAuthenticateCallback& callback) OVERRIDE {
+                     const ReAuthenticateCallback& callback) override {
     *start_called_ = true;
     passed_access_token_ = access_token;
     passed_reauth_callback_ = callback;
 
     // This request class itself does not return any response at this point.
     // Each test case should respond properly by using the above methods.
   }
 
-  virtual void Cancel() OVERRIDE {
+  virtual void Cancel() override {
     EXPECT_TRUE(*start_called_);
     *finish_reason_ = CANCEL;
     sender_->RequestFinished(this);
   }
 
-  virtual void OnAuthFailed(GDataErrorCode code) OVERRIDE {
+  virtual void OnAuthFailed(GDataErrorCode code) override {
     *finish_reason_ = AUTH_FAILURE;
     sender_->RequestFinished(this);
   }
 
-  virtual base::WeakPtr<AuthenticatedRequestInterface> GetWeakPtr() OVERRIDE {
+  virtual base::WeakPtr<AuthenticatedRequestInterface> GetWeakPtr() override {
     return weak_ptr_factory_.GetWeakPtr();
   }
 
  private:
   RequestSender* sender_;
   bool* start_called_;
   FinishReason* finish_reason_;
   std::string passed_access_token_;
   ReAuthenticateCallback passed_reauth_callback_;
   base::WeakPtrFactory<TestRequest> weak_ptr_factory_;
@@ skipping 111 matching lines @@
   // by the RequestSender. So with this TestRequest, RequestSender retries
   // infinitely. Let it succeed/
   EXPECT_EQ(kTestAccessToken + std::string("3"),
             request->passed_access_token());
   request->FinishRequestWithSuccess();
   EXPECT_EQ(SUCCESS, finish_reason);
   EXPECT_FALSE(weak_ptr);
 }
 
 }  // namespace google_apis