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