Persist sessionStorage on disk.

webkit/dom_storage/session_storage_database.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 "base/file_util.h"
 #include "base/logging.h"
 #include "base/stringprintf.h"
 #include "base/string_number_conversions.h"
@@ skipping 90 matching lines @@
         return false;
     }
   }
 
   WriteValuesToMap(map_id, changes, &batch);
 
   leveldb::Status s = db_->Write(leveldb::WriteOptions(), &batch);
   return DatabaseErrorCheck(s.ok());
 }
 
-bool SessionStorageDatabase::CloneNamespace(int64 namespace_id,
+void SessionStorageDatabase::CloneNamespace(int64 namespace_id,
                                             int64 new_namespace_id) {
   // Go through all origins in the namespace |namespace_id|, create placeholders
   // for them in |new_namespace_id|, and associate them with the existing maps.
 
   // Example, data before shallow copy:
   // | map-1                          | 1 (refcount)        |
   // | map-1-a                        | b                   |
   // | namespace-1 (1 = namespace id) | dummy               |
   // | namespace-1-origin1            | 1 (mapid)           |
 
   // Example, data after shallow copy:
   // | map-1                          | 2 (inc. refcount)   |
   // | map-1-a                        | b                   |
   // | namespace-1 (1 = namespace id) | dummy               |
   // | namespace-1-origin1            | 1 (mapid)           |
   // | namespace-2                    | dummy               |
   // | namespace-2-origin1            | 1 (mapid) << references the same map
 
   if (!LazyOpen(true))
-    return false;
+    return;
 
   leveldb::WriteBatch batch;
   const bool kOkIfExists = false;
   if (!CreateNamespace(new_namespace_id, kOkIfExists, &batch))
-    return false;
+    return;
 
   std::map<std::string, std::string> areas;
   if (!GetAreasInNamespace(namespace_id, &areas))
-    return false;
+    return;
 
   for (std::map<std::string, std::string>::const_iterator it = areas.begin();
        it != areas.end(); ++it) {
     const std::string& origin = it->first;
     const std::string& map_id = it->second;
     if (!IncreaseMapRefCount(map_id, &batch))
-      return false;
+      return;
     AddAreaToNamespace(new_namespace_id, origin, map_id, &batch);
   }
   leveldb::Status s = db_->Write(leveldb::WriteOptions(), &batch);
-  return DatabaseErrorCheck(s.ok());
+  DatabaseErrorCheck(s.ok());
 }
 
-bool SessionStorageDatabase::DeleteArea(int64 namespace_id,
+void SessionStorageDatabase::DeleteArea(int64 namespace_id,
                                         const GURL& origin) {
   if (!LazyOpen(false)) {
     // No need to create the database if it doesn't exist.
-    return true;
+    return;
   }
   leveldb::WriteBatch batch;
-  if (!DeleteArea(namespace_id, origin.spec(), &batch))
-    return false;
+  if (!DeleteAreaHelper(namespace_id, origin.spec(), &batch))
+    return;
   leveldb::Status s = db_->Write(leveldb::WriteOptions(), &batch);
-  return DatabaseErrorCheck(s.ok());
+  DatabaseErrorCheck(s.ok());
 }
 
 bool SessionStorageDatabase::DeleteNamespace(int64 namespace_id) {
   if (!LazyOpen(false)) {
     // No need to create the database if it doesn't exist.
     return true;
   }
   // Itereate through the areas in the namespace.
   leveldb::WriteBatch batch;
   std::map<std::string, std::string> areas;
   if (!GetAreasInNamespace(namespace_id, &areas))
     return false;
   for (std::map<std::string, std::string>::const_iterator it = areas.begin();
        it != areas.end(); ++it) {
     const std::string& origin = it->first;
-    if (!DeleteArea(namespace_id, origin, &batch))
+    if (!DeleteAreaHelper(namespace_id, origin, &batch))
       return false;
   }
   batch.Delete(NamespaceStartKey(namespace_id, namespace_offset_));
   leveldb::Status s = db_->Write(leveldb::WriteOptions(), &batch);
   return DatabaseErrorCheck(s.ok());
 }
 
+bool SessionStorageDatabase::ReadNamespaceIds(
+    std::vector<int64>* namespace_ids) {
+  if (!LazyOpen(true))
+    return false;
+
+  std::string namespace_prefix = NamespacePrefix();
+  scoped_ptr<leveldb::Iterator> it(db_->NewIterator(leveldb::ReadOptions()));
+  it->Seek(namespace_prefix);
+  if (it->status().IsNotFound())
+    return true;
+
+  if (!DatabaseErrorCheck(it->status().ok()))
+    return false;
+
+  // Skip the dummy entry "namespace-" and iterate the namespaces.
+  for (it->Next(); it->Valid(); it->Next()) {
+    std::string key = it->key().ToString();
+    if (key.find(namespace_prefix) != 0) {
+      // Iterated past the "namespace-" keys.
+      break;
+    }
+    size_t second_dash = key.find('-', namespace_prefix.length());
+    if (second_dash != std::string::npos)
+      continue;
+
+    // The key is of the form "namespace-<namespaceid>".
+    std::string namespace_id_str = key.substr(namespace_prefix.length());
+    int64 namespace_id;
+    bool conversion_ok =
+        base::StringToInt64(namespace_id_str, &namespace_id);
+    if (!ConsistencyCheck(conversion_ok))
+      return false;
+    namespace_ids->push_back(namespace_id - namespace_offset_);
+  }
+  return true;
+}
+
 bool SessionStorageDatabase::LazyOpen(bool create_if_needed) {
   base::AutoLock auto_lock(db_lock_);
   if (db_error_ || is_inconsistent_) {
     // Don't try to open a database that we know has failed already.
     return false;
   }
   if (IsOpen())
     return true;
 
   if (!create_if_needed &&
@@ skipping 165 matching lines @@
 
 void SessionStorageDatabase::AddAreaToNamespace(int64 namespace_id,
                                                 const std::string& origin,
                                                 const std::string& map_id,
                                                 leveldb::WriteBatch* batch) {
   std::string namespace_key = NamespaceKey(
       NamespaceIdStr(namespace_id, namespace_offset_), origin);
   batch->Put(namespace_key, map_id);
 }
 
-bool SessionStorageDatabase::DeleteArea(int64 namespace_id,
-                                        const std::string& origin,
-                                        leveldb::WriteBatch* batch) {
-  return DeleteArea(NamespaceIdStr(namespace_id, namespace_offset_),
-                    origin, batch);
+bool SessionStorageDatabase::DeleteAreaHelper(int64 namespace_id,
+                                              const std::string& origin,
+                                              leveldb::WriteBatch* batch) {
+  return DeleteAreaHelper(NamespaceIdStr(namespace_id, namespace_offset_),
+                          origin, batch);
 }
 
-bool SessionStorageDatabase::DeleteArea(const std::string& namespace_id_str,
-                                        const std::string& origin,
-                                        leveldb::WriteBatch* batch) {
+bool SessionStorageDatabase::DeleteAreaHelper(
+    const std::string& namespace_id_str,
+    const std::string& origin,
+    leveldb::WriteBatch* batch) {
   std::string map_id;
   bool exists;
   if (!GetMapForArea(namespace_id_str, origin, &exists, &map_id))
     return false;
   if (!exists)
     return true;  // Nothing to delete.
   if (!DecreaseMapRefCount(map_id, 1, batch))
     return false;
   std::string namespace_key = NamespaceKey(namespace_id_str, origin);
   batch->Delete(namespace_key);
@@ skipping 237 matching lines @@
 
 const char* SessionStorageDatabase::NextNamespaceIdKey() {
   return "next-namespace-id";
 }
 
 const char* SessionStorageDatabase::NextMapIdKey() {
   return "next-map-id";
 }
 
 }  // namespace dom_storage