Make all quota-exceeding messages in the storage API explain what the failure

is. This involves adding descriptions to all errors from ExtensionsQuotaService,
affecting the other APIs that use this (bookmarks and webRequest).

BUG=144533

Review URL: https://chromiumcodereview.appspot.com/10871034

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@154415 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 78 insertions, 68 deletions

diff --git a/chrome/browser/extensions/extensions_quota_service_unittest.cc b/chrome/browser/extensions/extensions_quota_service_unittest.cc
index 96cfdb7..8dd7d22 100644
--- a/chrome/browser/extensions/extensions_quota_service_unittest.cc
+++ b/chrome/browser/extensions/extensions_quota_service_unittest.cc
@@ -21,14 +21,15 @@ typedef QuotaLimitHeuristic::BucketList BucketList;
 typedef ExtensionsQuotaService::TimedLimit TimedLimit;
 typedef ExtensionsQuotaService::SustainedLimit SustainedLimit;
 
-static const Config kFrozenConfig = { 0, TimeDelta::FromDays(0) };
-static const Config k2PerMinute = { 2, TimeDelta::FromMinutes(1) };
-static const Config k20PerHour = { 20, TimeDelta::FromHours(1) };
-static const TimeTicks kStartTime = TimeTicks();
-static const TimeTicks k1MinuteAfterStart =
-    kStartTime + TimeDelta::FromMinutes(1);
-
 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 TimeTicks kStartTime = TimeTicks();
+const TimeTicks k1MinuteAfterStart = kStartTime + TimeDelta::FromMinutes(1);
+
 class Mapper : public QuotaLimitHeuristic::BucketMapper {
  public:
   Mapper() {}
@@ -75,7 +76,8 @@ class TimedLimitMockFunction : public MockFunction {
       : MockFunction(name) {}
   virtual void GetQuotaLimitHeuristics(
       QuotaLimitHeuristics* heuristics) const {
-    heuristics->push_back(new TimedLimit(k2PerMinute, new Mapper()));
+    heuristics->push_back(
+        new TimedLimit(k2PerMinute, new Mapper(), kGenericName));
   }
 
  private:
@@ -89,10 +91,11 @@ class ChainedLimitsMockFunction : public MockFunction {
   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()));
+    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()));
+    heuristics->push_back(
+        new TimedLimit(k20PerHour, new Mapper(), kGenericName));
   }
 
  private:
