SessionStorageDatabase fix: Delete namespace keys if there are no areas.

webkit/dom_storage/session_storage_database_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 
 #include "webkit/dom_storage/session_storage_database.h"
 
 #include <algorithm>
 #include <map>
 #include <string>
@@ skipping 65 matching lines @@
   const NullableString16 kValue3;
   const NullableString16 kValue4;
   const NullableString16 kValueNull;
 
   DISALLOW_COPY_AND_ASSIGN(SessionStorageDatabaseTest);
 };
 
 SessionStorageDatabaseTest::SessionStorageDatabaseTest()
     : kOrigin1("http://www.origin1.com"),
       kOrigin2("http://www.origin2.com"),
-      kNamespace1("1"),
+      kNamespace1("namespace1"),
       kNamespace2("namespace2"),
       kNamespaceClone("wascloned"),
       kKey1(ASCIIToUTF16("key1")),
       kKey2(ASCIIToUTF16("key2")),
       kKey3(ASCIIToUTF16("key3")),
       kValue1(NullableString16(ASCIIToUTF16("value1"), false)),
       kValue2(NullableString16(ASCIIToUTF16("value2"), false)),
       kValue3(NullableString16(ASCIIToUTF16("value3"), false)),
       kValue4(NullableString16(ASCIIToUTF16("value4"), false)),
       kValueNull(NullableString16(true)) { }
@@ skipping 109 matching lines @@
     // keys.
     for (DataMap::const_iterator it = data.begin(); it != data.end(); ++it) {
       ASSERT_TRUE(it->first == next_map_id_key);
     }
     return;
   }
   ++valid_keys;
 
   // Iterate the "namespace-" keys.
   std::set<std::string> found_namespace_ids;
+  std::set<std::string> namespaces_with_areas;
   std::map<int64, int64> expected_map_refcounts;
   int64 max_map_id = -1;
 
   for (DataMap::const_iterator it = data.begin(); it != data.end(); ++it) {
     std::string namespace_id;
     std::string origin;
     if (IsNamespaceKey(it->first, &namespace_id)) {
       found_namespace_ids.insert(namespace_id);
       ++valid_keys;
     } else if (IsNamespaceOriginKey(
         it->first, &namespace_id)) {
       // Check that the corresponding "namespace-<namespaceid>-" key exists. It
       // has been read by now, since the keys are stored in order.
       ASSERT_TRUE(found_namespace_ids.find(namespace_id) !=
                   found_namespace_ids.end());
+      namespaces_with_areas.insert(namespace_id);
       int64 map_id;
       bool conversion_ok = base::StringToInt64(it->second, &map_id);
       ASSERT_TRUE(conversion_ok);
       ASSERT_GE(map_id, 0);
       ++expected_map_refcounts[map_id];
       max_map_id = std::max(map_id, max_map_id);
       ++valid_keys;
     }
   }
+  // Check that there are no leftover "namespace-namespaceid-" keys without
+  // associated areas.
+  ASSERT_EQ(found_namespace_ids.size(), namespaces_with_areas.size());
+
   if (max_map_id != -1) {
     // The database contains maps.
     ASSERT_TRUE(data.find(next_map_id_key) != data.end());
     int64 next_map_id;
     bool conversion_ok =
         base::StringToInt64(data[next_map_id_key], &next_map_id);
     ASSERT_TRUE(conversion_ok);
     ASSERT_GT(next_map_id, max_map_id);
   }
 
@@ skipping 516 matching lines @@
   ASSERT_TRUE(db_->CloneNamespace(kNamespace1, kNamespaceClone));
   CheckOrigins(kNamespaceClone, expected_origins1);
 
   ASSERT_TRUE(db_->DeleteArea(kNamespace1, kOrigin2));
   expected_origins1.erase(kOrigin2);
   CheckOrigins(kNamespace1, expected_origins1);
 
   CheckDatabaseConsistency();
 }
 
+TEST_F(SessionStorageDatabaseTest, DeleteAllOrigins) {
+  // Write data for a namespace, for 2 origins.
+  ValuesMap data1;
+  data1[kKey1] = kValue1;
+  ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin1, false, data1));
+  ValuesMap data2;
+  data2[kKey1] = kValue2;
+  ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin2, false, data2));
+
+  EXPECT_TRUE(db_->DeleteArea(kNamespace1, kOrigin1));
+  EXPECT_TRUE(db_->DeleteArea(kNamespace1, kOrigin2));
+  // Check that also the namespace start key was deleted.
+  CheckDatabaseConsistency();
+}
+
+
 }  // namespace dom_storage