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 23 matching lines @@
 // | namespace-3-origin2            | 2 (shallow copy)                   |
 // | next-namespace-id              | 4                                  |
 // | next-map-id                    | 4                                  |
 
 namespace dom_storage {
 
 SessionStorageDatabase::SessionStorageDatabase(const FilePath& file_path)
     : file_path_(file_path),
       db_error_(false),
       is_inconsistent_(false),
-      namespace_offset_(0) {
+      next_namespace_id_(0),
+      next_negative_namespace_id_(-1) {
+}
+
+SessionStorageDatabase::SessionStorageDatabase(
+    const FilePath& file_path,
+    const SessionStorageAssociatedCallback& associated_callback)
+    : file_path_(file_path),
+      db_error_(false),
+      is_inconsistent_(false),
+      next_namespace_id_(0),
+      next_negative_namespace_id_(-1),
+      associated_callback_(associated_callback) {
 }
 
 SessionStorageDatabase::~SessionStorageDatabase() {
 }
 
 void SessionStorageDatabase::ReadAreaValues(int64 namespace_id,
                                             const GURL& origin,
                                             ValuesMap* result) {
   // We don't create a database if it doesn't exist. In that case, there is
   // nothing to be added to the result.
@@ skipping 97 matching lines @@
   return DatabaseErrorCheck(s.ok());
 }
 
 bool SessionStorageDatabase::DeleteArea(int64 namespace_id,
                                         const GURL& origin) {
   if (!LazyOpen(false)) {
     // No need to create the database if it doesn't exist.
     return true;
   }
   leveldb::WriteBatch batch;
-  if (!DeleteArea(namespace_id, origin.spec(), &batch))
+  if (!DeleteAreaHelper(namespace_id, origin.spec(), &batch))
     return false;
   leveldb::Status s = db_->Write(leveldb::WriteOptions(), &batch);
   return 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_));
+  batch.Delete(NamespaceStartKey(namespace_id));
   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 real_namespace_id;
+    bool conversion_ok =
+        base::StringToInt64(namespace_id_str, &real_namespace_id);
+    if (!ConsistencyCheck(conversion_ok))
+      return false;
+    std::map<int64, int64>::const_iterator it =
+        real_id_to_id_.find(real_namespace_id);
+    if (it != real_id_to_id_.end()) {
+      namespace_ids->push_back(it->second);
+    } else {
+      // There is no known upper layer ID for this namespace. Create one. (The
+      // upper layer will only create positive IDs, so this won't overlap with
+      // the IDs created by it.)
+      int64 upper_layer_id = next_negative_namespace_id_--;
+      AssociateNamespaceId(upper_layer_id, real_namespace_id);
+      namespace_ids->push_back(upper_layer_id);
+    }
+  }
+  return true;
+}
+
+void SessionStorageDatabase::AssociateNamespaceId(int64 namespace_id,
+                                                  int64 real_id) {
+  id_to_real_id_[namespace_id] = real_id;
+  real_id_to_id_[real_id] = namespace_id;
+}
+
 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 18 matching lines @@
     s = TryToOpen(&db);
     if (!s.ok()) {
       LOG(WARNING) << "Failed to open leveldb in " << file_path_.value()
                    << ", error: " << s.ToString();
       DCHECK(db == NULL);
       db_error_ = true;
       return false;
     }
   }
   db_.reset(db);
-
-  return GetNextNamespaceId(&namespace_offset_);
+  return GetNextNamespaceId(&next_namespace_id_);
 }
 
 leveldb::Status SessionStorageDatabase::TryToOpen(leveldb::DB** db) {
   leveldb::Options options;
   // The directory exists but a valid leveldb database might not exist inside it
   // (e.g., a subset of the needed files might be missing). Handle this
   // situation gracefully by creating the database now.
   options.create_if_missing = true;
 #if defined(OS_WIN)
   return leveldb::DB::Open(options, WideToUTF8(file_path_.value()), db);
@@ skipping 38 matching lines @@
                                              leveldb::WriteBatch* batch) {
   leveldb::Slice namespace_prefix = NamespacePrefix();
   std::string dummy;
   leveldb::Status s = db_->Get(leveldb::ReadOptions(), namespace_prefix,
                                &dummy);
   if (!DatabaseErrorCheck(s.ok() || s.IsNotFound()))
     return false;
   if (s.IsNotFound())
     batch->Put(namespace_prefix, "");
 
-  std::string namespace_start_key =
-      NamespaceStartKey(namespace_id, namespace_offset_);
+  std::string namespace_start_key = NamespaceStartKey(namespace_id);
   s = db_->Get(leveldb::ReadOptions(), namespace_start_key, &dummy);
   if (!DatabaseErrorCheck(s.ok() || s.IsNotFound()))
     return false;
   if (s.IsNotFound()) {
     batch->Put(namespace_start_key, "");
     return UpdateNextNamespaceId(namespace_id, batch);
   }
   return CallerErrorCheck(ok_if_exists);
 }
 
