RefCounted types should not have public destructors, chrome/browser/extensions

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 38 matching lines @@
 };
 
 class MockMapper : public QuotaLimitHeuristic::BucketMapper {
  public:
   virtual void GetBucketsForArgs(const ListValue* args, BucketList* buckets) {}
 };
 
 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 {
     heuristics->push_back(new TimedLimit(k2PerMinute, new Mapper()));
   }
+
+ private:
+  virtual ~TimedLimitMockFunction() {}
 };
 
 class ChainedLimitsMockFunction : public MockFunction {
  public:
   explicit ChainedLimitsMockFunction(const std::string& name)
       : MockFunction(name) {}
   virtual void GetQuotaLimitHeuristics(
       QuotaLimitHeuristics* heuristics) const {
     // No more than 2 per minute sustained over 5 minutes.
     heuristics->push_back(new SustainedLimit(TimeDelta::FromMinutes(5),
         k2PerMinute, new Mapper()));
     // No more than 20 per hour.
     heuristics->push_back(new TimedLimit(k20PerHour, new Mapper()));
   }
+
+ private:
+  virtual ~ChainedLimitsMockFunction() {}
 };
 
 class FrozenMockFunction : public MockFunction {
  public:
   explicit FrozenMockFunction(const std::string& name) : MockFunction(name) {}
   virtual void GetQuotaLimitHeuristics(
       QuotaLimitHeuristics* heuristics) const {
     heuristics->push_back(new TimedLimit(kFrozenConfig, new Mapper()));
   }
+
+ private:
+  virtual ~FrozenMockFunction() {}
 };
 }  // namespace
 
 class ExtensionsQuotaServiceTest : public testing::Test {
  public:
   ExtensionsQuotaServiceTest()
       : extension_a_("a"),
         extension_b_("b"),
         extension_c_("c"),
         loop_(),
@@ skipping 201 matching lines @@
   EXPECT_FALSE(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_FALSE(service_->Assess(extension_a_, f, &arg,
                kStartTime + TimeDelta::FromDays(1)));
   EXPECT_FALSE(service_->Assess(extension_a_, g, &arg,
                kStartTime + TimeDelta::FromDays(1)));
 }