Replacing the OVERRIDE with override in chrome/renderer

chrome/renderer/net/net_error_helper_core_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 "chrome/renderer/net/net_error_helper_core.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
@@ skipping 143 matching lines @@
                              error_url_(GURL(content::kUnreachableWebDataURL)),
                              tracking_request_count_(0) {
     SetUpCore(false, false, true);
   }
 
   virtual ~NetErrorHelperCoreTest() {
     // No test finishes while an error page is being fetched.
     EXPECT_FALSE(is_url_being_fetched());
   }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     base::StatisticsRecorder::Initialize();
   }
 
   void SetUpCore(bool auto_reload_enabled,
                  bool auto_reload_visible_only,
                  bool visible) {
     // The old value of timer_, if any, will be freed by the old core_ being
     // destructed, since core_ takes ownership of the timer.
     timer_ = new base::MockTimer(false, false);
     core_.reset(new NetErrorHelperCore(this,
@@ skipping 117 matching lines @@
                                          GURL(kSearchUrl));
   }
 
   // NetErrorHelperCore::Delegate implementation:
   virtual void GenerateLocalizedErrorPage(
       const WebURLError& error,
       bool is_failed_post,
       scoped_ptr<LocalizedError::ErrorPageParams> params,
       bool* reload_button_shown,
       bool* load_stale_button_shown,
-      std::string* html) const OVERRIDE {
+      std::string* html) const override {
     last_error_page_params_.reset(params.release());
     *reload_button_shown = false;
     *load_stale_button_shown = false;
     *html = ErrorToString(error, is_failed_post);
   }
 
   virtual void LoadErrorPageInMainFrame(const std::string& html,
-                                        const GURL& failed_url) OVERRIDE {
+                                        const GURL& failed_url) override {
     error_html_update_count_++;
     last_error_html_ = html;
   }
 
-  virtual void EnablePageHelperFunctions() OVERRIDE {
+  virtual void EnablePageHelperFunctions() override {
     enable_page_helper_functions_count_++;
   }
 
   virtual void UpdateErrorPage(const WebURLError& error,
-                               bool is_failed_post) OVERRIDE {
+                               bool is_failed_post) override {
     update_count_++;
     last_error_page_params_.reset(NULL);
     last_error_html_ = ErrorToString(error, is_failed_post);
   }
 
   virtual void FetchNavigationCorrections(
       const GURL& navigation_correction_url,
-      const std::string& navigation_correction_request_body) OVERRIDE {
+      const std::string& navigation_correction_request_body) override {
     EXPECT_TRUE(url_being_fetched_.is_empty());
     EXPECT_TRUE(request_body_.empty());
     EXPECT_EQ(GURL(kNavigationCorrectionUrl), navigation_correction_url);
 
     url_being_fetched_ = navigation_correction_url;
     request_body_ = navigation_correction_request_body;
 
     // Check the body of the request.
 
     base::JSONReader reader;
     scoped_ptr<base::Value> parsed_body(reader.Read(
         navigation_correction_request_body));
     ASSERT_TRUE(parsed_body);
     base::DictionaryValue* dict = NULL;
     ASSERT_TRUE(parsed_body->GetAsDictionary(&dict));
 
     EXPECT_TRUE(StringValueEquals(*dict, "params.urlQuery", kFailedUrl));
     EXPECT_TRUE(StringValueEquals(*dict, "params.language", kLanguage));
     EXPECT_TRUE(StringValueEquals(*dict, "params.originCountry", kCountry));
     EXPECT_TRUE(StringValueEquals(*dict, "params.key", kApiKey));
   }
 
-  virtual void CancelFetchNavigationCorrections() OVERRIDE {
+  virtual void CancelFetchNavigationCorrections() override {
     url_being_fetched_ = GURL();
     request_body_.clear();
   }
 
-  virtual void ReloadPage() OVERRIDE {
+  virtual void ReloadPage() override {
     reload_count_++;
   }
 
-  virtual void LoadPageFromCache(const GURL& error_url) OVERRIDE {
+  virtual void LoadPageFromCache(const GURL& error_url) override {
     load_stale_count_++;
     load_stale_url_ = error_url;
   }
 
   virtual void SendTrackingRequest(
       const GURL& tracking_url,
-      const std::string& tracking_request_body) OVERRIDE {
+      const std::string& tracking_request_body) override {
     last_tracking_url_ = tracking_url;
     last_tracking_request_body_ = tracking_request_body;
     tracking_request_count_++;
 
     // Check the body of the request.
 
     base::JSONReader reader;
     scoped_ptr<base::Value> parsed_body(reader.Read(tracking_request_body));
     ASSERT_TRUE(parsed_body);
     base::DictionaryValue* dict = NULL;
@@ skipping 1848 matching lines @@
   SetUpCore(true, true, false);
   DoErrorLoad(net::ERR_CONNECTION_RESET);
   EXPECT_FALSE(timer()->IsRunning());
   core()->OnWasShown();
   EXPECT_TRUE(timer()->IsRunning());
 }
 
 class NetErrorHelperCoreHistogramTest
     : public NetErrorHelperCoreAutoReloadTest {
  public:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     NetErrorHelperCoreAutoReloadTest::SetUp();
   }
 
   static const char kCountAtStop[];
   static const char kErrorAtStop[];
   static const char kCountAtSuccess[];
   static const char kErrorAtSuccess[];
   static const char kErrorAtFirstSuccess[];
 
  protected:
@@ skipping 177 matching lines @@
 
 TEST_F(NetErrorHelperCoreTest, ExplicitLoadStaleSucceeds) {
   DoErrorLoad(net::ERR_CONNECTION_RESET);
   EXPECT_EQ(0, load_stale_count());
   core()->ExecuteButtonPress(NetErrorHelperCore::LOAD_STALE_BUTTON);
   EXPECT_EQ(1, load_stale_count());
   EXPECT_EQ(GURL(kFailedUrl), load_stale_url());
 }
 
 } // namespace