Linux/ChromeOS Chromium style checker cleanup, chrome/browser/extensions edition.

chrome/browser/extensions/extensions_quota_service_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 "base/message_loop.h"
 #include "base/process.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "chrome/browser/extensions/extension_function.h"
 #include "chrome/browser/extensions/extensions_quota_service.h"
@@ skipping 16 matching lines @@
 const Config kFrozenConfig = { 0, TimeDelta::FromDays(0) };
 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 ListValue* args, BucketList* buckets) {
+  virtual void GetBucketsForArgs(const ListValue* args,
+                                 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 ListValue* args, BucketList* buckets) {}
+  virtual void GetBucketsForArgs(const ListValue* args,
+                                 BucketList* buckets) OVERRIDE {
+  }
 };
 
 class MockFunction : public ExtensionFunction {
  public:
   explicit MockFunction(const std::string& name) { set_name(name); }
 
   virtual void SetArgs(const ListValue* args) OVERRIDE {}
   virtual const std::string GetError() OVERRIDE { return std::string(); }
   virtual void SetError(const std::string& error) OVERRIDE {}
   virtual void Run() OVERRIDE {}
   virtual void Destruct() const OVERRIDE { delete this; }
   virtual bool RunImpl() OVERRIDE { return true; }
   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 {
+      QuotaLimitHeuristics* heuristics) const 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 {
+      QuotaLimitHeuristics* heuristics) const 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 {
+      QuotaLimitHeuristics* heuristics) const OVERRIDE {
     heuristics->push_back(
         new TimedLimit(kFrozenConfig, new Mapper(), kGenericName));
   }
 
  private:
   virtual ~FrozenMockFunction() {}
 };
 }  // namespace
 
 class ExtensionsQuotaServiceTest : public testing::Test {
@@ skipping 213 matching lines @@
   EXPECT_NE("", service_->Assess(extension_a_, f, &arg,
                                  kStartTime + TimeDelta::FromSeconds(15)));
 
   // We don't allow this extension to use quota limited functions even if they
   // wait a while.
   EXPECT_NE("", service_->Assess(extension_a_, f, &arg,
                                  kStartTime + TimeDelta::FromDays(1)));
   EXPECT_NE("", service_->Assess(extension_a_, g, &arg,
                                  kStartTime + TimeDelta::FromDays(1)));
 }