Standardize usage of virtual/override/final in google_apis/

google_apis/gaia/oauth2_token_service_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 <string>
 
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "google_apis/gaia/oauth2_access_token_consumer.h"
 #include "google_apis/gaia/oauth2_access_token_fetcher_impl.h"
 #include "google_apis/gaia/oauth2_token_service.h"
 #include "google_apis/gaia/oauth2_token_service_test_util.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 // A testing consumer that retries on error.
 class RetryingTestingOAuth2TokenServiceConsumer
     : public TestingOAuth2TokenServiceConsumer {
  public:
   RetryingTestingOAuth2TokenServiceConsumer(
       OAuth2TokenService* oauth2_service,
       const std::string& account_id)
       : oauth2_service_(oauth2_service),
         account_id_(account_id) {}
-  virtual ~RetryingTestingOAuth2TokenServiceConsumer() {}
+  ~RetryingTestingOAuth2TokenServiceConsumer() override {}
 
-  virtual void OnGetTokenFailure(const OAuth2TokenService::Request* request,
-                                 const GoogleServiceAuthError& error) override {
+  void OnGetTokenFailure(const OAuth2TokenService::Request* request,
+                         const GoogleServiceAuthError& error) override {
     TestingOAuth2TokenServiceConsumer::OnGetTokenFailure(request, error);
     request_.reset(oauth2_service_->StartRequest(
         account_id_, OAuth2TokenService::ScopeSet(), this).release());
   }
 
   OAuth2TokenService* oauth2_service_;
   std::string account_id_;
   scoped_ptr<OAuth2TokenService::Request> request_;
 };
 
@@ skipping 11 matching lines @@
 
   // For testing: set the refresh token to be used.
   void set_refresh_token(const std::string& account_id,
                          const std::string& refresh_token) {
     if (refresh_token.empty())
       refresh_tokens_.erase(account_id);
     else
       refresh_tokens_[account_id] = refresh_token;
   }
 
-  virtual bool RefreshTokenIsAvailable(const std::string& account_id) const
-      override {
+  bool RefreshTokenIsAvailable(const std::string& account_id) const override {
     std::map<std::string, std::string>::const_iterator it =
         refresh_tokens_.find(account_id);
 
     return it != refresh_tokens_.end();
   };
 
  private:
   // OAuth2TokenService implementation.
-  virtual net::URLRequestContextGetter* GetRequestContext() override {
+  net::URLRequestContextGetter* GetRequestContext() override {
     return request_context_getter_.get();
   }
 
-  virtual OAuth2AccessTokenFetcher* CreateAccessTokenFetcher(
+  OAuth2AccessTokenFetcher* CreateAccessTokenFetcher(
       const std::string& account_id,
       net::URLRequestContextGetter* getter,
       OAuth2AccessTokenConsumer* consumer) override {
     std::map<std::string, std::string>::const_iterator it =
         refresh_tokens_.find(account_id);
     DCHECK(it != refresh_tokens_.end());
     std::string refresh_token(it->second);
     return new OAuth2AccessTokenFetcherImpl(consumer, getter, refresh_token);
   };
 
@@ skipping 552 matching lines @@
       } else if (i < j) {
         EXPECT_TRUE(params[i] < params[j]) << " i=" << i << ", j=" << j;
         EXPECT_FALSE(params[j] < params[i]) << " i=" << i << ", j=" << j;
       } else {
         EXPECT_TRUE(params[j] < params[i]) << " i=" << i << ", j=" << j;
         EXPECT_FALSE(params[i] < params[j]) << " i=" << i << ", j=" << j;
       }
     }
   }
 }