Standardize usage of virtual/override/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_impl.h"
 
 #include "base/bind.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 16 matching lines @@
 const char kAttachmentServerUrl[] = "http://attachments.com/";
 const char kAttachmentContent[] = "attachment.content";
 
 // MockOAuth2TokenService remembers last request for access token and verifies
 // that only one request is active at a time.
 // Call RespondToAccessTokenRequest to respond to it.
 class MockOAuth2TokenService : public FakeOAuth2TokenService {
  public:
   MockOAuth2TokenService() : num_invalidate_token_(0) {}
 
-  virtual ~MockOAuth2TokenService() {}
+  ~MockOAuth2TokenService() override {}
 
   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;
+  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:
   base::WeakPtr<RequestImpl> last_request_;
   int num_invalidate_token_;
 };
 
 void MockOAuth2TokenService::RespondToAccessTokenRequest(
     GoogleServiceAuthError error) {
   EXPECT_TRUE(last_request_ != NULL);
   std::string access_token;
@@ skipping 31 matching lines @@
   ++num_invalidate_token_;
 }
 
 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;
+  scoped_refptr<base::SingleThreadTaskRunner> GetTokenServiceTaskRunner()
+      override;
+  OAuth2TokenService* GetTokenService() override;
 
  private:
-  virtual ~TokenServiceProvider();
+  ~TokenServiceProvider() override;
 
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   OAuth2TokenService* token_service_;
 };
 
 TokenServiceProvider::TokenServiceProvider(OAuth2TokenService* token_service)
     : task_runner_(base::ThreadTaskRunnerHandle::Get()),
       token_service_(token_service) {
   DCHECK(token_service_);
 }
@@ skipping 341 matching lines @@
   raw += "X-Goog-Hash: md5=rL0Y20zC+Fzt72VPzMSk2A==\n";
   raw += "\n";
   std::replace(raw.begin(), raw.end(), '\n', '\0');
   scoped_refptr<net::HttpResponseHeaders> headers(
       new net::HttpResponseHeaders(raw));
   std::string extracted;
   ASSERT_FALSE(AttachmentDownloaderImpl::ExtractCrc32c(*headers, &extracted));
 }
 
 }  // namespace syncer