Standardize usage of virtual/override/final in chrome/browser/

chrome/browser/spellchecker/spelling_service_client_unittest.cc

 // Copyright (c) 2012 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 <vector>
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 27 matching lines @@
                          const std::string& language,
                          int status,
                          const std::string& response)
       : net::TestURLFetcher(0, url, d),
         version_(base::StringPrintf("v%d", version)),
         language_(language.empty() ? std::string("en") : language),
         text_(text) {
     set_response_code(status);
     SetResponseString(response);
   }
-  virtual ~TestSpellingURLFetcher() {
-  }
+  ~TestSpellingURLFetcher() override {}
 
-  virtual void SetUploadData(const std::string& upload_content_type,
-                             const std::string& upload_content) override {
+  void SetUploadData(const std::string& upload_content_type,
+                     const std::string& upload_content) override {
     // Verify the given content type is JSON. (The Spelling service returns an
     // internal server error when this content type is not JSON.)
     EXPECT_EQ("application/json", upload_content_type);
 
     // Parse the JSON to be sent to the service, and verify its parameters.
     scoped_ptr<base::DictionaryValue> value(static_cast<base::DictionaryValue*>(
         base::JSONReader::Read(upload_content,
                                base::JSON_ALLOW_TRAILING_COMMAS)));
     ASSERT_TRUE(!!value.get());
     std::string method;
     EXPECT_TRUE(value->GetString("method", &method));
     EXPECT_EQ("spelling.check", method);
     std::string version;
     EXPECT_TRUE(value->GetString("apiVersion", &version));
     EXPECT_EQ(version_, version);
     std::string text;
     EXPECT_TRUE(value->GetString("params.text", &text));
     EXPECT_EQ(text_, text);
     std::string language;
     EXPECT_TRUE(value->GetString("params.language", &language));
     EXPECT_EQ(language_, language);
     ASSERT_TRUE(GetExpectedCountry(language, &country_));
     std::string country;
     EXPECT_TRUE(value->GetString("params.originCountry", &country));
     EXPECT_EQ(country_, country);
 
     net::TestURLFetcher::SetUploadData(upload_content_type, upload_content);
   }
 
-  virtual void Start() override {
+  void Start() override {
     // Verify that this client does not either send cookies to the Spelling
     // service or accept cookies from it.
     EXPECT_EQ(net::LOAD_DO_NOT_SEND_COOKIES | net::LOAD_DO_NOT_SAVE_COOKIES,
               GetLoadFlags());
   }
 
  private:
   bool GetExpectedCountry(const std::string& language, std::string* country) {
     static const struct {
       const char* language;
@@ skipping 22 matching lines @@
 // this test can use TestSpellingURLFetcher. This class also lets tests access
 // the ParseResponse method.
 class TestingSpellingServiceClient : public SpellingServiceClient {
  public:
   TestingSpellingServiceClient()
       : request_type_(0),
         response_status_(0),
         success_(false),
         fetcher_(NULL) {
   }
-  virtual ~TestingSpellingServiceClient() {
-  }
+  ~TestingSpellingServiceClient() override {}
 
   void SetHTTPRequest(int type,
                       const std::string& text,
                       const std::string& language) {
     request_type_ = type;
     request_text_ = text;
     request_language_ = language;
   }
 
   void SetHTTPResponse(int status, const char* data) {
@@ skipping 24 matching lines @@
     }
     EXPECT_EQ(corrected_text_, text);
   }
 
   bool ParseResponseSuccess(const std::string& data) {
     std::vector<SpellCheckResult> results;
     return ParseResponse(data, &results);
   }
 
  private:
-  virtual net::URLFetcher* CreateURLFetcher(const GURL& url) override {
+  net::URLFetcher* CreateURLFetcher(const GURL& url) override {
     EXPECT_EQ("https://www.googleapis.com/rpc", url.spec());
     fetcher_ = new TestSpellingURLFetcher(0, url, this,
                                           request_type_, request_text_,
                                           request_language_,
                                           response_status_, response_data_);
     return fetcher_;
   }
 
   int request_type_;
   std::string request_text_;
@@ skipping 195 matching lines @@
   }
 #endif  // !defined(OS_MACOSX)
 }
 
 // Verify that an error in JSON response from spelling service will result in
 // ParseResponse returning false.
 TEST_F(SpellingServiceClientTest, ResponseErrorTest) {
   EXPECT_TRUE(client_.ParseResponseSuccess("{\"result\": {}}"));
   EXPECT_FALSE(client_.ParseResponseSuccess("{\"error\": {}}"));
 }