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 34 matching lines @@
 SessionStorageDatabase::~SessionStorageDatabase() {
 }
 
 void SessionStorageDatabase::ReadAreaValues(const std::string& 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.
   if (!LazyOpen(false))
     return;
+
+  // While ReadAreaValues is in progress, another thread can call
+  // CommitAreaChanges. CommitAreaChanges might update map ref count key while
+  // this thread is iterating over the map ref count key. To protect the reading
+  // operation, create a snapshot and read from it.
+  leveldb::ReadOptions options;
+  options.snapshot = db_->GetSnapshot();
+
   std::string map_id;
   bool exists;
-  if (!GetMapForArea(namespace_id, origin.spec(), &exists, &map_id))
-    return;
-  if (exists)
-    ReadMap(map_id, result, false);
+  if (GetMapForArea(namespace_id, origin.spec(), options, &exists, &map_id) &&
+      exists)
+    ReadMap(map_id, options, result, false);
+  db_->ReleaseSnapshot(options.snapshot);
 }
 
 bool SessionStorageDatabase::CommitAreaChanges(const std::string& namespace_id,
                                                const GURL& origin,
                                                bool clear_all_first,
                                                const ValuesMap& changes) {
   // Even if |changes| is empty, we need to write the appropriate placeholders
   // in the database, so that it can be later shallow-copied succssfully.
   if (!LazyOpen(true))
     return false;
 
   leveldb::WriteBatch batch;
   // Ensure that the keys "namespace-" "namespace-N" (see the schema above)
   // exist.
   const bool kOkIfExists = true;
   if (!CreateNamespace(namespace_id, kOkIfExists, &batch))
     return false;
 
   std::string map_id;
   bool exists;
-  if (!GetMapForArea(namespace_id, origin.spec(), &exists, &map_id))
+  if (!GetMapForArea(namespace_id, origin.spec(), leveldb::ReadOptions(),
+                     &exists, &map_id))
     return false;
   if (exists) {
     int64 ref_count;
     if (!GetMapRefCount(map_id, &ref_count))
       return false;
     if (ref_count > 1) {
       if (!DeepCopyArea(namespace_id, origin, !clear_all_first,
                         &map_id, &batch))
         return false;
     }
@@ skipping 93 matching lines @@
 }
 
 bool SessionStorageDatabase::ReadNamespaceIds(
     std::vector<std::string>* 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())
+  // Apparently it's possible for a leveldb iterator to have status "OK" and be
+  // invalid. Interpret invalid iterator as "key not found".
+  if (it->status().IsNotFound() || !it->Valid())
     return true;
 
   if (!DatabaseErrorCheck(it->status().ok()))
     return false;
 
   // Skip the dummy entry "namespace-" and iterate the namespaces.
   std::string current_namespace_start_key;
   for (it->Next(); it->Valid(); it->Next()) {
     std::string key = it->key().ToString();
     if (key.find(namespace_prefix) != 0) {
@@ skipping 10 matching lines @@
       // <namespaceid>.
       current_namespace_start_key = key;
       namespace_ids->push_back(
           key.substr(namespace_prefix.length(),
                      key.length() - namespace_prefix.length() - 1));
     }
   }
   return true;
 }
 
