Standardize usage of virtual/override/final in google_apis/

google_apis/gaia/oauth2_token_service_request_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 "google_apis/gaia/oauth2_token_service_request.h"
 
 #include <set>
 #include <string>
 #include <vector>
 #include "base/threading/thread.h"
 #include "google_apis/gaia/fake_oauth2_token_service.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "google_apis/gaia/oauth2_token_service.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 const char kAccessToken[] = "access_token";
 const char kAccountId[] = "test_user@gmail.com";
 const char kScope[] = "SCOPE";
 
 class TestingOAuth2TokenServiceConsumer : public OAuth2TokenService::Consumer {
  public:
   TestingOAuth2TokenServiceConsumer();
-  virtual ~TestingOAuth2TokenServiceConsumer();
+  ~TestingOAuth2TokenServiceConsumer() override;
 
-  virtual void OnGetTokenSuccess(const OAuth2TokenService::Request* request,
-                                 const std::string& access_token,
-                                 const base::Time& expiration_time) override;
-  virtual void OnGetTokenFailure(const OAuth2TokenService::Request* request,
-                                 const GoogleServiceAuthError& error) override;
+  void OnGetTokenSuccess(const OAuth2TokenService::Request* request,
+                         const std::string& access_token,
+                         const base::Time& expiration_time) override;
+  void OnGetTokenFailure(const OAuth2TokenService::Request* request,
+                         const GoogleServiceAuthError& error) override;
 
   int num_get_token_success_;
   int num_get_token_failure_;
   std::string last_token_;
   GoogleServiceAuthError last_error_;
 };
 
 TestingOAuth2TokenServiceConsumer::TestingOAuth2TokenServiceConsumer()
     : OAuth2TokenService::Consumer("test"),
       num_get_token_success_(0),
@@ skipping 18 matching lines @@
   last_error_ = error;
   ++num_get_token_failure_;
 }
 
 // A mock implementation of an OAuth2TokenService.
 //
 // Use SetResponse to vary the response to token requests.
 class MockOAuth2TokenService : public FakeOAuth2TokenService {
  public:
   MockOAuth2TokenService();
-  virtual ~MockOAuth2TokenService();
+  ~MockOAuth2TokenService() override;
 
   void SetResponse(const GoogleServiceAuthError& error,
                    const std::string& access_token,
                    const base::Time& expiration);
 
   int num_invalidate_token() const { return num_invalidate_token_; }
 
   const std::string& last_token_invalidated() const {
     return last_token_invalidated_;
   }
 
  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;
+  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;
 
-  virtual void InvalidateOAuth2Token(const std::string& account_id,
-                                     const std::string& client_id,
-                                     const ScopeSet& scopes,
-                                     const std::string& access_token) override;
+  void InvalidateOAuth2Token(const std::string& account_id,
+                             const std::string& client_id,
+                             const ScopeSet& scopes,
+                             const std::string& access_token) override;
 
  private:
   GoogleServiceAuthError response_error_;
   std::string response_access_token_;
   base::Time response_expiration_;
   int num_invalidate_token_;
   std::string last_token_invalidated_;
 };
 
 MockOAuth2TokenService::MockOAuth2TokenService()
@@ skipping 43 matching lines @@
  public:
   virtual void SetUp() override;
   virtual void TearDown() override;
 
  protected:
   class Provider : public OAuth2TokenServiceRequest::TokenServiceProvider {
    public:
     Provider(const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
              OAuth2TokenService* token_service);
 
-    virtual scoped_refptr<base::SingleThreadTaskRunner>
-        GetTokenServiceTaskRunner() override;
-    virtual OAuth2TokenService* GetTokenService() override;
+    scoped_refptr<base::SingleThreadTaskRunner> GetTokenServiceTaskRunner()
+        override;
+    OAuth2TokenService* GetTokenService() override;
 
    private:
-    virtual ~Provider();
+    ~Provider() override;
 
     scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
     OAuth2TokenService* token_service_;
   };
 
   base::MessageLoop ui_loop_;
   OAuth2TokenService::ScopeSet scopes_;
   scoped_ptr<MockOAuth2TokenService> oauth2_service_;
   scoped_refptr<OAuth2TokenServiceRequest::TokenServiceProvider> provider_;
   TestingOAuth2TokenServiceConsumer consumer_;
@@ skipping 86 matching lines @@
   OAuth2TokenServiceRequest::InvalidateToken(
       provider_.get(), kAccountId, scopes_, kAccessToken);
   ui_loop_.RunUntilIdle();
   EXPECT_EQ(0, consumer_.num_get_token_success_);
   EXPECT_EQ(0, consumer_.num_get_token_failure_);
   EXPECT_EQ(kAccessToken, oauth2_service_->last_token_invalidated());
   EXPECT_EQ(1, oauth2_service_->num_invalidate_token());
 }
 
 }  // namespace