1 // Copyright 2013 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 6 #include "content/browser/dom_storage/session_storage_database.h" 7 8 #include <algorithm> 9 #include <map> 10 #include <string> 11 12 #include "base/file_util.h" 13 #include "base/files/scoped_temp_dir.h" 14 #include "base/logging.h" 15 #include "base/strings/string_number_conversions.h" 16 #include "base/strings/utf_string_conversions.h" 17 #include "content/common/dom_storage/dom_storage_types.h" 18 #include "testing/gtest/include/gtest/gtest.h" 19 #include "third_party/leveldatabase/src/include/leveldb/db.h" 20 #include "third_party/leveldatabase/src/include/leveldb/iterator.h" 21 #include "third_party/leveldatabase/src/include/leveldb/options.h" 22 #include "url/gurl.h" 23 24 namespace content { 25 26 class SessionStorageDatabaseTest : public testing::Test { 27 public: 28 SessionStorageDatabaseTest(); 29 virtual ~SessionStorageDatabaseTest(); 30 virtual void SetUp() OVERRIDE; 31 32 protected: 33 typedef std::map<std::string, std::string> DataMap; 34 35 // Helpers. 36 static bool IsNamespaceKey(const std::string& key, 37 std::string* namespace_id); 38 static bool IsNamespaceOriginKey(const std::string& key, 39 std::string* namespace_id); 40 static bool IsMapRefCountKey(const std::string& key, 41 int64* map_id); 42 static bool IsMapValueKey(const std::string& key, 43 int64* map_id); 44 void ResetDatabase(); 45 void ReadData(DataMap* data) const; 46 void CheckDatabaseConsistency() const; 47 void CheckEmptyDatabase() const; 48 void DumpData() const; 49 void CheckAreaData(const std::string& namespace_id, 50 const GURL& origin, 51 const DOMStorageValuesMap& reference) const; 52 void CompareValuesMaps(const DOMStorageValuesMap& map1, 53 const DOMStorageValuesMap& map2) const; 54 void CheckNamespaceIds( 55 const std::set<std::string>& expected_namespace_ids) const; 56 void CheckOrigins( 57 const std::string& namespace_id, 58 const std::set<GURL>& expected_origins) const; 59 std::string GetMapForArea(const std::string& namespace_id, 60 const GURL& origin) const; 61 int64 GetMapRefCount(const std::string& map_id) const; 62 63 base::ScopedTempDir temp_dir_; 64 scoped_refptr<SessionStorageDatabase> db_; 65 66 // Test data. 67 const GURL kOrigin1; 68 const GURL kOrigin2; 69 const std::string kNamespace1; 70 const std::string kNamespace2; 71 const std::string kNamespaceClone; 72 const base::string16 kKey1; 73 const base::string16 kKey2; 74 const base::string16 kKey3; 75 const base::NullableString16 kValue1; 76 const base::NullableString16 kValue2; 77 const base::NullableString16 kValue3; 78 const base::NullableString16 kValue4; 79 const base::NullableString16 kValueNull; 80 81 DISALLOW_COPY_AND_ASSIGN(SessionStorageDatabaseTest); 82 }; 83 84 SessionStorageDatabaseTest::SessionStorageDatabaseTest() 85 : kOrigin1("http://www.origin1.com"), 86 kOrigin2("http://www.origin2.com"), 87 kNamespace1("namespace1"), 88 kNamespace2("namespace2"), 89 kNamespaceClone("wascloned"), 90 kKey1(base::ASCIIToUTF16("key1")), 91 kKey2(base::ASCIIToUTF16("key2")), 92 kKey3(base::ASCIIToUTF16("key3")), 93 kValue1(base::ASCIIToUTF16("value1"), false), 94 kValue2(base::ASCIIToUTF16("value2"), false), 95 kValue3(base::ASCIIToUTF16("value3"), false), 96 kValue4(base::ASCIIToUTF16("value4"), false) { } 97 98 SessionStorageDatabaseTest::~SessionStorageDatabaseTest() { } 99 100 void SessionStorageDatabaseTest::SetUp() { 101 ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); 102 ResetDatabase(); 103 } 104 105 void SessionStorageDatabaseTest::ResetDatabase() { 106 db_ = new SessionStorageDatabase(temp_dir_.path()); 107 ASSERT_TRUE(db_->LazyOpen(true)); 108 } 109 110 // static 111 bool SessionStorageDatabaseTest::IsNamespaceKey(const std::string& key, 112 std::string* namespace_id) { 113 std::string namespace_prefix = SessionStorageDatabase::NamespacePrefix(); 114 if (key.find(namespace_prefix) != 0) 115 return false; 116 if (key == namespace_prefix) 117 return false; 118 119 size_t second_dash = key.find('-', namespace_prefix.length()); 120 if (second_dash != key.length() - 1) 121 return false; 122 123 // Key is of the form "namespace-<namespaceid>-". 124 *namespace_id = key.substr( 125 namespace_prefix.length(), 126 second_dash - namespace_prefix.length()); 127 return true; 128 } 129 130 // static 131 bool SessionStorageDatabaseTest::IsNamespaceOriginKey( 132 const std::string& key, 133 std::string* namespace_id) { 134 std::string namespace_prefix = SessionStorageDatabase::NamespacePrefix(); 135 if (key.find(namespace_prefix) != 0) 136 return false; 137 size_t second_dash = key.find('-', namespace_prefix.length()); 138 if (second_dash == std::string::npos || second_dash == key.length() - 1) 139 return false; 140 141 // Key is of the form "namespace-<namespaceid>-<origin>", and the value 142 // is the map id. 143 *namespace_id = key.substr( 144 namespace_prefix.length(), 145 second_dash - namespace_prefix.length()); 146 return true; 147 } 148 149 // static 150 bool SessionStorageDatabaseTest::IsMapRefCountKey(const std::string& key, 151 int64* map_id) { 152 std::string map_prefix = "map-"; 153 if (key.find(map_prefix) != 0) 154 return false; 155 size_t second_dash = key.find('-', map_prefix.length()); 156 if (second_dash != key.length() - 1) 157 return false; 158 // Key is of the form "map-<mapid>-" and the value is the ref count. 159 std::string map_id_str = key.substr(map_prefix.length(), 160 second_dash - map_prefix.length()); 161 bool conversion_ok = base::StringToInt64(map_id_str, map_id); 162 EXPECT_TRUE(conversion_ok); 163 return true; 164 } 165 166 // static 167 bool SessionStorageDatabaseTest::IsMapValueKey(const std::string& key, 168 int64* map_id) { 169 std::string map_prefix = "map-"; 170 if (key.find(map_prefix) != 0) 171 return false; 172 size_t second_dash = key.find('-', map_prefix.length()); 173 if (second_dash == std::string::npos || second_dash == key.length() - 1) 174 return false; 175 // Key is of the form "map-<mapid>-key". 176 std::string map_id_str = key.substr(map_prefix.length(), 177 second_dash - map_prefix.length()); 178 bool conversion_ok = base::StringToInt64(map_id_str, map_id); 179 EXPECT_TRUE(conversion_ok); 180 return true; 181 } 182 183 void SessionStorageDatabaseTest::ReadData(DataMap* data) const { 184 leveldb::DB* leveldb = db_->db_.get(); 185 scoped_ptr<leveldb::Iterator> it( 186 leveldb->NewIterator(leveldb::ReadOptions())); 187 for (it->SeekToFirst(); it->Valid(); it->Next()) { 188 (*data)[it->key().ToString()] = it->value().ToString(); 189 } 190 } 191 192 void SessionStorageDatabaseTest::CheckDatabaseConsistency() const { 193 DataMap data; 194 ReadData(&data); 195 // Empty db is ok. 196 if (data.empty()) 197 return; 198 199 // For detecting rubbish keys. 200 size_t valid_keys = 0; 201 202 std::string next_map_id_key = SessionStorageDatabase::NextMapIdKey(); 203 // Check the namespace start key. 204 if (data.find(SessionStorageDatabase::NamespacePrefix()) == data.end()) { 205 // If there is no namespace start key, the database may contain only counter 206 // keys. 207 for (DataMap::const_iterator it = data.begin(); it != data.end(); ++it) { 208 ASSERT_TRUE(it->first == next_map_id_key); 209 } 210 return; 211 } 212 ++valid_keys; 213 214 // Iterate the "namespace-" keys. 215 std::set<std::string> found_namespace_ids; 216 std::set<std::string> namespaces_with_areas; 217 std::map<int64, int64> expected_map_refcounts; 218 int64 max_map_id = -1; 219 220 for (DataMap::const_iterator it = data.begin(); it != data.end(); ++it) { 221 std::string namespace_id; 222 if (IsNamespaceKey(it->first, &namespace_id)) { 223 found_namespace_ids.insert(namespace_id); 224 ++valid_keys; 225 } else if (IsNamespaceOriginKey( 226 it->first, &namespace_id)) { 227 // Check that the corresponding "namespace-<namespaceid>-" key exists. It 228 // has been read by now, since the keys are stored in order. 229 ASSERT_TRUE(found_namespace_ids.find(namespace_id) != 230 found_namespace_ids.end()); 231 namespaces_with_areas.insert(namespace_id); 232 int64 map_id; 233 bool conversion_ok = base::StringToInt64(it->second, &map_id); 234 ASSERT_TRUE(conversion_ok); 235 ASSERT_GE(map_id, 0); 236 ++expected_map_refcounts[map_id]; 237 max_map_id = std::max(map_id, max_map_id); 238 ++valid_keys; 239 } 240 } 241 // Check that there are no leftover "namespace-namespaceid-" keys without 242 // associated areas. 243 ASSERT_EQ(found_namespace_ids.size(), namespaces_with_areas.size()); 244 245 if (max_map_id != -1) { 246 // The database contains maps. 247 ASSERT_TRUE(data.find(next_map_id_key) != data.end()); 248 int64 next_map_id; 249 bool conversion_ok = 250 base::StringToInt64(data[next_map_id_key], &next_map_id); 251 ASSERT_TRUE(conversion_ok); 252 ASSERT_GT(next_map_id, max_map_id); 253 } 254 255 // Iterate the "map-" keys. 256 std::set<int64> found_map_ids; 257 for (DataMap::const_iterator it = data.begin(); it != data.end(); ++it) { 258 int64 map_id; 259 if (IsMapRefCountKey(it->first, &map_id)) { 260 int64 ref_count; 261 bool conversion_ok = base::StringToInt64(it->second, &ref_count); 262 ASSERT_TRUE(conversion_ok); 263 // Check that the map is not stale. 264 ASSERT_GT(ref_count, 0); 265 ASSERT_TRUE(expected_map_refcounts.find(map_id) != 266 expected_map_refcounts.end()); 267 ASSERT_EQ(expected_map_refcounts[map_id], ref_count); 268 // Mark the map as existing. 269 expected_map_refcounts.erase(map_id); 270 found_map_ids.insert(map_id); 271 ++valid_keys; 272 } else if (IsMapValueKey(it->first, &map_id)) { 273 ASSERT_TRUE(found_map_ids.find(map_id) != found_map_ids.end()); 274 ++valid_keys; 275 } 276 } 277 // Check that all maps referred to exist. 278 ASSERT_TRUE(expected_map_refcounts.empty()); 279 280 if (data.find(next_map_id_key) != data.end()) 281 ++valid_keys; 282 283 ASSERT_EQ(data.size(), valid_keys); 284 } 285 286 void SessionStorageDatabaseTest::CheckEmptyDatabase() const { 287 DataMap data; 288 ReadData(&data); 289 size_t valid_keys = 0; 290 if (data.find(SessionStorageDatabase::NamespacePrefix()) != data.end()) 291 ++valid_keys; 292 if (data.find(SessionStorageDatabase::NextMapIdKey()) != data.end()) 293 ++valid_keys; 294 EXPECT_EQ(valid_keys, data.size()); 295 } 296 297 void SessionStorageDatabaseTest::DumpData() const { 298 LOG(WARNING) << "---- Session storage contents"; 299 scoped_ptr<leveldb::Iterator> it( 300 db_->db_->NewIterator(leveldb::ReadOptions())); 301 for (it->SeekToFirst(); it->Valid(); it->Next()) { 302 int64 dummy_map_id; 303 if (IsMapValueKey(it->key().ToString(), &dummy_map_id)) { 304 // Convert the value back to base::string16. 305 base::string16 value; 306 size_t len = it->value().size() / sizeof(base::char16); 307 value.resize(len); 308 value.assign( 309 reinterpret_cast<const base::char16*>(it->value().data()), len); 310 LOG(WARNING) << it->key().ToString() << ": " << value; 311 } else { 312 LOG(WARNING) << it->key().ToString() << ": " << it->value().ToString(); 313 } 314 } 315 LOG(WARNING) << "----"; 316 } 317 318 void SessionStorageDatabaseTest::CheckAreaData( 319 const std::string& namespace_id, const GURL& origin, 320 const DOMStorageValuesMap& reference) const { 321 DOMStorageValuesMap values; 322 db_->ReadAreaValues(namespace_id, origin, &values); 323 CompareValuesMaps(values, reference); 324 } 325 326 void SessionStorageDatabaseTest::CompareValuesMaps( 327 const DOMStorageValuesMap& map1, 328 const DOMStorageValuesMap& map2) const { 329 ASSERT_EQ(map2.size(), map1.size()); 330 for (DOMStorageValuesMap::const_iterator it = map1.begin(); 331 it != map1.end(); ++it) { 332 base::string16 key = it->first; 333 ASSERT_TRUE(map2.find(key) != map2.end()); 334 base::NullableString16 val1 = it->second; 335 base::NullableString16 val2 = map2.find(key)->second; 336 EXPECT_EQ(val2.is_null(), val1.is_null()); 337 EXPECT_EQ(val2.string(), val1.string()); 338 } 339 } 340 341 void SessionStorageDatabaseTest::CheckNamespaceIds( 342 const std::set<std::string>& expected_namespace_ids) const { 343 std::map<std::string, std::vector<GURL> > namespaces_and_origins; 344 EXPECT_TRUE(db_->ReadNamespacesAndOrigins(&namespaces_and_origins)); 345 EXPECT_EQ(expected_namespace_ids.size(), namespaces_and_origins.size()); 346 for (std::map<std::string, std::vector<GURL> >::const_iterator it = 347 namespaces_and_origins.begin(); 348 it != namespaces_and_origins.end(); ++it) { 349 EXPECT_TRUE(expected_namespace_ids.find(it->first) != 350 expected_namespace_ids.end()); 351 } 352 } 353 354 void SessionStorageDatabaseTest::CheckOrigins( 355 const std::string& namespace_id, 356 const std::set<GURL>& expected_origins) const { 357 std::map<std::string, std::vector<GURL> > namespaces_and_origins; 358 EXPECT_TRUE(db_->ReadNamespacesAndOrigins(&namespaces_and_origins)); 359 const std::vector<GURL>& origins = namespaces_and_origins[namespace_id]; 360 EXPECT_EQ(expected_origins.size(), origins.size()); 361 for (std::vector<GURL>::const_iterator it = origins.begin(); 362 it != origins.end(); ++it) { 363 EXPECT_TRUE(expected_origins.find(*it) != expected_origins.end()); 364 } 365 } 366 367 std::string SessionStorageDatabaseTest::GetMapForArea( 368 const std::string& namespace_id, const GURL& origin) const { 369 bool exists; 370 std::string map_id; 371 EXPECT_TRUE(db_->GetMapForArea(namespace_id, origin.spec(), 372 leveldb::ReadOptions(), &exists, &map_id)); 373 EXPECT_TRUE(exists); 374 return map_id; 375 } 376 377 int64 SessionStorageDatabaseTest::GetMapRefCount( 378 const std::string& map_id) const { 379 int64 ref_count; 380 EXPECT_TRUE(db_->GetMapRefCount(map_id, &ref_count)); 381 return ref_count; 382 } 383 384 TEST_F(SessionStorageDatabaseTest, EmptyDatabaseSanityCheck) { 385 // An empty database should be valid. 386 CheckDatabaseConsistency(); 387 } 388 389 TEST_F(SessionStorageDatabaseTest, WriteDataForOneOrigin) { 390 // Keep track on what the values should look like. 391 DOMStorageValuesMap reference; 392 // Write data. 393 { 394 DOMStorageValuesMap changes; 395 changes[kKey1] = kValue1; 396 changes[kKey2] = kValue2; 397 changes[kKey3] = kValue3; 398 reference[kKey1] = kValue1; 399 reference[kKey2] = kValue2; 400 reference[kKey3] = kValue3; 401 EXPECT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin1, false, changes)); 402 } 403 CheckDatabaseConsistency(); 404 CheckAreaData(kNamespace1, kOrigin1, reference); 405 406 // Overwrite and delete values. 407 { 408 DOMStorageValuesMap changes; 409 changes[kKey1] = kValue4; 410 changes[kKey3] = kValueNull; 411 reference[kKey1] = kValue4; 412 reference.erase(kKey3); 413 EXPECT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin1, false, changes)); 414 } 415 CheckDatabaseConsistency(); 416 CheckAreaData(kNamespace1, kOrigin1, reference); 417 418 // Clear data before writing. 419 { 420 DOMStorageValuesMap changes; 421 changes[kKey2] = kValue2; 422 reference.erase(kKey1); 423 reference[kKey2] = kValue2; 424 EXPECT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin1, true, changes)); 425 } 426 CheckDatabaseConsistency(); 427 CheckAreaData(kNamespace1, kOrigin1, reference); 428 } 429 430 TEST_F(SessionStorageDatabaseTest, WriteDataForTwoOrigins) { 431 // Write data. 432 DOMStorageValuesMap data1; 433 data1[kKey1] = kValue1; 434 data1[kKey2] = kValue2; 435 data1[kKey3] = kValue3; 436 EXPECT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin1, false, data1)); 437 438 DOMStorageValuesMap data2; 439 data2[kKey1] = kValue4; 440 data2[kKey2] = kValue1; 441 data2[kKey3] = kValue2; 442 EXPECT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin2, false, data2)); 443 444 CheckDatabaseConsistency(); 445 CheckAreaData(kNamespace1, kOrigin1, data1); 446 CheckAreaData(kNamespace1, kOrigin2, data2); 447 } 448 449 TEST_F(SessionStorageDatabaseTest, WriteDataForTwoNamespaces) { 450 // Write data. 451 DOMStorageValuesMap data11; 452 data11[kKey1] = kValue1; 453 data11[kKey2] = kValue2; 454 data11[kKey3] = kValue3; 455 EXPECT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin1, false, data11)); 456 DOMStorageValuesMap data12; 457 data12[kKey2] = kValue4; 458 data12[kKey3] = kValue3; 459 EXPECT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin2, false, data12)); 460 DOMStorageValuesMap data21; 461 data21[kKey1] = kValue2; 462 data21[kKey2] = kValue4; 463 EXPECT_TRUE(db_->CommitAreaChanges(kNamespace2, kOrigin1, false, data21)); 464 DOMStorageValuesMap data22; 465 data22[kKey2] = kValue1; 466 data22[kKey3] = kValue2; 467 EXPECT_TRUE(db_->CommitAreaChanges(kNamespace2, kOrigin2, false, data22)); 468 CheckDatabaseConsistency(); 469 CheckAreaData(kNamespace1, kOrigin1, data11); 470 CheckAreaData(kNamespace1, kOrigin2, data12); 471 CheckAreaData(kNamespace2, kOrigin1, data21); 472 CheckAreaData(kNamespace2, kOrigin2, data22); 473 } 474 475 TEST_F(SessionStorageDatabaseTest, ShallowCopy) { 476 // Write data for a namespace, for 2 origins. 477 DOMStorageValuesMap data1; 478 data1[kKey1] = kValue1; 479 data1[kKey2] = kValue2; 480 data1[kKey3] = kValue3; 481 ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin1, false, data1)); 482 DOMStorageValuesMap data2; 483 data2[kKey1] = kValue2; 484 data2[kKey3] = kValue1; 485 ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin2, false, data2)); 486 // Make a shallow copy. 487 EXPECT_TRUE(db_->CloneNamespace(kNamespace1, kNamespaceClone)); 488 // Now both namespaces should have the same data. 489 CheckDatabaseConsistency(); 490 CheckAreaData(kNamespace1, kOrigin1, data1); 491 CheckAreaData(kNamespace1, kOrigin2, data2); 492 CheckAreaData(kNamespaceClone, kOrigin1, data1); 493 CheckAreaData(kNamespaceClone, kOrigin2, data2); 494 // Both the namespaces refer to the same maps. 495 EXPECT_EQ(GetMapForArea(kNamespace1, kOrigin1), 496 GetMapForArea(kNamespaceClone, kOrigin1)); 497 EXPECT_EQ(GetMapForArea(kNamespace1, kOrigin2), 498 GetMapForArea(kNamespaceClone, kOrigin2)); 499 EXPECT_EQ(2, GetMapRefCount(GetMapForArea(kNamespace1, kOrigin1))); 500 EXPECT_EQ(2, GetMapRefCount(GetMapForArea(kNamespace1, kOrigin2))); 501 } 502 503 TEST_F(SessionStorageDatabaseTest, WriteIntoShallowCopy) { 504 DOMStorageValuesMap data1; 505 data1[kKey1] = kValue1; 506 data1[kKey2] = kValue2; 507 ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin1, false, data1)); 508 EXPECT_TRUE(db_->CloneNamespace(kNamespace1, kNamespaceClone)); 509 510 // Write data into a shallow copy. 511 DOMStorageValuesMap changes; 512 DOMStorageValuesMap reference; 513 changes[kKey1] = kValueNull; 514 changes[kKey2] = kValue4; 515 changes[kKey3] = kValue4; 516 reference[kKey2] = kValue4; 517 reference[kKey3] = kValue4; 518 EXPECT_TRUE(db_->CommitAreaChanges(kNamespaceClone, kOrigin1, false, 519 changes)); 520 521 // Values in the original namespace were not changed. 522 CheckAreaData(kNamespace1, kOrigin1, data1); 523 // But values in the copy were. 524 CheckAreaData(kNamespaceClone, kOrigin1, reference); 525 526 // The namespaces no longer refer to the same map. 527 EXPECT_NE(GetMapForArea(kNamespace1, kOrigin1), 528 GetMapForArea(kNamespaceClone, kOrigin1)); 529 EXPECT_EQ(1, GetMapRefCount(GetMapForArea(kNamespace1, kOrigin1))); 530 EXPECT_EQ(1, GetMapRefCount(GetMapForArea(kNamespaceClone, kOrigin1))); 531 } 532 533 TEST_F(SessionStorageDatabaseTest, ManyShallowCopies) { 534 // Write data for a namespace, for 2 origins. 535 DOMStorageValuesMap data1; 536 data1[kKey1] = kValue1; 537 data1[kKey2] = kValue2; 538 data1[kKey3] = kValue3; 539 ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin1, false, data1)); 540 DOMStorageValuesMap data2; 541 data2[kKey1] = kValue2; 542 data2[kKey3] = kValue1; 543 ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin2, false, data2)); 544 545 // Make a two shallow copies. 546 EXPECT_TRUE(db_->CloneNamespace(kNamespace1, kNamespaceClone)); 547 std::string another_clone("another_cloned"); 548 EXPECT_TRUE(db_->CloneNamespace(kNamespace1, another_clone)); 549 550 // Make a shallow copy of a shallow copy. 551 std::string clone_of_clone("clone_of_clone"); 552 EXPECT_TRUE(db_->CloneNamespace(another_clone, clone_of_clone)); 553 554 // Now all namespaces should have the same data. 555 CheckDatabaseConsistency(); 556 CheckAreaData(kNamespace1, kOrigin1, data1); 557 CheckAreaData(kNamespaceClone, kOrigin1, data1); 558 CheckAreaData(another_clone, kOrigin1, data1); 559 CheckAreaData(clone_of_clone, kOrigin1, data1); 560 CheckAreaData(kNamespace1, kOrigin2, data2); 561 CheckAreaData(kNamespaceClone, kOrigin2, data2); 562 CheckAreaData(another_clone, kOrigin2, data2); 563 CheckAreaData(clone_of_clone, kOrigin2, data2); 564 565 // All namespaces refer to the same maps. 566 EXPECT_EQ(GetMapForArea(kNamespace1, kOrigin1), 567 GetMapForArea(kNamespaceClone, kOrigin1)); 568 EXPECT_EQ(GetMapForArea(kNamespace1, kOrigin2), 569 GetMapForArea(kNamespaceClone, kOrigin2)); 570 EXPECT_EQ(GetMapForArea(kNamespace1, kOrigin1), 571 GetMapForArea(another_clone, kOrigin1)); 572 EXPECT_EQ(GetMapForArea(kNamespace1, kOrigin2), 573 GetMapForArea(another_clone, kOrigin2)); 574 EXPECT_EQ(GetMapForArea(kNamespace1, kOrigin1), 575 GetMapForArea(clone_of_clone, kOrigin1)); 576 EXPECT_EQ(GetMapForArea(kNamespace1, kOrigin2), 577 GetMapForArea(clone_of_clone, kOrigin2)); 578 579 // Check the ref counts. 580 EXPECT_EQ(4, GetMapRefCount(GetMapForArea(kNamespace1, kOrigin1))); 581 EXPECT_EQ(4, GetMapRefCount(GetMapForArea(kNamespace1, kOrigin2))); 582 } 583 584 TEST_F(SessionStorageDatabaseTest, DisassociateShallowCopy) { 585 DOMStorageValuesMap data1; 586 data1[kKey1] = kValue1; 587 data1[kKey2] = kValue2; 588 ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin1, false, data1)); 589 EXPECT_TRUE(db_->CloneNamespace(kNamespace1, kNamespaceClone)); 590 591 // Disassoaciate the shallow copy. 592 EXPECT_TRUE(db_->DeleteArea(kNamespaceClone, kOrigin1)); 593 CheckDatabaseConsistency(); 594 595 // Now new data can be written to that map. 596 DOMStorageValuesMap reference; 597 DOMStorageValuesMap changes; 598 changes[kKey1] = kValueNull; 599 changes[kKey2] = kValue4; 600 changes[kKey3] = kValue4; 601 reference[kKey2] = kValue4; 602 reference[kKey3] = kValue4; 603 EXPECT_TRUE(db_->CommitAreaChanges(kNamespaceClone, kOrigin1, false, 604 changes)); 605 606 // Values in the original map were not changed. 607 CheckAreaData(kNamespace1, kOrigin1, data1); 608 609 // But values in the disassociated map were. 610 CheckAreaData(kNamespaceClone, kOrigin1, reference); 611 } 612 613 TEST_F(SessionStorageDatabaseTest, DeleteNamespace) { 614 DOMStorageValuesMap data1; 615 data1[kKey1] = kValue1; 616 data1[kKey2] = kValue2; 617 data1[kKey3] = kValue3; 618 ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin1, false, data1)); 619 DOMStorageValuesMap data2; 620 data2[kKey2] = kValue4; 621 data2[kKey3] = kValue3; 622 ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin2, false, data2)); 623 EXPECT_TRUE(db_->DeleteNamespace(kNamespace1)); 624 CheckDatabaseConsistency(); 625 CheckEmptyDatabase(); 626 } 627 628 TEST_F(SessionStorageDatabaseTest, DeleteNamespaceWithShallowCopy) { 629 // Write data for a namespace, for 2 origins. 630 DOMStorageValuesMap data1; 631 data1[kKey1] = kValue1; 632 data1[kKey2] = kValue2; 633 data1[kKey3] = kValue3; 634 ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin1, false, data1)); 635 DOMStorageValuesMap data2; 636 data2[kKey1] = kValue2; 637 data2[kKey3] = kValue1; 638 ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin2, false, data2)); 639 640 // Make a shallow copy and delete the original namespace. 641 EXPECT_TRUE(db_->CloneNamespace(kNamespace1, kNamespaceClone)); 642 EXPECT_TRUE(db_->DeleteNamespace(kNamespace1)); 643 644 // The original namespace has no data. 645 CheckDatabaseConsistency(); 646 CheckAreaData(kNamespace1, kOrigin1, DOMStorageValuesMap()); 647 CheckAreaData(kNamespace1, kOrigin2, DOMStorageValuesMap()); 648 // But the copy persists. 649 CheckAreaData(kNamespaceClone, kOrigin1, data1); 650 CheckAreaData(kNamespaceClone, kOrigin2, data2); 651 } 652 653 TEST_F(SessionStorageDatabaseTest, DeleteArea) { 654 // Write data for a namespace, for 2 origins. 655 DOMStorageValuesMap data1; 656 data1[kKey1] = kValue1; 657 data1[kKey2] = kValue2; 658 data1[kKey3] = kValue3; 659 ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin1, false, data1)); 660 DOMStorageValuesMap data2; 661 data2[kKey1] = kValue2; 662 data2[kKey3] = kValue1; 663 ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin2, false, data2)); 664 665 EXPECT_TRUE(db_->DeleteArea(kNamespace1, kOrigin2)); 666 CheckDatabaseConsistency(); 667 // The data for the non-deleted origin persists. 668 CheckAreaData(kNamespace1, kOrigin1, data1); 669 // The data for the deleted origin is gone. 670 CheckAreaData(kNamespace1, kOrigin2, DOMStorageValuesMap()); 671 } 672 673 TEST_F(SessionStorageDatabaseTest, DeleteAreaWithShallowCopy) { 674 // Write data for a namespace, for 2 origins. 675 DOMStorageValuesMap data1; 676 data1[kKey1] = kValue1; 677 data1[kKey2] = kValue2; 678 data1[kKey3] = kValue3; 679 ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin1, false, data1)); 680 DOMStorageValuesMap data2; 681 data2[kKey1] = kValue2; 682 data2[kKey3] = kValue1; 683 ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin2, false, data2)); 684 685 // Make a shallow copy and delete an origin from the original namespace. 686 EXPECT_TRUE(db_->CloneNamespace(kNamespace1, kNamespaceClone)); 687 EXPECT_TRUE(db_->DeleteArea(kNamespace1, kOrigin1)); 688 CheckDatabaseConsistency(); 689 690 // The original namespace has data for only the non-deleted origin. 691 CheckAreaData(kNamespace1, kOrigin1, DOMStorageValuesMap()); 692 CheckAreaData(kNamespace1, kOrigin2, data2); 693 // But the copy persists. 694 CheckAreaData(kNamespaceClone, kOrigin1, data1); 695 CheckAreaData(kNamespaceClone, kOrigin2, data2); 696 } 697 698 TEST_F(SessionStorageDatabaseTest, WriteRawBytes) { 699 // Write data which is not valid utf8 and contains null bytes. 700 unsigned char raw_data[10] = {255, 0, 0, 0, 1, 2, 3, 4, 5, 0}; 701 DOMStorageValuesMap changes; 702 base::string16 string_with_raw_data; 703 string_with_raw_data.assign(reinterpret_cast<base::char16*>(raw_data), 5); 704 changes[kKey1] = base::NullableString16(string_with_raw_data, false); 705 EXPECT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin1, false, changes)); 706 CheckDatabaseConsistency(); 707 DOMStorageValuesMap values; 708 db_->ReadAreaValues(kNamespace1, kOrigin1, &values); 709 const unsigned char* data = 710 reinterpret_cast<const unsigned char*>(values[kKey1].string().data()); 711 for (int i = 0; i < 10; ++i) 712 EXPECT_EQ(raw_data[i], data[i]); 713 } 714 715 TEST_F(SessionStorageDatabaseTest, DeleteNamespaceConfusion) { 716 // Regression test for a bug where a namespace with id 10 prevented deleting 717 // the namespace with id 1. 718 719 DOMStorageValuesMap data1; 720 data1[kKey1] = kValue1; 721 ASSERT_TRUE(db_->CommitAreaChanges("foobar", kOrigin1, false, data1)); 722 ASSERT_TRUE(db_->CommitAreaChanges("foobarbaz", kOrigin1, false, data1)); 723 724 // Delete the namespace with ID 1. 725 EXPECT_TRUE(db_->DeleteNamespace("foobar")); 726 } 727 728 TEST_F(SessionStorageDatabaseTest, ReadNamespaceIds) { 729 DOMStorageValuesMap data1; 730 data1[kKey1] = kValue1; 731 data1[kKey2] = kValue2; 732 data1[kKey3] = kValue3; 733 std::set<std::string> expected_namespace_ids; 734 735 ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin1, false, data1)); 736 expected_namespace_ids.insert(kNamespace1); 737 CheckNamespaceIds(expected_namespace_ids); 738 739 ASSERT_TRUE(db_->CloneNamespace(kNamespace1, kNamespaceClone)); 740 expected_namespace_ids.insert(kNamespaceClone); 741 CheckNamespaceIds(expected_namespace_ids); 742 743 ASSERT_TRUE(db_->DeleteNamespace(kNamespace1)); 744 expected_namespace_ids.erase(kNamespace1); 745 CheckNamespaceIds(expected_namespace_ids); 746 747 CheckDatabaseConsistency(); 748 } 749 750 TEST_F(SessionStorageDatabaseTest, ReadNamespaceIdsInEmptyDatabase) { 751 std::set<std::string> expected_namespace_ids; 752 CheckNamespaceIds(expected_namespace_ids); 753 } 754 755 TEST_F(SessionStorageDatabaseTest, ReadOriginsInNamespace) { 756 DOMStorageValuesMap data1; 757 data1[kKey1] = kValue1; 758 data1[kKey2] = kValue2; 759 data1[kKey3] = kValue3; 760 761 std::set<GURL> expected_origins1; 762 ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin1, false, data1)); 763 ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin2, false, data1)); 764 expected_origins1.insert(kOrigin1); 765 expected_origins1.insert(kOrigin2); 766 CheckOrigins(kNamespace1, expected_origins1); 767 768 std::set<GURL> expected_origins2; 769 ASSERT_TRUE(db_->CommitAreaChanges(kNamespace2, kOrigin2, false, data1)); 770 expected_origins2.insert(kOrigin2); 771 CheckOrigins(kNamespace2, expected_origins2); 772 773 ASSERT_TRUE(db_->CloneNamespace(kNamespace1, kNamespaceClone)); 774 CheckOrigins(kNamespaceClone, expected_origins1); 775 776 ASSERT_TRUE(db_->DeleteArea(kNamespace1, kOrigin2)); 777 expected_origins1.erase(kOrigin2); 778 CheckOrigins(kNamespace1, expected_origins1); 779 780 CheckDatabaseConsistency(); 781 } 782 783 TEST_F(SessionStorageDatabaseTest, DeleteAllOrigins) { 784 // Write data for a namespace, for 2 origins. 785 DOMStorageValuesMap data1; 786 data1[kKey1] = kValue1; 787 ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin1, false, data1)); 788 DOMStorageValuesMap data2; 789 data2[kKey1] = kValue2; 790 ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin2, false, data2)); 791 792 EXPECT_TRUE(db_->DeleteArea(kNamespace1, kOrigin1)); 793 EXPECT_TRUE(db_->DeleteArea(kNamespace1, kOrigin2)); 794 // Check that also the namespace start key was deleted. 795 CheckDatabaseConsistency(); 796 } 797 798 799 } // namespace content 800
