replace OVERRIDE and FINAL with override and final in chrome/browser/[j-q]*

chrome/browser/prerender/prerender_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 <map>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/format_macros.h"
 #include "base/memory/scoped_vector.h"
@@ skipping 39 matching lines @@
                          Origin origin,
                          FinalStatus expected_final_status);
 
   virtual ~DummyPrerenderContents();
 
   virtual void StartPrerendering(
       int ALLOW_UNUSED creator_child_id,
       const gfx::Size& ALLOW_UNUSED size,
       content::SessionStorageNamespace* ALLOW_UNUSED session_storage_namespace,
       net::URLRequestContextGetter* ALLOW_UNUSED request_context)
-      OVERRIDE;
+      override;
 
-  virtual bool GetChildId(int* child_id) const OVERRIDE {
+  virtual bool GetChildId(int* child_id) const override {
     // Having a default child_id of -1 forces pending prerenders not to fail
     // on session storage and cross domain checking.
     *child_id = -1;
     return true;
   }
 
-  virtual bool GetRouteId(int* route_id) const OVERRIDE {
+  virtual bool GetRouteId(int* route_id) const override {
     *route_id = route_id_;
     return true;
   }
 
   FinalStatus expected_final_status() const { return expected_final_status_; }
 
   bool prerendering_has_been_cancelled() const {
     return PrerenderContents::prerendering_has_been_cancelled();
   }
 
@@ skipping 25 matching lines @@
         time_ticks_(TimeTicks::Now()),
         prerender_tracker_(prerender_tracker) {
     set_rate_limit_enabled(false);
     OnCookieStoreLoaded();
   }
 
   virtual ~UnitTestPrerenderManager() {
   }
 
   // From KeyedService, via PrererenderManager:
-  virtual void Shutdown() OVERRIDE {
+  virtual void Shutdown() override {
     if (next_prerender_contents())
       next_prerender_contents_->Destroy(FINAL_STATUS_MANAGER_SHUTDOWN);
     PrerenderManager::Shutdown();
   }
 
   // From PrerenderManager:
   virtual void MoveEntryToPendingDelete(PrerenderContents* entry,
-                                        FinalStatus final_status) OVERRIDE {
+                                        FinalStatus final_status) override {
     if (entry == next_prerender_contents_.get())
       return;
     PrerenderManager::MoveEntryToPendingDelete(entry, final_status);
   }
 
   PrerenderContents* FindEntry(const GURL& url) {
     DeleteOldEntries();
     to_delete_prerenders_.clear();
     if (PrerenderData* data = FindPrerenderData(url, NULL))
       return data->contents();
@@ skipping 63 matching lines @@
 
   void set_rate_limit_enabled(bool enabled) {
     mutable_config().rate_limit_enabled = enabled;
   }
 
   PrerenderContents* next_prerender_contents() {
     return next_prerender_contents_.get();
   }
 
   // from PrerenderManager
-  virtual Time GetCurrentTime() const OVERRIDE {
+  virtual Time GetCurrentTime() const override {
     return time_;
   }
 
-  virtual TimeTicks GetCurrentTimeTicks() const OVERRIDE {
+  virtual TimeTicks GetCurrentTimeTicks() const override {
     return time_ticks_;
   }
 
   virtual PrerenderContents* GetPrerenderContentsForRoute(
-      int child_id, int route_id) const OVERRIDE {
+      int child_id, int route_id) const override {
     // Overridden for the PrerenderLinkManager's pending prerender logic.
     PrerenderContentsMap::const_iterator iter = prerender_contents_map_.find(
         std::make_pair(child_id, route_id));
     if (iter == prerender_contents_map_.end())
       return NULL;
     return iter->second;
   }
 
   void DummyPrerenderContentsStarted(int child_id,
                                      int route_id,
                                      PrerenderContents* prerender_contents) {
     prerender_contents_map_[std::make_pair(child_id, route_id)] =
         prerender_contents;
   }
 
   void DummyPrerenderContentsDestroyed(int child_id,
                                        int route_id) {
     prerender_contents_map_.erase(std::make_pair(child_id, route_id));
   }
 
  protected:
-  virtual net::URLRequestContextGetter* GetURLRequestContext() OVERRIDE {
+  virtual net::URLRequestContextGetter* GetURLRequestContext() override {
     return NULL;
   }
 
  private:
   void SetNextPrerenderContents(DummyPrerenderContents* prerender_contents) {
     CHECK(!next_prerender_contents_.get());
     next_prerender_contents_.reset(prerender_contents);
     if (prerender_contents->expected_final_status() == FINAL_STATUS_USED)
       used_prerender_contents_.push_back(prerender_contents);
   }
 
 
   virtual PrerenderContents* CreatePrerenderContents(
       const GURL& url,
       const Referrer& referrer,
       Origin origin,
-      uint8 experiment_id) OVERRIDE {
+      uint8 experiment_id) override {
     CHECK(next_prerender_contents_.get());
     EXPECT_EQ(url, next_prerender_contents_->prerender_url());
     EXPECT_EQ(origin, next_prerender_contents_->origin());
     return next_prerender_contents_.release();
   }
 
   // Maintain a map from route pairs to PrerenderContents for
   // GetPrerenderContentsForRoute.
   typedef std::map<std::pair<int,int>, PrerenderContents*> PrerenderContentsMap;
   PrerenderContentsMap prerender_contents_map_;
@@ skipping 1317 matching lines @@
   CHECK(prerender_handle.get());
   EXPECT_TRUE(prerender_handle->IsPrerendering());
   EXPECT_TRUE(prerender_contents->prerendering_has_started());
   EXPECT_EQ(prerender_contents, prerender_handle->contents());
   EXPECT_EQ(ORIGIN_INSTANT, prerender_handle->contents()->origin());
   ASSERT_EQ(prerender_contents, prerender_manager()->FindAndUseEntry(url));
   EXPECT_FALSE(prerender_handle->IsPrerendering());
 }
 
 }  // namespace prerender