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_(Value::CreateIntegerValue(1)), 29 byte_value_16_(Value::CreateStringValue("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(Value::CreateIntegerValue(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().get()) && 66 settings.Equals(delegate_->Get()->settings().get()); 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 599
