Moved ExtensionInfoMap and ExtensionsQuotaService to extensions/

extensions/browser/quota_service_unittest.cc

Index: extensions/browser/quota_service_unittest.cc
diff --git a/chrome/browser/extensions/extensions_quota_service_unittest.cc b/extensions/browser/quota_service_unittest.cc
similarity index 91%
rename from chrome/browser/extensions/extensions_quota_service_unittest.cc
rename to extensions/browser/quota_service_unittest.cc
index a0438ff3887d9f92199df43b820e187e255a4b6d..a156871abbea93f505fd763da41d347384a0bb45 100644
--- a/chrome/browser/extensions/extensions_quota_service_unittest.cc
+++ b/extensions/browser/quota_service_unittest.cc
@@ -7,26 +7,28 @@
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "chrome/browser/extensions/extension_function.h"
-#include "chrome/browser/extensions/extensions_quota_service.h"
 #include "content/public/test/test_browser_thread.h"
+#include "extensions/browser/quota_service.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 using content::BrowserThread;
 
+namespace extensions {
+
 typedef QuotaLimitHeuristic::Bucket Bucket;
 typedef QuotaLimitHeuristic::Config Config;
 typedef QuotaLimitHeuristic::BucketList BucketList;
-typedef ExtensionsQuotaService::TimedLimit TimedLimit;
-typedef ExtensionsQuotaService::SustainedLimit SustainedLimit;
+typedef QuotaService::TimedLimit TimedLimit;
+typedef QuotaService::SustainedLimit SustainedLimit;
 
 namespace {
 
 const char kGenericName[] = "name";
-const Config kFrozenConfig = { 0, TimeDelta::FromDays(0) };
-const Config k2PerMinute = { 2, TimeDelta::FromMinutes(1) };
-const Config k20PerHour = { 20, TimeDelta::FromHours(1) };
+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);
 
@@ -44,6 +46,7 @@ class Mapper : public QuotaLimitHeuristic::BucketMapper {
       buckets->push_back(buckets_[id]);
     }
   }
+
  private:
   typedef std::map<int, Bucket*> BucketMap;
   BucketMap buckets_;
