| 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/strings/utf_string_conversions.h" | |
| 6 #include "testing/gtest/include/gtest/gtest.h" | |
| 7 #include "webkit/common/dom_storage/dom_storage_map.h" | |
| 8 | |
| 9 namespace dom_storage { | |
| 10 | |
| 11 TEST(DomStorageMapTest, DomStorageMapBasics) { | |
| 12 const base::string16 kKey(ASCIIToUTF16("key")); | |
| 13 const base::string16 kValue(ASCIIToUTF16("value")); | |
| 14 const size_t kValueBytes = kValue.size() * sizeof(char16); | |
| 15 const size_t kItemBytes = | |
| 16 (kKey.size() + kValue.size()) * sizeof(char16); | |
| 17 const base::string16 kKey2(ASCIIToUTF16("key2")); | |
| 18 const size_t kKey2Bytes = kKey2.size() * sizeof(char16); | |
| 19 const base::string16 kValue2(ASCIIToUTF16("value2")); | |
| 20 const size_t kItem2Bytes = | |
| 21 (kKey2.size() + kValue2.size()) * sizeof(char16); | |
| 22 const size_t kQuota = 1024; // 1K quota for this test. | |
| 23 | |
| 24 scoped_refptr<DomStorageMap> map(new DomStorageMap(kQuota)); | |
| 25 base::string16 old_value; | |
| 26 base::NullableString16 old_nullable_value; | |
| 27 ValuesMap swap; | |
| 28 scoped_refptr<DomStorageMap> copy; | |
| 29 | |
| 30 // Check the behavior of an empty map. | |
| 31 EXPECT_EQ(0u, map->Length()); | |
| 32 EXPECT_TRUE(map->Key(0).is_null()); | |
| 33 EXPECT_TRUE(map->Key(100).is_null()); | |
| 34 EXPECT_TRUE(map->GetItem(kKey).is_null()); | |
| 35 EXPECT_FALSE(map->RemoveItem(kKey, &old_value)); | |
| 36 EXPECT_EQ(0u, map->bytes_used()); | |
| 37 copy = map->DeepCopy(); | |
| 38 EXPECT_EQ(0u, copy->Length()); | |
| 39 EXPECT_EQ(0u, copy->bytes_used()); | |
| 40 map->SwapValues(&swap); | |
| 41 EXPECT_TRUE(swap.empty()); | |
| 42 | |
| 43 // Check the behavior of a map containing some values. | |
| 44 EXPECT_TRUE(map->SetItem(kKey, kValue, &old_nullable_value)); | |
| 45 EXPECT_TRUE(old_nullable_value.is_null()); | |
| 46 EXPECT_EQ(1u, map->Length()); | |
| 47 EXPECT_EQ(kKey, map->Key(0).string()); | |
| 48 EXPECT_TRUE(map->Key(1).is_null()); | |
| 49 EXPECT_EQ(kValue, map->GetItem(kKey).string()); | |
| 50 EXPECT_TRUE(map->GetItem(kKey2).is_null()); | |
| 51 EXPECT_EQ(kItemBytes, map->bytes_used()); | |
| 52 EXPECT_TRUE(map->RemoveItem(kKey, &old_value)); | |
| 53 EXPECT_EQ(0u, map->bytes_used()); | |
| 54 EXPECT_EQ(kValue, old_value); | |
| 55 old_value.clear(); | |
| 56 | |
| 57 EXPECT_TRUE(map->SetItem(kKey, kValue, &old_nullable_value)); | |
| 58 EXPECT_TRUE(map->SetItem(kKey2, kValue, &old_nullable_value)); | |
| 59 EXPECT_TRUE(old_nullable_value.is_null()); | |
| 60 EXPECT_EQ(kItemBytes + kKey2Bytes + kValueBytes, map->bytes_used()); | |
| 61 EXPECT_TRUE(map->SetItem(kKey2, kValue2, &old_nullable_value)); | |
| 62 EXPECT_EQ(kItemBytes + kItem2Bytes, map->bytes_used()); | |
| 63 EXPECT_EQ(kValue, old_nullable_value.string()); | |
| 64 EXPECT_EQ(2u, map->Length()); | |
| 65 EXPECT_EQ(kKey, map->Key(0).string()); | |
| 66 EXPECT_EQ(kKey2, map->Key(1).string()); | |
| 67 EXPECT_EQ(kKey, map->Key(0).string()); | |
| 68 EXPECT_EQ(kItemBytes + kItem2Bytes, map->bytes_used()); | |
| 69 | |
| 70 copy = map->DeepCopy(); | |
| 71 EXPECT_EQ(2u, copy->Length()); | |
| 72 EXPECT_EQ(kValue, copy->GetItem(kKey).string()); | |
| 73 EXPECT_EQ(kValue2, copy->GetItem(kKey2).string()); | |
| 74 EXPECT_EQ(kKey, copy->Key(0).string()); | |
| 75 EXPECT_EQ(kKey2, copy->Key(1).string()); | |
| 76 EXPECT_TRUE(copy->Key(2).is_null()); | |
| 77 EXPECT_EQ(kItemBytes + kItem2Bytes, copy->bytes_used()); | |
| 78 | |
| 79 map->SwapValues(&swap); | |
| 80 EXPECT_EQ(2ul, swap.size()); | |
| 81 EXPECT_EQ(0u, map->Length()); | |
| 82 EXPECT_EQ(0u, map->bytes_used()); | |
| 83 } | |
| 84 | |
| 85 TEST(DomStorageMapTest, EnforcesQuota) { | |
| 86 const base::string16 kKey = ASCIIToUTF16("test_key"); | |
| 87 const base::string16 kValue = ASCIIToUTF16("test_value"); | |
| 88 const base::string16 kKey2 = ASCIIToUTF16("test_key_2"); | |
| 89 | |
| 90 // A 50 byte quota is too small to hold both keys, so we | |
| 91 // should see the DomStorageMap enforcing it. | |
| 92 const size_t kQuota = 50; | |
| 93 | |
| 94 base::string16 old_value; | |
| 95 base::NullableString16 old_nullable_value; | |
| 96 | |
| 97 scoped_refptr<DomStorageMap> map(new DomStorageMap(kQuota)); | |
| 98 EXPECT_TRUE(map->SetItem(kKey, kValue, &old_nullable_value)); | |
| 99 EXPECT_FALSE(map->SetItem(kKey2, kValue, &old_nullable_value)); | |
| 100 EXPECT_EQ(1u, map->Length()); | |
| 101 | |
| 102 EXPECT_TRUE(map->RemoveItem(kKey, &old_value)); | |
| 103 EXPECT_EQ(kValue, old_value); | |
| 104 EXPECT_EQ(0u, map->Length()); | |
| 105 EXPECT_TRUE(map->SetItem(kKey2, kValue, &old_nullable_value)); | |
| 106 EXPECT_EQ(1u, map->Length()); | |
| 107 | |
| 108 // Verify that the SwapValues method does not do quota checking. | |
| 109 ValuesMap swap; | |
| 110 swap[kKey] = base::NullableString16(kValue, false); | |
| 111 swap[kKey2] = base::NullableString16(kValue, false); | |
| 112 map->SwapValues(&swap); | |
| 113 EXPECT_GT(map->bytes_used(), kQuota); | |
| 114 | |
| 115 // When overbudget, a new value of greater size than the existing value can | |
| 116 // not be set, but a new value of lesser or equal size can be set. | |
| 117 EXPECT_TRUE(map->SetItem(kKey, kValue, &old_nullable_value)); | |
| 118 EXPECT_FALSE(map->SetItem(kKey, base::string16(kValue + kValue), | |
| 119 &old_nullable_value)); | |
| 120 EXPECT_TRUE(map->SetItem(kKey, base::string16(), &old_nullable_value)); | |
| 121 EXPECT_EQ(kValue, old_nullable_value.string()); | |
| 122 } | |
| 123 | |
| 124 } // namespace dom_storage | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 22297005:
Move webkit/{browser,common}/dom_storage into content/ (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src