replace OVERRIDE and FINAL with override and final in components/

components/visitedlink/test/visitedlink_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 <cstdio>
 #include <string>
 #include <vector>
 
 #include "base/files/file_util.h"
 #include "base/memory/shared_memory.h"
@@ skipping 37 matching lines @@
 // Returns a test URL for index |i|
 GURL TestURL(int i) {
   return GURL(base::StringPrintf("%s%d", g_test_prefix, i));
 }
 
 std::vector<VisitedLinkSlave*> g_slaves;
 
 class TestVisitedLinkDelegate : public VisitedLinkDelegate {
  public:
   virtual void RebuildTable(
-      const scoped_refptr<URLEnumerator>& enumerator) OVERRIDE;
+      const scoped_refptr<URLEnumerator>& enumerator) override;
 
   void AddURLForRebuild(const GURL& url);
 
  private:
   URLs rebuild_urls_;
 };
 
 void TestVisitedLinkDelegate::RebuildTable(
     const scoped_refptr<URLEnumerator>& enumerator) {
   for (URLs::const_iterator itr = rebuild_urls_.begin();
        itr != rebuild_urls_.end();
        ++itr)
     enumerator->OnURL(*itr);
   enumerator->OnComplete(true);
 }
 
 void TestVisitedLinkDelegate::AddURLForRebuild(const GURL& url) {
   rebuild_urls_.push_back(url);
 }
 
 class TestURLIterator : public VisitedLinkMaster::URLIterator {
  public:
   explicit TestURLIterator(const URLs& urls);
 
-  virtual const GURL& NextURL() OVERRIDE;
-  virtual bool HasNextURL() const OVERRIDE;
+  virtual const GURL& NextURL() override;
+  virtual bool HasNextURL() const override;
 
  private:
   URLs::const_iterator iterator_;
   URLs::const_iterator end_;
 };
 
 TestURLIterator::TestURLIterator(const URLs& urls)
     : iterator_(urls.begin()),
       end_(urls.end()) {
 }
 
 const GURL& TestURLIterator::NextURL() {
   return *(iterator_++);
 }
 
 bool TestURLIterator::HasNextURL() const {
   return iterator_ != end_;
 }
 
 }  // namespace
 
 class TrackingVisitedLinkEventListener : public VisitedLinkMaster::Listener {
  public:
   TrackingVisitedLinkEventListener()
       : reset_count_(0),
         add_count_(0) {}
 
-  virtual void NewTable(base::SharedMemory* table) OVERRIDE {
+  virtual void NewTable(base::SharedMemory* table) override {
     if (table) {
       for (std::vector<VisitedLinkSlave>::size_type i = 0;
            i < g_slaves.size(); i++) {
         base::SharedMemoryHandle new_handle = base::SharedMemory::NULLHandle();
         table->ShareToProcess(base::GetCurrentProcessHandle(), &new_handle);
         g_slaves[i]->OnUpdateVisitedLinks(new_handle);
       }
     }
   }
-  virtual void Add(VisitedLinkCommon::Fingerprint) OVERRIDE { add_count_++; }
-  virtual void Reset() OVERRIDE { reset_count_++; }
+  virtual void Add(VisitedLinkCommon::Fingerprint) override { add_count_++; }
+  virtual void Reset() override { reset_count_++; }
 
   void SetUp() {
     reset_count_ = 0;
     add_count_ = 0;
   }
 
   int reset_count() const { return reset_count_; }
   int add_count() const { return add_count_; }
 
  private:
@@ skipping 402 matching lines @@
         content::Source<RenderProcessHost>(this),
         content::NotificationService::NoDetails());
   }
   virtual ~VisitRelayingRenderProcessHost() {
     content::NotificationService::current()->Notify(
         content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
         content::Source<content::RenderProcessHost>(this),
         content::NotificationService::NoDetails());
   }
 
-  virtual void WidgetRestored() OVERRIDE { widgets_++; }
-  virtual void WidgetHidden() OVERRIDE { widgets_--; }
-  virtual int VisibleWidgetCount() const OVERRIDE { return widgets_; }
+  virtual void WidgetRestored() override { widgets_++; }
+  virtual void WidgetHidden() override { widgets_--; }
+  virtual int VisibleWidgetCount() const override { return widgets_; }
 
-  virtual bool Send(IPC::Message* msg) OVERRIDE {
+  virtual bool Send(IPC::Message* msg) override {
     VisitCountingContext* counting_context =
         static_cast<VisitCountingContext*>(
             GetBrowserContext());
 
     if (msg->type() == ChromeViewMsg_VisitedLink_Add::ID) {
       PickleIterator iter(*msg);
       std::vector<uint64> fingerprints;
       CHECK(IPC::ReadParam(msg, &iter, &fingerprints));
       counting_context->CountAddEvent(fingerprints.size());
     } else if (msg->type() == ChromeViewMsg_VisitedLink_Reset::ID) {
@@ skipping 12 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(VisitRelayingRenderProcessHost);
 };
 
 class VisitedLinkRenderProcessHostFactory
     : public content::RenderProcessHostFactory {
  public:
   VisitedLinkRenderProcessHostFactory()
       : content::RenderProcessHostFactory() {}
   virtual content::RenderProcessHost* CreateRenderProcessHost(
       content::BrowserContext* browser_context,
-      content::SiteInstance* site_instance) const OVERRIDE {
+      content::SiteInstance* site_instance) const override {
     return new VisitRelayingRenderProcessHost(browser_context);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(VisitedLinkRenderProcessHostFactory);
 };
 
 class VisitedLinkEventsTest : public content::RenderViewHostTestHarness {
  public:
   virtual void SetUp() {
     SetRenderProcessHostFactory(&vc_rph_factory_);
     content::RenderViewHostTestHarness::SetUp();
   }
 
-  virtual content::BrowserContext* CreateBrowserContext() OVERRIDE {
+  virtual content::BrowserContext* CreateBrowserContext() override {
     VisitCountingContext* context = new VisitCountingContext();
     master_.reset(new VisitedLinkMaster(context, &delegate_, true));
     master_->Init();
     return context;
   }
 
   VisitCountingContext* context() {
     return static_cast<VisitCountingContext*>(browser_context());
   }
 
@@ skipping 152 matching lines @@
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_RENDERER_PROCESS_CREATED,
       content::Source<content::RenderProcessHost>(&different_process_host),
       content::NotificationService::NoDetails());
   WaitForCoalescense();
 
   EXPECT_EQ(0, different_context.new_table_count());
 }
 
 }  // namespace visitedlink