replace OVERRIDE and FINAL with override and final in extensions/

extensions/browser/quota_service_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 "base/message_loop/message_loop.h"
 #include "base/process/process.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "content/public/test/test_browser_thread.h"
 #include "extensions/browser/extension_function.h"
@@ skipping 19 matching lines @@
 const Config k2PerMinute = {2, TimeDelta::FromMinutes(1)};
 const Config k20PerHour = {20, TimeDelta::FromHours(1)};
 const TimeTicks kStartTime = TimeTicks();
 const TimeTicks k1MinuteAfterStart = kStartTime + TimeDelta::FromMinutes(1);
 
 class Mapper : public QuotaLimitHeuristic::BucketMapper {
  public:
   Mapper() {}
   virtual ~Mapper() { STLDeleteValues(&buckets_); }
   virtual void GetBucketsForArgs(const base::ListValue* args,
-                                 BucketList* buckets) OVERRIDE {
+                                 BucketList* buckets) override {
     for (size_t i = 0; i < args->GetSize(); i++) {
       int id;
       ASSERT_TRUE(args->GetInteger(i, &id));
       if (buckets_.find(id) == buckets_.end())
         buckets_[id] = new Bucket();
       buckets->push_back(buckets_[id]);
     }
   }
 
  private:
   typedef std::map<int, Bucket*> BucketMap;
   BucketMap buckets_;
   DISALLOW_COPY_AND_ASSIGN(Mapper);
 };
 
 class MockMapper : public QuotaLimitHeuristic::BucketMapper {
  public:
   virtual void GetBucketsForArgs(const base::ListValue* args,
-                                 BucketList* buckets) OVERRIDE {}
+                                 BucketList* buckets) override {}
 };
 
 class MockFunction : public ExtensionFunction {
  public:
   explicit MockFunction(const std::string& name) { set_name(name); }
 
-  virtual void SetArgs(const base::ListValue* args) OVERRIDE {}
-  virtual std::string GetError() const OVERRIDE { return std::string(); }
-  virtual void SetError(const std::string& error) OVERRIDE {}
-  virtual void Destruct() const OVERRIDE { delete this; }
-  virtual ResponseAction Run() OVERRIDE { return RespondLater(); }
-  virtual void SendResponse(bool) OVERRIDE {}
+  virtual void SetArgs(const base::ListValue* args) override {}
+  virtual std::string GetError() const override { return std::string(); }
+  virtual void SetError(const std::string& error) override {}
+  virtual void Destruct() const override { delete this; }
+  virtual ResponseAction Run() override { return RespondLater(); }
+  virtual void SendResponse(bool) override {}
 
  protected:
   virtual ~MockFunction() {}
 };
 
 class TimedLimitMockFunction : public MockFunction {
  public:
   explicit TimedLimitMockFunction(const std::string& name)
       : MockFunction(name) {}
   virtual void GetQuotaLimitHeuristics(QuotaLimitHeuristics* heuristics) const
-      OVERRIDE {
+      override {
     heuristics->push_back(
         new TimedLimit(k2PerMinute, new Mapper(), kGenericName));
   }
 
  private:
   virtual ~TimedLimitMockFunction() {}
 };
 
 class ChainedLimitsMockFunction : public MockFunction {
  public:
   explicit ChainedLimitsMockFunction(const std::string& name)
       : MockFunction(name) {}
   virtual void GetQuotaLimitHeuristics(QuotaLimitHeuristics* heuristics) const
-      OVERRIDE {
+      override {
     // No more than 2 per minute sustained over 5 minutes.
     heuristics->push_back(new SustainedLimit(
         TimeDelta::FromMinutes(5), k2PerMinute, new Mapper(), kGenericName));
     // No more than 20 per hour.
     heuristics->push_back(
         new TimedLimit(k20PerHour, new Mapper(), kGenericName));
   }
 
  private:
   virtual ~ChainedLimitsMockFunction() {}
 };
 
 class FrozenMockFunction : public MockFunction {
  public:
   explicit FrozenMockFunction(const std::string& name) : MockFunction(name) {}
   virtual void GetQuotaLimitHeuristics(QuotaLimitHeuristics* heuristics) const
-      OVERRIDE {
+      override {
     heuristics->push_back(
         new TimedLimit(kFrozenConfig, new Mapper(), kGenericName));
   }
 
  private:
   virtual ~FrozenMockFunction() {}
 };
 }  // namespace
 
 class QuotaServiceTest : public testing::Test {
@@ skipping 283 matching lines @@
       "",
       service_->Assess(
           extension_a_, f.get(), &arg, kStartTime + TimeDelta::FromDays(1)));
   EXPECT_NE(
       "",
       service_->Assess(
           extension_a_, g.get(), &arg, kStartTime + TimeDelta::FromDays(1)));
 }
 
 }  // namespace extensions