@@ -53,8 +56,7 @@ class Mapper : public QuotaLimitHeuristic::BucketMapper {
 class MockMapper : public QuotaLimitHeuristic::BucketMapper {
  public:
   virtual void GetBucketsForArgs(const base::ListValue* args,
-                                 BucketList* buckets) OVERRIDE {
-  }
+                                 BucketList* buckets) OVERRIDE {}
 };
 
 class MockFunction : public ExtensionFunction {
@@ -67,7 +69,7 @@ class MockFunction : public ExtensionFunction {
   virtual void Run() OVERRIDE {}
   virtual void Destruct() const OVERRIDE { delete this; }
   virtual bool RunImpl() OVERRIDE { return true; }
-  virtual void SendResponse(bool) OVERRIDE { }
+  virtual void SendResponse(bool) OVERRIDE {}
 
  protected:
   virtual ~MockFunction() {}
@@ -77,8 +79,8 @@ class TimedLimitMockFunction : public MockFunction {
  public:
   explicit TimedLimitMockFunction(const std::string& name)
       : MockFunction(name) {}
-  virtual void GetQuotaLimitHeuristics(
-      QuotaLimitHeuristics* heuristics) const OVERRIDE {
+  virtual void GetQuotaLimitHeuristics(QuotaLimitHeuristics* heuristics) const
+      OVERRIDE {
     heuristics->push_back(
         new TimedLimit(k2PerMinute, new Mapper(), kGenericName));
   }
@@ -91,8 +93,8 @@ class ChainedLimitsMockFunction : public MockFunction {
  public:
   explicit ChainedLimitsMockFunction(const std::string& name)
       : MockFunction(name) {}
-  virtual void GetQuotaLimitHeuristics(
-      QuotaLimitHeuristics* heuristics) const OVERRIDE {
+  virtual void GetQuotaLimitHeuristics(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));
@@ -108,8 +110,8 @@ class ChainedLimitsMockFunction : public MockFunction {
 class FrozenMockFunction : public MockFunction {
  public:
   explicit FrozenMockFunction(const std::string& name) : MockFunction(name) {}
-  virtual void GetQuotaLimitHeuristics(
-      QuotaLimitHeuristics* heuristics) const OVERRIDE {
+  virtual void GetQuotaLimitHeuristics(QuotaLimitHeuristics* heuristics) const
+      OVERRIDE {
     heuristics->push_back(
         new TimedLimit(kFrozenConfig, new Mapper(), kGenericName));
   }
@@ -119,27 +121,25 @@ class FrozenMockFunction : public MockFunction {
 };
 }  // namespace
 
-class ExtensionsQuotaServiceTest : public testing::Test {
+class QuotaServiceTest : public testing::Test {
  public:
-  ExtensionsQuotaServiceTest()
+  QuotaServiceTest()
       : extension_a_("a"),
         extension_b_("b"),
         extension_c_("c"),
         loop_(),
-        ui_thread_(BrowserThread::UI, &loop_) {
-  }
-  virtual void SetUp() {
-    service_.reset(new ExtensionsQuotaService());
-  }
+        ui_thread_(BrowserThread::UI, &loop_) {}
+  virtual void SetUp() { service_.reset(new QuotaService()); }
   virtual void TearDown() {
     loop_.RunUntilIdle();
     service_.reset();
   }
+
  protected:
   std::string extension_a_;
   std::string extension_b_;
   std::string extension_c_;
-  scoped_ptr<ExtensionsQuotaService> service_;
+  scoped_ptr<QuotaService> service_;
   base::MessageLoop loop_;
   content::TestBrowserThread ui_thread_;
 };
@@ -180,7 +180,7 @@ TEST_F(QuotaLimitHeuristicTest, Timed) {
   EXPECT_TRUE(b.has_tokens());
   EXPECT_TRUE(lim.Apply(&b, kStartTime + TimeDelta::FromSeconds(30)));
   EXPECT_FALSE(b.has_tokens());
-  EXPECT_FALSE(lim.Apply(&b,  k1MinuteAfterStart));
+  EXPECT_FALSE(lim.Apply(&b, k1MinuteAfterStart));
 
   b.Reset(k2PerMinute, kStartTime);
   EXPECT_TRUE(lim.Apply(&b, k1MinuteAfterStart - TimeDelta::FromSeconds(1)));
@@ -215,20 +215,20 @@ TEST_F(QuotaLimitHeuristicTest, Sustained) {
   EXPECT_TRUE(lim.Apply(&bucket, kStartTime + TimeDelta::FromMinutes(6)));
 }
 
-TEST_F(ExtensionsQuotaServiceTest, NoHeuristic) {
+TEST_F(QuotaServiceTest, NoHeuristic) {
   scoped_refptr<MockFunction> f(new MockFunction("foo"));
   base::ListValue args;
   EXPECT_EQ("", service_->Assess(extension_a_, f.get(), &args, kStartTime));
 }
 
-TEST_F(ExtensionsQuotaServiceTest, FrozenHeuristic) {
+TEST_F(QuotaServiceTest, FrozenHeuristic) {
   scoped_refptr<MockFunction> f(new FrozenMockFunction("foo"));
   base::ListValue args;
   args.Append(new base::FundamentalValue(1));
   EXPECT_NE("", service_->Assess(extension_a_, f.get(), &args, kStartTime));
 }
 
-TEST_F(ExtensionsQuotaServiceTest, SingleHeuristic) {
+TEST_F(QuotaServiceTest, SingleHeuristic) {
   scoped_refptr<MockFunction> f(new TimedLimitMockFunction("foo"));
   base::ListValue args;
   args.Append(new base::FundamentalValue(1));
@@ -299,7 +299,7 @@ TEST_F(ExtensionsQuotaServiceTest, SingleHeuristic) {
                              kStartTime + TimeDelta::FromSeconds(30)));
 }
 
-TEST_F(ExtensionsQuotaServiceTest, ChainedHeuristics) {
+TEST_F(QuotaServiceTest, ChainedHeuristics) {
   scoped_refptr<MockFunction> f(new ChainedLimitsMockFunction("foo"));
   base::ListValue args;
   args.Append(new base::FundamentalValue(1));
@@ -352,7 +352,7 @@ TEST_F(ExtensionsQuotaServiceTest, ChainedHeuristics) {
                              kStartTime + TimeDelta::FromMinutes(6)));
 }
 
-TEST_F(ExtensionsQuotaServiceTest, MultipleFunctionsDontInterfere) {
+TEST_F(QuotaServiceTest, MultipleFunctionsDontInterfere) {
   scoped_refptr<MockFunction> f(new TimedLimitMockFunction("foo"));
   scoped_refptr<MockFunction> g(new TimedLimitMockFunction("bar"));
 
@@ -385,7 +385,7 @@ TEST_F(ExtensionsQuotaServiceTest, MultipleFunctionsDontInterfere) {
                              kStartTime + TimeDelta::FromSeconds(15)));
 }
 
-TEST_F(ExtensionsQuotaServiceTest, ViolatorsWillBeViolators) {
+TEST_F(QuotaServiceTest, ViolatorsWillBeViolators) {
   scoped_refptr<MockFunction> f(new TimedLimitMockFunction("foo"));
   scoped_refptr<MockFunction> g(new TimedLimitMockFunction("bar"));
   base::ListValue arg;
@@ -413,3 +413,5 @@ TEST_F(ExtensionsQuotaServiceTest, ViolatorsWillBeViolators) {
       service_->Assess(
           extension_a_, g.get(), &arg, kStartTime + TimeDelta::FromDays(1)));
 }
+
+}  // namespace extensions