@@ -104,7 +107,8 @@ class FrozenMockFunction : public MockFunction {
   explicit FrozenMockFunction(const std::string& name) : MockFunction(name) {}
   virtual void GetQuotaLimitHeuristics(
       QuotaLimitHeuristics* heuristics) const {
-    heuristics->push_back(new TimedLimit(kFrozenConfig, new Mapper()));
+    heuristics->push_back(
+        new TimedLimit(kFrozenConfig, new Mapper(), kGenericName));
   }
 
  private:
@@ -165,7 +169,7 @@ class QuotaLimitHeuristicTest : public testing::Test {
 };
 
 TEST_F(QuotaLimitHeuristicTest, Timed) {
-  TimedLimit lim(k2PerMinute, new MockMapper());
+  TimedLimit lim(k2PerMinute, new MockMapper(), kGenericName);
   Bucket b;
 
   b.Reset(k2PerMinute, kStartTime);
@@ -184,7 +188,8 @@ TEST_F(QuotaLimitHeuristicTest, Timed) {
 }
 
 TEST_F(QuotaLimitHeuristicTest, Sustained) {
-  SustainedLimit lim(TimeDelta::FromMinutes(5), k2PerMinute, new MockMapper());
+  SustainedLimit lim(
+      TimeDelta::FromMinutes(5), k2PerMinute, new MockMapper(), kGenericName);
   Bucket bucket;
 
   bucket.Reset(k2PerMinute, kStartTime);
@@ -210,54 +215,55 @@ TEST_F(QuotaLimitHeuristicTest, Sustained) {
 TEST_F(ExtensionsQuotaServiceTest, NoHeuristic) {
   scoped_refptr<MockFunction> f(new MockFunction("foo"));
   ListValue args;
-  EXPECT_TRUE(service_->Assess(extension_a_, f, &args, kStartTime));
+  EXPECT_EQ("", service_->Assess(extension_a_, f, &args, kStartTime));
 }
 
 TEST_F(ExtensionsQuotaServiceTest, FrozenHeuristic) {
   scoped_refptr<MockFunction> f(new FrozenMockFunction("foo"));
   ListValue args;
   args.Append(new base::FundamentalValue(1));
-  EXPECT_FALSE(service_->Assess(extension_a_, f, &args, kStartTime));
+  EXPECT_NE("", service_->Assess(extension_a_, f, &args, kStartTime));
 }
 
 TEST_F(ExtensionsQuotaServiceTest, SingleHeuristic) {
   scoped_refptr<MockFunction> f(new TimedLimitMockFunction("foo"));
   ListValue args;
   args.Append(new base::FundamentalValue(1));
-  EXPECT_TRUE(service_->Assess(extension_a_, f, &args, kStartTime));
-  EXPECT_TRUE(service_->Assess(extension_a_, f, &args,
-              kStartTime + TimeDelta::FromSeconds(10)));
-  EXPECT_FALSE(service_->Assess(extension_a_, f, &args,
+  EXPECT_EQ("", service_->Assess(extension_a_, f, &args, kStartTime));
+  EXPECT_EQ("", service_->Assess(extension_a_, f, &args,
+                                 kStartTime + TimeDelta::FromSeconds(10)));
+  EXPECT_NE("", service_->Assess(extension_a_, f, &args,
               kStartTime + TimeDelta::FromSeconds(15)));
 
   ListValue args2;
   args2.Append(new base::FundamentalValue(1));
   args2.Append(new base::FundamentalValue(2));
-  EXPECT_TRUE(service_->Assess(extension_b_, f, &args2, kStartTime));
-  EXPECT_TRUE(service_->Assess(extension_b_, f, &args2,
-              kStartTime + TimeDelta::FromSeconds(10)));
+  EXPECT_EQ("", service_->Assess(extension_b_, f, &args2, kStartTime));
+  EXPECT_EQ("", service_->Assess(extension_b_, f, &args2,
+                                 kStartTime + TimeDelta::FromSeconds(10)));
 
   TimeDelta peace = TimeDelta::FromMinutes(30);
-  EXPECT_TRUE(service_->Assess(extension_b_, f, &args, kStartTime + peace));
-  EXPECT_TRUE(service_->Assess(extension_b_, f, &args,
-              kStartTime + peace + TimeDelta::FromSeconds(10)));
-  EXPECT_FALSE(service_->Assess(extension_b_, f, &args2,
+  EXPECT_EQ("", service_->Assess(extension_b_, f, &args, kStartTime + peace));
+  EXPECT_EQ("", service_->Assess(
+        extension_b_, f, &args,
+        kStartTime + peace + TimeDelta::FromSeconds(10)));
+  EXPECT_NE("", service_->Assess(extension_b_, f, &args2,
                kStartTime + peace + TimeDelta::FromSeconds(15)));
 
   // Test that items are independent.
   ListValue args3;
   args3.Append(new base::FundamentalValue(3));
-  EXPECT_TRUE(service_->Assess(extension_c_, f, &args, kStartTime));
-  EXPECT_TRUE(service_->Assess(extension_c_, f, &args3,
-              kStartTime + TimeDelta::FromSeconds(10)));
-  EXPECT_TRUE(service_->Assess(extension_c_, f, &args,
-              kStartTime + TimeDelta::FromSeconds(15)));
-  EXPECT_TRUE(service_->Assess(extension_c_, f, &args3,
-              kStartTime + TimeDelta::FromSeconds(20)));
-  EXPECT_FALSE(service_->Assess(extension_c_, f, &args,
-               kStartTime + TimeDelta::FromSeconds(25)));
-  EXPECT_FALSE(service_->Assess(extension_c_, f, &args3,
-               kStartTime + TimeDelta::FromSeconds(30)));
+  EXPECT_EQ("", service_->Assess(extension_c_, f, &args, kStartTime));
+  EXPECT_EQ("", service_->Assess(extension_c_, f, &args3,
+                                 kStartTime + TimeDelta::FromSeconds(10)));
+  EXPECT_EQ("", service_->Assess(extension_c_, f, &args,
+                                 kStartTime + TimeDelta::FromSeconds(15)));
+  EXPECT_EQ("", service_->Assess(extension_c_, f, &args3,
+                                 kStartTime + TimeDelta::FromSeconds(20)));
+  EXPECT_NE("", service_->Assess(extension_c_, f, &args,
+                                 kStartTime + TimeDelta::FromSeconds(25)));
+  EXPECT_NE("", service_->Assess(extension_c_, f, &args3,
+                                 kStartTime + TimeDelta::FromSeconds(30)));
 }
 
 TEST_F(ExtensionsQuotaServiceTest, ChainedHeuristics) {
@@ -269,25 +275,29 @@ TEST_F(ExtensionsQuotaServiceTest, ChainedHeuristics) {
   // One event per minute for 20 minutes comes in under the sustained limit,
   // but is equal to the timed limit.
   for (int i = 0; i < 20; i++) {
-    EXPECT_TRUE(service_->Assess(extension_a_, f, &args,
-                kStartTime + TimeDelta::FromSeconds(10 + i * 60)));
+    EXPECT_EQ("", service_->Assess(
+          extension_a_, f, &args,
+          kStartTime + TimeDelta::FromSeconds(10 + i * 60)));
   }
 
   // This will bring us to 21 events in an hour, which is a violation.
-  EXPECT_FALSE(service_->Assess(extension_a_, f, &args,
-               kStartTime + TimeDelta::FromMinutes(30)));
+  EXPECT_NE("", service_->Assess(extension_a_, f, &args,
+                                 kStartTime + TimeDelta::FromMinutes(30)));
 
   // Now, check that we can still hit the lower limit.
   for (int i = 0; i < 5; i++) {
-    EXPECT_TRUE(service_->Assess(extension_b_, f, &args,
-                kStartTime + TimeDelta::FromSeconds(10 + i * 60)));
-    EXPECT_TRUE(service_->Assess(extension_b_, f, &args,
-                kStartTime + TimeDelta::FromSeconds(15 + i * 60)));
-    EXPECT_TRUE(service_->Assess(extension_b_, f, &args,
-                kStartTime + TimeDelta::FromSeconds(20 + i * 60)));
+    EXPECT_EQ("", service_->Assess(
+          extension_b_, f, &args,
+          kStartTime + TimeDelta::FromSeconds(10 + i * 60)));
+    EXPECT_EQ("", service_->Assess(
+          extension_b_, f, &args,
+          kStartTime + TimeDelta::FromSeconds(15 + i * 60)));
+    EXPECT_EQ("", service_->Assess(
+          extension_b_, f, &args,
+          kStartTime + TimeDelta::FromSeconds(20 + i * 60)));
   }
 
-  EXPECT_FALSE(service_->Assess(extension_b_, f, &args,
+  EXPECT_NE("", service_->Assess(extension_b_, f, &args,
                kStartTime + TimeDelta::FromMinutes(6)));
 }
 
@@ -300,16 +310,16 @@ TEST_F(ExtensionsQuotaServiceTest, MultipleFunctionsDontInterfere) {
   args_f.Append(new base::FundamentalValue(1));
   args_g.Append(new base::FundamentalValue(2));
 
-  EXPECT_TRUE(service_->Assess(extension_a_, f, &args_f, kStartTime));
-  EXPECT_TRUE(service_->Assess(extension_a_, g, &args_g, kStartTime));
-  EXPECT_TRUE(service_->Assess(extension_a_, f, &args_f,
-              kStartTime + TimeDelta::FromSeconds(10)));
-  EXPECT_TRUE(service_->Assess(extension_a_, g, &args_g,
-              kStartTime + TimeDelta::FromSeconds(10)));
-  EXPECT_FALSE(service_->Assess(extension_a_, f, &args_f,
-               kStartTime + TimeDelta::FromSeconds(15)));
-  EXPECT_FALSE(service_->Assess(extension_a_, g, &args_g,
-               kStartTime + TimeDelta::FromSeconds(15)));
+  EXPECT_EQ("", service_->Assess(extension_a_, f, &args_f, kStartTime));
+  EXPECT_EQ("", service_->Assess(extension_a_, g, &args_g, kStartTime));
+  EXPECT_EQ("", service_->Assess(extension_a_, f, &args_f,
+                                 kStartTime + TimeDelta::FromSeconds(10)));
+  EXPECT_EQ("", service_->Assess(extension_a_, g, &args_g,
+                                 kStartTime + TimeDelta::FromSeconds(10)));
+  EXPECT_NE("", service_->Assess(extension_a_, f, &args_f,
+                                 kStartTime + TimeDelta::FromSeconds(15)));
+  EXPECT_NE("", service_->Assess(extension_a_, g, &args_g,
+                                 kStartTime + TimeDelta::FromSeconds(15)));
 }
 
 TEST_F(ExtensionsQuotaServiceTest, ViolatorsWillBeViolators) {
@@ -317,16 +327,16 @@ TEST_F(ExtensionsQuotaServiceTest, ViolatorsWillBeViolators) {
   scoped_refptr<MockFunction> g(new TimedLimitMockFunction("bar"));
   ListValue arg;
   arg.Append(new base::FundamentalValue(1));
-  EXPECT_TRUE(service_->Assess(extension_a_, f, &arg, kStartTime));
-  EXPECT_TRUE(service_->Assess(extension_a_, f, &arg,
-              kStartTime + TimeDelta::FromSeconds(10)));
-  EXPECT_FALSE(service_->Assess(extension_a_, f, &arg,
-               kStartTime + TimeDelta::FromSeconds(15)));
+  EXPECT_EQ("", service_->Assess(extension_a_, f, &arg, kStartTime));
+  EXPECT_EQ("", service_->Assess(extension_a_, f, &arg,
+                                 kStartTime + TimeDelta::FromSeconds(10)));
+  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_FALSE(service_->Assess(extension_a_, f, &arg,
-               kStartTime + TimeDelta::FromDays(1)));
-  EXPECT_FALSE(service_->Assess(extension_a_, g, &arg,
-               kStartTime + TimeDelta::FromDays(1)));
+  EXPECT_NE("", service_->Assess(extension_a_, f, &arg,
+                                 kStartTime + TimeDelta::FromDays(1)));
+  EXPECT_NE("", service_->Assess(extension_a_, g, &arg,
+                                 kStartTime + TimeDelta::FromDays(1)));
 }