+bool SessionStorageDatabase::ReadOriginsInNamespace(
+    const std::string& namespace_id, std::vector<GURL>* origins) {
+  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)
+    origins->push_back(GURL(it->first));
+  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 94 matching lines @@
   }
   return CallerErrorCheck(ok_if_exists);
 }
 
 bool SessionStorageDatabase::GetAreasInNamespace(
     const std::string& namespace_id,
     std::map<std::string, std::string>* areas) {
   std::string namespace_start_key = NamespaceStartKey(namespace_id);
   scoped_ptr<leveldb::Iterator> it(db_->NewIterator(leveldb::ReadOptions()));
   it->Seek(namespace_start_key);
-  if (it->status().IsNotFound()) {
+  // Apparently it's possible for a leveldb iterator to have status "OK" and be
+  // invalid. Interpret invalid iterator as "key not found".
+  if (it->status().IsNotFound() || !it->Valid()) {
     // 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();
@@ skipping 15 matching lines @@
   std::string namespace_key = NamespaceKey(namespace_id, origin);
   batch->Put(namespace_key, map_id);
 }
 
 bool SessionStorageDatabase::DeleteAreaHelper(
     const std::string& namespace_id,
     const std::string& origin,
     leveldb::WriteBatch* batch) {
   std::string map_id;
   bool exists;
-  if (!GetMapForArea(namespace_id, origin, &exists, &map_id))
+  if (!GetMapForArea(namespace_id, origin, leveldb::ReadOptions(), &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, origin);
   batch->Delete(namespace_key);
   return true;
 }
 
 bool SessionStorageDatabase::GetMapForArea(const std::string& namespace_id,
                                            const std::string& origin,
+                                           const leveldb::ReadOptions& options,
                                            bool* exists, std::string* map_id) {
   std::string namespace_key = NamespaceKey(namespace_id, origin);
-  leveldb::Status s = db_->Get(leveldb::ReadOptions(), namespace_key, map_id);
+  leveldb::Status s = db_->Get(options, namespace_key, map_id);
   if (s.IsNotFound()) {
     *exists = false;
     return true;
   }
   *exists = true;
   return DatabaseErrorCheck(s.ok());
 }
 
 bool SessionStorageDatabase::CreateMapForArea(const std::string& namespace_id,
                                               const GURL& origin,
@@ skipping 12 matching lines @@
       return false;
   }
   batch->Put(next_map_id_key, base::Int64ToString(++next_map_id));
   std::string namespace_key = NamespaceKey(namespace_id, origin.spec());
   batch->Put(namespace_key, *map_id);
   batch->Put(MapRefCountKey(*map_id), "1");
   return true;
 }
 
 bool SessionStorageDatabase::ReadMap(const std::string& map_id,
+                                     const leveldb::ReadOptions& options,
                                      ValuesMap* result,
                                      bool only_keys) {
-  scoped_ptr<leveldb::Iterator> it(db_->NewIterator(leveldb::ReadOptions()));
+  scoped_ptr<leveldb::Iterator> it(db_->NewIterator(options));
   std::string map_start_key = MapRefCountKey(map_id);
   it->Seek(map_start_key);
   // The map needs to exist, otherwise we have a stale map_id in the database.
-  if (!ConsistencyCheck(!it->status().IsNotFound()))
+  if (!ConsistencyCheck(!it->status().IsNotFound() && it->Valid()))
     return false;
   if (!DatabaseErrorCheck(it->status().ok()))
     return false;
   // Skip the dummy entry "map-<mapid>-".
   for (it->Next(); it->Valid(); it->Next()) {
     std::string key = it->key().ToString();
     if (key.find(map_start_key) != 0) {
       // Iterated past the keys in this map.
       break;
     }
@@ skipping 70 matching lines @@
     if (!ClearMap(map_id, batch))
       return false;
     batch->Delete(MapRefCountKey(map_id));
   }
   return true;
 }
 
 bool SessionStorageDatabase::ClearMap(const std::string& map_id,
                                       leveldb::WriteBatch* batch) {
   ValuesMap values;
-  if (!ReadMap(map_id, &values, true))
+  if (!ReadMap(map_id, leveldb::ReadOptions(), &values, true))
     return false;
   for (ValuesMap::const_iterator it = values.begin(); it != values.end(); ++it)
     batch->Delete(MapKey(map_id, UTF16ToUTF8(it->first)));
   return true;
 }
 
 bool SessionStorageDatabase::DeepCopyArea(
     const std::string& namespace_id, const GURL& origin, bool copy_data,
     std::string* map_id, leveldb::WriteBatch* batch) {
   // Example, data before deep copy:
@@ skipping 10 matching lines @@
   // | namespace-2-                   | dummy               |
   // | namespace-2-origin1            | 2 (mapid) << references the new map
   // | map-1-                         | 1 (dec. refcount)   |
   // | map-1-a                        | b                   |
   // | map-2-                         | 1 (refcount)        |
   // | map-2-a                        | b                   |
 
   // Read the values from the old map here. If we don't need to copy the data,
   // this can stay empty.
   ValuesMap values;
-  if (copy_data && !ReadMap(*map_id, &values, false))
+  if (copy_data && !ReadMap(*map_id, leveldb::ReadOptions(), &values, false))
     return false;
   if (!DecreaseMapRefCount(*map_id, 1, batch))
     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;
@@ skipping 21 matching lines @@
 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::NextMapIdKey() {
   return "next-map-id";
 }
 
 }  // namespace dom_storage