@@ skipping 10 matching lines @@
   bool conversion_ok =
       base::StringToInt64(next_namespace_id_string, next_namespace_id);
   return ConsistencyCheck(conversion_ok);
 }
 
 bool SessionStorageDatabase::UpdateNextNamespaceId(int64 namespace_id,
                                                    leveldb::WriteBatch* batch) {
   int64 next_namespace_id;
   if (!GetNextNamespaceId(&next_namespace_id))
     return false;
-  if (next_namespace_id < namespace_id + namespace_offset_ + 1) {
-    next_namespace_id = namespace_id + namespace_offset_ + 1;
+  int64 real_id;
+  if (!GetRealId(namespace_id, &real_id))
+    return false;
+  if (next_namespace_id < real_id + 1) {
+    next_namespace_id = real_id + 1;
     batch->Put(NextNamespaceIdKey(), base::Int64ToString(next_namespace_id));
   }
   return true;
 }
 
 bool SessionStorageDatabase::GetAreasInNamespace(
     int64 namespace_id,
     std::map<std::string, std::string>* areas) {
-  return GetAreasInNamespace(NamespaceIdStr(namespace_id, namespace_offset_),
-                             areas);
+  return GetAreasInNamespace(NamespaceIdStr(namespace_id), areas);
 }
 
 bool SessionStorageDatabase::GetAreasInNamespace(
     const std::string& namespace_id_str,
     std::map<std::string, std::string>* areas) {
   std::string namespace_start_key = NamespaceStartKey(namespace_id_str);
   scoped_ptr<leveldb::Iterator> it(db_->NewIterator(leveldb::ReadOptions()));
   it->Seek(namespace_start_key);
   if (it->status().IsNotFound()) {
     // The namespace_start_key is not found when the namespace doesn't contain
     // any areas. We don't need to do anything.
     return true;
   }
   if (!DatabaseErrorCheck(it->status().ok()))
     return false;
 
   // Skip the dummy entry "namespace-<namespaceid>" and iterate the origins.
   for (it->Next(); it->Valid(); it->Next()) {
     std::string key = it->key().ToString();
     if (key.find(namespace_start_key) != 0) {
       // Iterated past the origins for this namespace.
       break;
     }
     size_t second_dash = key.find('-', namespace_start_key.length());
-    if (!ConsistencyCheck(second_dash != std::string::npos))
-      return false;
+    if (second_dash == std::string::npos)
+      break;
     std::string origin = key.substr(second_dash + 1);
     std::string map_id = it->value().ToString();
     (*areas)[origin] = map_id;
   }
   return true;
 }
 
 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);
