src/chrome/browser/extensions/api/storage/settings_quota_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/json/json_writer.h"
   6 #include "base/memory/ref_counted.h"
   7 #include "base/memory/scoped_ptr.h"
   8 #include "base/values.h"
   9 #include "chrome/browser/extensions/api/storage/settings_backend.h"
  10 #include "chrome/browser/extensions/api/storage/settings_storage_quota_enforcer.h"
  11 #include "chrome/browser/value_store/testing_value_store.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 using base::DictionaryValue;
  15 using base::ListValue;
  16 using base::Value;
  17
  18 namespace extensions {
  19
  20 // To save typing ValueStore::DEFAULTS/IGNORE_QUOTA everywhere.
  21 const ValueStore::WriteOptions DEFAULTS = ValueStore::DEFAULTS;
  22 const ValueStore::WriteOptions IGNORE_QUOTA =
  23     ValueStore::IGNORE_QUOTA;
  24
  25 class ExtensionSettingsQuotaTest : public testing::Test {
  26  public:
  27   ExtensionSettingsQuotaTest()
  28       : byte_value_1_(new base::FundamentalValue(1)),
  29         byte_value_16_(new base::StringValue("sixteen bytes.")),
  30         byte_value_256_(new ListValue()),
  31         delegate_(new TestingValueStore()) {
  32     for (int i = 1; i < 89; ++i) {
  33       byte_value_256_->Append(new base::FundamentalValue(i));
  34     }
  35     ValidateByteValues();
  36   }
  37
  38   void ValidateByteValues() {
  39     std::string validate_sizes;
  40     base::JSONWriter::Write(byte_value_1_.get(), &validate_sizes);
  41     ASSERT_EQ(1u, validate_sizes.size());
  42     base::JSONWriter::Write(byte_value_16_.get(), &validate_sizes);
  43     ASSERT_EQ(16u, validate_sizes.size());
  44     base::JSONWriter::Write(byte_value_256_.get(), &validate_sizes);
  45     ASSERT_EQ(256u, validate_sizes.size());
  46   }
  47
  48   virtual void TearDown() OVERRIDE {
  49     ASSERT_TRUE(storage_.get() != NULL);
  50   }
  51
  52  protected:
  53   // Creates |storage_|.  Must only be called once.
  54   void CreateStorage(
  55       size_t quota_bytes, size_t quota_bytes_per_item, size_t max_items) {
  56     ASSERT_TRUE(storage_.get() == NULL);
  57     SettingsStorageQuotaEnforcer::Limits limits =
  58         { quota_bytes, quota_bytes_per_item, max_items };
  59     storage_.reset(new SettingsStorageQuotaEnforcer(limits, delegate_));
  60   }
  61
  62   // Returns whether the settings in |storage_| and |delegate_| are the same as
  63   // |settings|.
  64   bool SettingsEqual(const DictionaryValue& settings) {
  65     return settings.Equals(&storage_->Get()->settings()) &&
  66            settings.Equals(&delegate_->Get()->settings());
  67   }
  68
  69   // Values with different serialized sizes.
  70   scoped_ptr<Value> byte_value_1_;
  71   scoped_ptr<Value> byte_value_16_;
  72   scoped_ptr<ListValue> byte_value_256_;
  73
  74   // Quota enforcing storage area being tested.
  75   scoped_ptr<SettingsStorageQuotaEnforcer> storage_;
  76
  77   // In-memory storage area being delegated to.  Always owned by |storage_|.
  78   TestingValueStore* delegate_;
  79 };
  80
  81 TEST_F(ExtensionSettingsQuotaTest, ZeroQuotaBytes) {
  82   DictionaryValue empty;
  83   CreateStorage(0, UINT_MAX, UINT_MAX);
  84
  85   EXPECT_TRUE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
  86   EXPECT_FALSE(storage_->Remove("a")->HasError());
  87   EXPECT_FALSE(storage_->Remove("b")->HasError());
  88   EXPECT_TRUE(SettingsEqual(empty));
  89 }
  90
  91 TEST_F(ExtensionSettingsQuotaTest, KeySizeTakenIntoAccount) {
  92   DictionaryValue empty;
  93   CreateStorage(8u, UINT_MAX, UINT_MAX);
  94   EXPECT_TRUE(
  95       storage_->Set(DEFAULTS, "Really long key", *byte_value_1_)->HasError());
  96   EXPECT_TRUE(SettingsEqual(empty));
  97 }
  98
  99 TEST_F(ExtensionSettingsQuotaTest, SmallByteQuota) {
 100   DictionaryValue settings;
 101   CreateStorage(8u, UINT_MAX, UINT_MAX);
 102
 103   EXPECT_FALSE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
 104   settings.Set("a", byte_value_1_->DeepCopy());
 105   EXPECT_TRUE(SettingsEqual(settings));
 106
 107   EXPECT_TRUE(storage_->Set(DEFAULTS, "b", *byte_value_16_)->HasError());
 108   EXPECT_TRUE(storage_->Set(DEFAULTS, "c", *byte_value_256_)->HasError());
 109   EXPECT_TRUE(SettingsEqual(settings));
 110 }
 111
 112 TEST_F(ExtensionSettingsQuotaTest, MediumByteQuota) {
 113   DictionaryValue settings;
 114   CreateStorage(40, UINT_MAX, UINT_MAX);
 115
 116   DictionaryValue to_set;
 117   to_set.Set("a", byte_value_1_->DeepCopy());
 118   to_set.Set("b", byte_value_16_->DeepCopy());
 119   EXPECT_FALSE(storage_->Set(DEFAULTS, to_set)->HasError());
 120   settings.Set("a", byte_value_1_->DeepCopy());
 121   settings.Set("b", byte_value_16_->DeepCopy());
 122   EXPECT_TRUE(SettingsEqual(settings));
 123
 124   // Should be able to set value to other under-quota value.
 125   to_set.Set("a", byte_value_16_->DeepCopy());
 126   EXPECT_FALSE(storage_->Set(DEFAULTS, to_set)->HasError());
 127   settings.Set("a", byte_value_16_->DeepCopy());
 128   EXPECT_TRUE(SettingsEqual(settings));
 129
 130   EXPECT_TRUE(storage_->Set(DEFAULTS, "c", *byte_value_256_)->HasError());
 131   EXPECT_TRUE(SettingsEqual(settings));
 132 }
 133
 134 TEST_F(ExtensionSettingsQuotaTest, ZeroMaxKeys) {
 135   DictionaryValue empty;
 136   CreateStorage(UINT_MAX, UINT_MAX, 0);
 137
 138   EXPECT_TRUE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
 139   EXPECT_FALSE(storage_->Remove("a")->HasError());
 140   EXPECT_FALSE(storage_->Remove("b")->HasError());
 141   EXPECT_TRUE(SettingsEqual(empty));
 142 }
 143
 144 TEST_F(ExtensionSettingsQuotaTest, SmallMaxKeys) {
 145   DictionaryValue settings;
 146   CreateStorage(UINT_MAX, UINT_MAX, 1);
 147
 148   EXPECT_FALSE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
 149   settings.Set("a", byte_value_1_->DeepCopy());
 150   EXPECT_TRUE(SettingsEqual(settings));
 151
 152   // Should be able to set existing key to other value without going over quota.
 153   EXPECT_FALSE(storage_->Set(DEFAULTS, "a", *byte_value_16_)->HasError());
 154   settings.Set("a", byte_value_16_->DeepCopy());
 155   EXPECT_TRUE(SettingsEqual(settings));
 156
 157   EXPECT_TRUE(storage_->Set(DEFAULTS, "b", *byte_value_16_)->HasError());
 158   EXPECT_TRUE(storage_->Set(DEFAULTS, "c", *byte_value_256_)->HasError());
 159   EXPECT_TRUE(SettingsEqual(settings));
 160 }
 161
 162 TEST_F(ExtensionSettingsQuotaTest, MediumMaxKeys) {
 163   DictionaryValue settings;
 164   CreateStorage(UINT_MAX, UINT_MAX, 2);
 165
 166   DictionaryValue to_set;
 167   to_set.Set("a", byte_value_1_->DeepCopy());
 168   to_set.Set("b", byte_value_16_->DeepCopy());
 169   EXPECT_FALSE(storage_->Set(DEFAULTS, to_set)->HasError());
 170   settings.Set("a", byte_value_1_->DeepCopy());
 171   settings.Set("b", byte_value_16_->DeepCopy());
 172   EXPECT_TRUE(SettingsEqual(settings));
 173
 174   // Should be able to set existing keys to other values without going over
 175   // quota.
 176   to_set.Set("a", byte_value_16_->DeepCopy());
 177   EXPECT_FALSE(storage_->Set(DEFAULTS, to_set)->HasError());
 178   settings.Set("a", byte_value_16_->DeepCopy());
 179   EXPECT_TRUE(SettingsEqual(settings));
 180
 181   EXPECT_TRUE(storage_->Set(DEFAULTS, "c", *byte_value_256_)->HasError());
 182   EXPECT_TRUE(SettingsEqual(settings));
 183 }
 184
 185 TEST_F(ExtensionSettingsQuotaTest, RemovingExistingSettings) {
 186   DictionaryValue settings;
 187   CreateStorage(266, UINT_MAX, 2);
 188
 189   storage_->Set(DEFAULTS, "b", *byte_value_16_);
 190   settings.Set("b", byte_value_16_->DeepCopy());
 191   // Not enough quota.
 192   storage_->Set(DEFAULTS, "c", *byte_value_256_);
 193   EXPECT_TRUE(SettingsEqual(settings));
 194
 195   // Try again with "b" removed, enough quota.
 196   EXPECT_FALSE(storage_->Remove("b")->HasError());
 197   settings.Remove("b", NULL);
 198   EXPECT_FALSE(storage_->Set(DEFAULTS, "c", *byte_value_256_)->HasError());
 199   settings.Set("c", byte_value_256_->DeepCopy());
 200   EXPECT_TRUE(SettingsEqual(settings));
 201
 202   // Enough byte quota but max keys not high enough.
 203   EXPECT_FALSE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
 204   settings.Set("a", byte_value_1_->DeepCopy());
 205   EXPECT_TRUE(SettingsEqual(settings));
 206
 207   EXPECT_TRUE(storage_->Set(DEFAULTS, "b", *byte_value_1_)->HasError());
 208   EXPECT_TRUE(SettingsEqual(settings));
 209
 210   // Back under max keys.
 211   EXPECT_FALSE(storage_->Remove("a")->HasError());
 212   settings.Remove("a", NULL);
 213   EXPECT_FALSE(storage_->Set(DEFAULTS, "b", *byte_value_1_)->HasError());
 214   settings.Set("b", byte_value_1_->DeepCopy());
 215   EXPECT_TRUE(SettingsEqual(settings));
 216 }
 217
 218 TEST_F(ExtensionSettingsQuotaTest, RemovingNonexistentSettings) {
 219   DictionaryValue settings;
 220   CreateStorage(36, UINT_MAX, 3);
 221
 222   // Max out bytes.
 223   DictionaryValue to_set;
 224   to_set.Set("b1", byte_value_16_->DeepCopy());
 225   to_set.Set("b2", byte_value_16_->DeepCopy());
 226   storage_->Set(DEFAULTS, to_set);
 227   settings.Set("b1", byte_value_16_->DeepCopy());
 228   settings.Set("b2", byte_value_16_->DeepCopy());
 229   EXPECT_TRUE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
 230   EXPECT_TRUE(SettingsEqual(settings));
 231
 232   // Remove some settings that don't exist.
 233   std::vector<std::string> to_remove;
 234   to_remove.push_back("a1");
 235   to_remove.push_back("a2");
 236   EXPECT_FALSE(storage_->Remove(to_remove)->HasError());
 237   EXPECT_FALSE(storage_->Remove("b")->HasError());
 238   EXPECT_TRUE(SettingsEqual(settings));
 239
 240   // Still no quota.
 241   EXPECT_TRUE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
 242   EXPECT_TRUE(SettingsEqual(settings));
 243
 244   // Max out key count.
 245   to_set.Clear();
 246   to_set.Set("b1", byte_value_1_->DeepCopy());
 247   to_set.Set("b2", byte_value_1_->DeepCopy());
 248   storage_->Set(DEFAULTS, to_set);
 249   settings.Set("b1", byte_value_1_->DeepCopy());
 250   settings.Set("b2", byte_value_1_->DeepCopy());
 251   storage_->Set(DEFAULTS, "b3", *byte_value_1_);
 252   settings.Set("b3", byte_value_1_->DeepCopy());
 253   EXPECT_TRUE(SettingsEqual(settings));
 254
 255   // Remove some settings that don't exist.
 256   to_remove.clear();
 257   to_remove.push_back("a1");
 258   to_remove.push_back("a2");
 259   EXPECT_FALSE(storage_->Remove(to_remove)->HasError());
 260   EXPECT_FALSE(storage_->Remove("b")->HasError());
 261   EXPECT_TRUE(SettingsEqual(settings));
 262
 263   // Still no quota.
 264   EXPECT_TRUE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
 265   EXPECT_TRUE(SettingsEqual(settings));
 266 }
 267
 268 TEST_F(ExtensionSettingsQuotaTest, Clear) {
 269   DictionaryValue settings;
 270   CreateStorage(40, UINT_MAX, 5);
 271
 272   // Test running out of byte quota.
 273   {
 274     DictionaryValue to_set;
 275     to_set.Set("a", byte_value_16_->DeepCopy());
 276     to_set.Set("b", byte_value_16_->DeepCopy());
 277     EXPECT_FALSE(storage_->Set(DEFAULTS, to_set)->HasError());
 278     EXPECT_TRUE(storage_->Set(DEFAULTS, "c", *byte_value_16_)->HasError());
 279
 280     EXPECT_FALSE(storage_->Clear()->HasError());
 281
 282     // (repeat)
 283     EXPECT_FALSE(storage_->Set(DEFAULTS, to_set)->HasError());
 284     EXPECT_TRUE(storage_->Set(DEFAULTS, "c", *byte_value_16_)->HasError());
 285   }
 286
 287   // Test reaching max keys.
 288   storage_->Clear();
 289   {
 290     DictionaryValue to_set;
 291     to_set.Set("a", byte_value_1_->DeepCopy());
 292     to_set.Set("b", byte_value_1_->DeepCopy());
 293     to_set.Set("c", byte_value_1_->DeepCopy());
 294     to_set.Set("d", byte_value_1_->DeepCopy());
 295     to_set.Set("e", byte_value_1_->DeepCopy());
 296     EXPECT_FALSE(storage_->Set(DEFAULTS, to_set)->HasError());
 297     EXPECT_TRUE(storage_->Set(DEFAULTS, "f", *byte_value_1_)->HasError());
 298
 299     storage_->Clear();
 300
 301     // (repeat)
 302     EXPECT_FALSE(storage_->Set(DEFAULTS, to_set)->HasError());
 303     EXPECT_TRUE(storage_->Set(DEFAULTS, "f", *byte_value_1_)->HasError());
 304   }
 305 }
 306
 307 TEST_F(ExtensionSettingsQuotaTest, ChangingUsedBytesWithSet) {
 308   DictionaryValue settings;
 309   CreateStorage(20, UINT_MAX, UINT_MAX);
 310
 311   // Change a setting to make it go over quota.
 312   storage_->Set(DEFAULTS, "a", *byte_value_16_);
 313   settings.Set("a", byte_value_16_->DeepCopy());
 314   EXPECT_TRUE(SettingsEqual(settings));
 315
 316   EXPECT_TRUE(storage_->Set(DEFAULTS, "a", *byte_value_256_)->HasError());
 317   EXPECT_TRUE(SettingsEqual(settings));
 318
 319   // Change a setting to reduce usage and room for another setting.
 320   EXPECT_TRUE(storage_->Set(DEFAULTS, "foobar", *byte_value_1_)->HasError());
 321   storage_->Set(DEFAULTS, "a", *byte_value_1_);
 322   settings.Set("a", byte_value_1_->DeepCopy());
 323
 324   EXPECT_FALSE(storage_->Set(DEFAULTS, "foobar", *byte_value_1_)->HasError());
 325   settings.Set("foobar", byte_value_1_->DeepCopy());
 326   EXPECT_TRUE(SettingsEqual(settings));
 327 }
 328
 329 TEST_F(ExtensionSettingsQuotaTest, SetsOnlyEntirelyCompletedWithByteQuota) {
 330   DictionaryValue settings;
 331   CreateStorage(40, UINT_MAX, UINT_MAX);
 332
 333   storage_->Set(DEFAULTS, "a", *byte_value_16_);
 334   settings.Set("a", byte_value_16_->DeepCopy());
 335
 336   // The entire change is over quota.
 337   DictionaryValue to_set;
 338   to_set.Set("b", byte_value_16_->DeepCopy());
 339   to_set.Set("c", byte_value_16_->DeepCopy());
 340   EXPECT_TRUE(storage_->Set(DEFAULTS, to_set)->HasError());
 341   EXPECT_TRUE(SettingsEqual(settings));
 342
 343   // The entire change is over quota, but quota reduced in existing key.
 344   to_set.Set("a", byte_value_1_->DeepCopy());
 345   EXPECT_FALSE(storage_->Set(DEFAULTS, to_set)->HasError());
 346   settings.Set("a", byte_value_1_->DeepCopy());
 347   settings.Set("b", byte_value_16_->DeepCopy());
 348   settings.Set("c", byte_value_16_->DeepCopy());
 349   EXPECT_TRUE(SettingsEqual(settings));
 350 }
 351
 352 TEST_F(ExtensionSettingsQuotaTest, SetsOnlyEntireCompletedWithMaxKeys) {
 353   DictionaryValue settings;
 354   CreateStorage(UINT_MAX, UINT_MAX, 2);
 355
 356   storage_->Set(DEFAULTS, "a", *byte_value_1_);
 357   settings.Set("a", byte_value_1_->DeepCopy());
 358
 359   DictionaryValue to_set;
 360   to_set.Set("b", byte_value_16_->DeepCopy());
 361   to_set.Set("c", byte_value_16_->DeepCopy());
 362   EXPECT_TRUE(storage_->Set(DEFAULTS, to_set)->HasError());
 363   EXPECT_TRUE(SettingsEqual(settings));
 364 }
 365
 366 TEST_F(ExtensionSettingsQuotaTest, WithInitialDataAndByteQuota) {
 367   DictionaryValue settings;
 368   delegate_->Set(DEFAULTS, "a", *byte_value_256_);
 369   settings.Set("a", byte_value_256_->DeepCopy());
 370
 371   CreateStorage(280, UINT_MAX, UINT_MAX);
 372   EXPECT_TRUE(SettingsEqual(settings));
 373
 374   // Add some data.
 375   EXPECT_FALSE(storage_->Set(DEFAULTS, "b", *byte_value_16_)->HasError());
 376   settings.Set("b", byte_value_16_->DeepCopy());
 377   EXPECT_TRUE(SettingsEqual(settings));
 378
 379   // Not enough quota.
 380   EXPECT_TRUE(storage_->Set(DEFAULTS, "c", *byte_value_16_)->HasError());
 381   EXPECT_TRUE(SettingsEqual(settings));
 382
 383   // Reduce usage of original setting so that "c" can fit.
 384   EXPECT_FALSE(storage_->Set(DEFAULTS, "a", *byte_value_16_)->HasError());
 385   settings.Set("a", byte_value_16_->DeepCopy());
 386   EXPECT_TRUE(SettingsEqual(settings));
 387
 388   EXPECT_FALSE(storage_->Set(DEFAULTS, "c", *byte_value_16_)->HasError());
 389   settings.Set("c", byte_value_16_->DeepCopy());
 390   EXPECT_TRUE(SettingsEqual(settings));
 391
 392   // Remove to free up some more data.
 393   EXPECT_TRUE(storage_->Set(DEFAULTS, "d", *byte_value_256_)->HasError());
 394
 395   std::vector<std::string> to_remove;
 396   to_remove.push_back("a");
 397   to_remove.push_back("b");
 398   storage_->Remove(to_remove);
 399   settings.Remove("a", NULL);
 400   settings.Remove("b", NULL);
 401   EXPECT_TRUE(SettingsEqual(settings));
 402
 403   EXPECT_FALSE(storage_->Set(DEFAULTS, "d", *byte_value_256_)->HasError());
 404   settings.Set("d", byte_value_256_->DeepCopy());
 405   EXPECT_TRUE(SettingsEqual(settings));
 406 }
 407
 408 TEST_F(ExtensionSettingsQuotaTest, WithInitialDataAndMaxKeys) {
 409   DictionaryValue settings;
 410   delegate_->Set(DEFAULTS, "a", *byte_value_1_);
 411   settings.Set("a", byte_value_1_->DeepCopy());
 412   CreateStorage(UINT_MAX, UINT_MAX, 2);
 413
 414   EXPECT_FALSE(storage_->Set(DEFAULTS, "b", *byte_value_1_)->HasError());
 415   settings.Set("b", byte_value_1_->DeepCopy());
 416
 417   EXPECT_TRUE(storage_->Set(DEFAULTS, "c", *byte_value_1_)->HasError());
 418
 419   EXPECT_TRUE(SettingsEqual(settings));
 420 }
 421
 422 TEST_F(ExtensionSettingsQuotaTest, InitiallyOverByteQuota) {
 423   DictionaryValue settings;
 424   settings.Set("a", byte_value_16_->DeepCopy());
 425   settings.Set("b", byte_value_16_->DeepCopy());
 426   settings.Set("c", byte_value_16_->DeepCopy());
 427   delegate_->Set(DEFAULTS, settings);
 428
 429   CreateStorage(40, UINT_MAX, UINT_MAX);
 430   EXPECT_TRUE(SettingsEqual(settings));
 431
 432   EXPECT_TRUE(storage_->Set(DEFAULTS, "d", *byte_value_16_)->HasError());
 433
 434   // Take under quota by reducing size of an existing setting
 435   EXPECT_FALSE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
 436   settings.Set("a", byte_value_1_->DeepCopy());
 437   EXPECT_TRUE(SettingsEqual(settings));
 438
 439   // Should be able set another small setting.
 440   EXPECT_FALSE(storage_->Set(DEFAULTS, "d", *byte_value_1_)->HasError());
 441   settings.Set("d", byte_value_1_->DeepCopy());
 442   EXPECT_TRUE(SettingsEqual(settings));
 443 }
 444
 445 TEST_F(ExtensionSettingsQuotaTest, InitiallyOverMaxKeys) {
 446   DictionaryValue settings;
 447   settings.Set("a", byte_value_16_->DeepCopy());
 448   settings.Set("b", byte_value_16_->DeepCopy());
 449   settings.Set("c", byte_value_16_->DeepCopy());
 450   delegate_->Set(DEFAULTS, settings);
 451
 452   CreateStorage(UINT_MAX, UINT_MAX, 2);
 453   EXPECT_TRUE(SettingsEqual(settings));
 454
 455   // Can't set either an existing or new setting.
 456   EXPECT_TRUE(storage_->Set(DEFAULTS, "d", *byte_value_16_)->HasError());
 457   EXPECT_TRUE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
 458   EXPECT_TRUE(SettingsEqual(settings));
 459
 460   // Should be able after removing 2.
 461   storage_->Remove("a");
 462   settings.Remove("a", NULL);
 463   storage_->Remove("b");
 464   settings.Remove("b", NULL);
 465   EXPECT_TRUE(SettingsEqual(settings));
 466
 467   EXPECT_FALSE(storage_->Set(DEFAULTS, "e", *byte_value_1_)->HasError());
 468   settings.Set("e", byte_value_1_->DeepCopy());
 469   EXPECT_TRUE(SettingsEqual(settings));
 470
 471   // Still can't set any.
 472   EXPECT_TRUE(storage_->Set(DEFAULTS, "d", *byte_value_16_)->HasError());
 473   EXPECT_TRUE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
 474   EXPECT_TRUE(SettingsEqual(settings));
 475 }
 476
 477 TEST_F(ExtensionSettingsQuotaTest, ZeroQuotaBytesPerSetting) {
 478   DictionaryValue empty;
 479   CreateStorage(UINT_MAX, 0, UINT_MAX);
 480
 481   EXPECT_TRUE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
 482   EXPECT_FALSE(storage_->Remove("a")->HasError());
 483   EXPECT_FALSE(storage_->Remove("b")->HasError());
 484   EXPECT_TRUE(SettingsEqual(empty));
 485 }
 486
 487 TEST_F(ExtensionSettingsQuotaTest, QuotaBytesPerSetting) {
 488   DictionaryValue settings;
 489
 490   CreateStorage(UINT_MAX, 20, UINT_MAX);
 491
 492   EXPECT_FALSE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
 493   EXPECT_FALSE(storage_->Set(DEFAULTS, "a", *byte_value_16_)->HasError());
 494   settings.Set("a", byte_value_16_->DeepCopy());
 495   EXPECT_TRUE(storage_->Set(DEFAULTS, "a", *byte_value_256_)->HasError());
 496
 497   EXPECT_FALSE(storage_->Set(DEFAULTS, "b", *byte_value_1_)->HasError());
 498   EXPECT_FALSE(storage_->Set(DEFAULTS, "b", *byte_value_16_)->HasError());
 499   settings.Set("b", byte_value_16_->DeepCopy());
 500   EXPECT_TRUE(storage_->Set(DEFAULTS, "b", *byte_value_256_)->HasError());
 501
 502   EXPECT_TRUE(SettingsEqual(settings));
 503 }
 504
 505 TEST_F(ExtensionSettingsQuotaTest, QuotaBytesPerSettingWithInitialSettings) {
 506   DictionaryValue settings;
 507
 508   delegate_->Set(DEFAULTS, "a", *byte_value_1_);
 509   delegate_->Set(DEFAULTS, "b", *byte_value_16_);
 510   delegate_->Set(DEFAULTS, "c", *byte_value_256_);
 511   CreateStorage(UINT_MAX, 20, UINT_MAX);
 512
 513   EXPECT_FALSE(storage_->Set(DEFAULTS, "a", *byte_value_1_)->HasError());
 514   EXPECT_FALSE(storage_->Set(DEFAULTS, "a", *byte_value_16_)->HasError());
 515   settings.Set("a", byte_value_16_->DeepCopy());
 516   EXPECT_TRUE(storage_->Set(DEFAULTS, "a", *byte_value_256_)->HasError());
 517
 518   EXPECT_FALSE(storage_->Set(DEFAULTS, "b", *byte_value_1_)->HasError());
 519   EXPECT_FALSE(storage_->Set(DEFAULTS, "b", *byte_value_16_)->HasError());
 520   settings.Set("b", byte_value_16_->DeepCopy());
 521   EXPECT_TRUE(storage_->Set(DEFAULTS, "b", *byte_value_256_)->HasError());
 522
 523   EXPECT_FALSE(storage_->Set(DEFAULTS, "c", *byte_value_1_)->HasError());
 524   EXPECT_FALSE(storage_->Set(DEFAULTS, "c", *byte_value_16_)->HasError());
 525   settings.Set("c", byte_value_16_->DeepCopy());
 526   EXPECT_TRUE(storage_->Set(DEFAULTS, "c", *byte_value_256_)->HasError());
 527
 528   EXPECT_TRUE(SettingsEqual(settings));
 529 }
 530
 531 TEST_F(ExtensionSettingsQuotaTest,
 532     QuotaBytesPerSettingWithInitialSettingsForced) {
 533   // This is a lazy test to make sure IGNORE_QUOTA lets through changes: the
 534   // test above copied, but using IGNORE_QUOTA and asserting nothing is ever
 535   // rejected...
 536   DictionaryValue settings;
 537
 538   delegate_->Set(DEFAULTS, "a", *byte_value_1_);
 539   delegate_->Set(DEFAULTS, "b", *byte_value_16_);
 540   delegate_->Set(DEFAULTS, "c", *byte_value_256_);
 541   CreateStorage(UINT_MAX, 20, UINT_MAX);
 542
 543   EXPECT_FALSE(storage_->Set(IGNORE_QUOTA, "a", *byte_value_1_)->HasError());
 544   EXPECT_FALSE(storage_->Set(IGNORE_QUOTA, "a", *byte_value_16_)->HasError());
 545   EXPECT_FALSE(storage_->Set(IGNORE_QUOTA, "a", *byte_value_256_)->HasError());
 546   settings.Set("a", byte_value_256_->DeepCopy());
 547
 548   EXPECT_FALSE(storage_->Set(IGNORE_QUOTA, "b", *byte_value_1_)->HasError());
 549   EXPECT_FALSE(storage_->Set(IGNORE_QUOTA, "b", *byte_value_16_)->HasError());
 550   EXPECT_FALSE(storage_->Set(IGNORE_QUOTA, "b", *byte_value_256_)->HasError());
 551   settings.Set("b", byte_value_256_->DeepCopy());
 552
 553   EXPECT_FALSE(storage_->Set(IGNORE_QUOTA, "c", *byte_value_1_)->HasError());
 554   EXPECT_FALSE(storage_->Set(IGNORE_QUOTA, "c", *byte_value_16_)->HasError());
 555   settings.Set("c", byte_value_16_->DeepCopy());
 556
 557   // ... except the last.  Make sure it can still fail.
 558   EXPECT_TRUE(storage_->Set(DEFAULTS, "c", *byte_value_256_)->HasError());
 559
 560   EXPECT_TRUE(SettingsEqual(settings));
 561 }
 562
 563 TEST_F(ExtensionSettingsQuotaTest, GetBytesInUse) {
 564   // Just testing GetBytesInUse, no need for a quota.
 565   CreateStorage(UINT_MAX, UINT_MAX, UINT_MAX);
 566
 567   std::vector<std::string> ab;
 568   ab.push_back("a");
 569   ab.push_back("b");
 570
 571   EXPECT_EQ(0u, storage_->GetBytesInUse());
 572   EXPECT_EQ(0u, storage_->GetBytesInUse("a"));
 573   EXPECT_EQ(0u, storage_->GetBytesInUse("b"));
 574   EXPECT_EQ(0u, storage_->GetBytesInUse(ab));
 575
 576   storage_->Set(DEFAULTS, "a", *byte_value_1_);
 577
 578   EXPECT_EQ(2u, storage_->GetBytesInUse());
 579   EXPECT_EQ(2u, storage_->GetBytesInUse("a"));
 580   EXPECT_EQ(0u, storage_->GetBytesInUse("b"));
 581   EXPECT_EQ(2u, storage_->GetBytesInUse(ab));
 582
 583   storage_->Set(DEFAULTS, "b", *byte_value_1_);
 584
 585   EXPECT_EQ(4u, storage_->GetBytesInUse());
 586   EXPECT_EQ(2u, storage_->GetBytesInUse("a"));
 587   EXPECT_EQ(2u, storage_->GetBytesInUse("b"));
 588   EXPECT_EQ(4u, storage_->GetBytesInUse(ab));
 589
 590   storage_->Set(DEFAULTS, "c", *byte_value_1_);
 591
 592   EXPECT_EQ(6u, storage_->GetBytesInUse());
 593   EXPECT_EQ(2u, storage_->GetBytesInUse("a"));
 594   EXPECT_EQ(2u, storage_->GetBytesInUse("b"));
 595   EXPECT_EQ(4u, storage_->GetBytesInUse(ab));
 596 }
 597
 598 }  // namespace extensions