replace OVERRIDE and FINAL with override and final in chrome/browser/[r-z]*

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 31 matching lines @@
         version_(base::StringPrintf("v%d", version)),
         language_(language.empty() ? std::string("en") : language),
         text_(text) {
     set_response_code(status);
     SetResponseString(response);
   }
   virtual ~TestSpellingURLFetcher() {
   }
 
   virtual void SetUploadData(const std::string& upload_content_type,
-                             const std::string& upload_content) OVERRIDE {
+                             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 {
+  virtual 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 68 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 {
+  virtual 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 197 matching lines @@
     EXPECT_FALSE(client_.IsAvailable(&profile_, kSpellcheck));
   }
 }
 
 // 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\": {}}"));
 }