+  std::string namespace_key =
+      NamespaceKey(NamespaceIdStr(namespace_id), 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), 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);
   return true;
 }
 
 bool SessionStorageDatabase::GetMapForArea(int64 namespace_id,
                                            const GURL& origin,
                                            bool* exists,
                                            std::string* map_id) {
-  return GetMapForArea(
-      base::Int64ToString(namespace_id + namespace_offset_),
-      origin.spec(), exists, map_id);
+  int64 real_id;
+  if (!GetRealId(namespace_id, &real_id))
+    return false;
+  return GetMapForArea(base::Int64ToString(real_id), origin.spec(),
+                       exists, map_id);
 }
 
 bool SessionStorageDatabase::GetMapForArea(const std::string& namespace_id_str,
                                            const std::string& origin,
                                            bool* exists, std::string* map_id) {
   std::string namespace_key = NamespaceKey(namespace_id_str, origin);
   leveldb::Status s = db_->Get(leveldb::ReadOptions(), namespace_key, map_id);
   if (s.IsNotFound()) {
     *exists = false;
     return true;
@@ skipping 12 matching lines @@
     return false;
   int64 next_map_id = 0;
   if (s.IsNotFound()) {
     *map_id = "0";
   } else {
     bool conversion_ok = base::StringToInt64(*map_id, &next_map_id);
     if (!ConsistencyCheck(conversion_ok))
       return false;
   }
   batch->Put(next_map_id_key, base::Int64ToString(++next_map_id));
-  std::string namespace_key =
-      NamespaceKey(namespace_id, namespace_offset_, origin);
+  std::string namespace_key = NamespaceKey(namespace_id, origin);
   batch->Put(namespace_key, *map_id);
   batch->Put(MapRefCountKey(*map_id), "1");
   return true;
 }
 
 bool SessionStorageDatabase::ReadMap(const std::string& map_id,
                                      ValuesMap* result,
                                      bool only_keys) {
   scoped_ptr<leveldb::Iterator> it(db_->NewIterator(leveldb::ReadOptions()));
   std::string map_start_key = MapRefCountKey(map_id);
@@ skipping 130 matching lines @@
     return false;
   // Create a new map (this will also break the association to the old map) and
   // write the old data into it. This will write the id of the created map into
   // |map_id|.
   if (!CreateMapForArea(namespace_id, origin, map_id, batch))
     return false;
   WriteValuesToMap(*map_id, values, batch);
   return true;
 }
 
+bool SessionStorageDatabase::AllocateNamespaceId(int64* namespace_id) {
+  if (!LazyOpen(true))
+    return false;
+  *namespace_id = next_namespace_id_++;
+  // The next namespace id field in the db will be increased when data is
+  // actually written to the namespace.
+  return true;
+}
+
+bool SessionStorageDatabase::GetRealId(int64 namespace_id, int64* real_id) {
+  std::map<int64, int64>::const_iterator it = id_to_real_id_.find(namespace_id);
+  if (it != id_to_real_id_.end()) {
+    *real_id = it->second;
+    return true;
+  }
+  if (!AllocateNamespaceId(real_id))
+    return false;
+  if (!associated_callback_.is_null())
+    associated_callback_.Run(namespace_id, *real_id);
+  AssociateNamespaceId(namespace_id, *real_id);
+  return true;
+}
+
 std::string SessionStorageDatabase::NamespaceStartKey(
     const std::string& namespace_id_str) {
   return base::StringPrintf("namespace-%s", namespace_id_str.c_str());
 }
 
-std::string SessionStorageDatabase::NamespaceStartKey(int64 namespace_id,
-                                                      int64 namespace_offset) {
-  return NamespaceStartKey(NamespaceIdStr(namespace_id, namespace_offset));
+std::string SessionStorageDatabase::NamespaceStartKey(int64 namespace_id) {
+  return NamespaceStartKey(NamespaceIdStr(namespace_id));
 }
 
 std::string SessionStorageDatabase::NamespaceKey(
     const std::string& namespace_id_str, const std::string& origin) {
   return base::StringPrintf("namespace-%s-%s", namespace_id_str.c_str(),
                             origin.c_str());
 }
 
-std::string SessionStorageDatabase::NamespaceKey(
-    int64 namespace_id, int64 namespace_offset, const GURL& origin) {
-  return NamespaceKey(NamespaceIdStr(namespace_id, namespace_offset),
-                      origin.spec());
+std::string SessionStorageDatabase::NamespaceKey(int64 namespace_id,
+                                                 const GURL& origin) {
+  return NamespaceKey(NamespaceIdStr(namespace_id), origin.spec());
 }
 
-std::string SessionStorageDatabase::NamespaceIdStr(int64 namespace_id,
-                                                   int64 namespace_offset) {
-  return base::Int64ToString(namespace_id + namespace_offset);
+std::string SessionStorageDatabase::NamespaceIdStr(int64 namespace_id) {
+  int64 real_id;
+  if (!GetRealId(namespace_id, &real_id))
+    return "";
+  return base::Int64ToString(real_id);
 }
 
 const char* SessionStorageDatabase::NamespacePrefix() {
   return "namespace-";
 }
 
 std::string SessionStorageDatabase::MapRefCountKey(const std::string& map_id) {
   return base::StringPrintf("map-%s", map_id.c_str());
 }
 
 std::string SessionStorageDatabase::MapKey(const std::string& map_id,
                                            const std::string& key) {
   return base::StringPrintf("map-%s-%s", map_id.c_str(), key.c_str());
 }
 
 const char* SessionStorageDatabase::MapPrefix() {
   return "map-";
 }
 
 const char* SessionStorageDatabase::NextNamespaceIdKey() {
   return "next-namespace-id";
 }
 
 const char* SessionStorageDatabase::NextMapIdKey() {
   return "next-map-id";
 }
 
 }  // namespace dom_storage