Hook up DomStorageArea with a DomStorageDatabase.

webkit/dom_storage/dom_storage_area.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/dom_storage_area.h"
+
+#include "base/bind.h"
 #include "webkit/dom_storage/dom_storage_map.h"
 #include "webkit/dom_storage/dom_storage_namespace.h"
+#include "webkit/dom_storage/dom_storage_task_runner.h"
+#include "webkit/fileapi/file_system_util.h"
 
 namespace dom_storage {
 
 DomStorageArea::DomStorageArea(
     int64 namespace_id, const GURL& origin,
     const FilePath& directory, DomStorageTaskRunner* task_runner)
     : namespace_id_(namespace_id), origin_(origin),
       directory_(directory), task_runner_(task_runner),
-      map_(new DomStorageMap()) {
+      map_(new DomStorageMap()),
+      backing_(NULL),
+      initial_import_done_(false),
+      clear_all_next_commit_(false) {
+
+  if (namespace_id == kLocalStorageNamespaceId && !directory.empty()) {
+    FilePath path = directory.Append(DatabaseFileNameFromOrigin(origin_));
+    backing_.reset(new DomStorageDatabase(path));
+  } else {
+    // Not a local storage area or no directory specified for backing
+    // database, (i.e. it's an incognito profile).
+    initial_import_done_ = true;
+  }
 }
 
 DomStorageArea::~DomStorageArea() {
+  if (clear_all_next_commit_ || !changed_values_.empty()) {
+    // Still some data left that was not committed to disk, try
+    // now.
+    CommitChanges();
+  }
+  // TODO(benm): What if the last commit failed and there's still data
+  // left not synced to disk?
+  DCHECK(!clear_all_next_commit_);
+  DCHECK(changed_values_.empty());
 }
 
 unsigned DomStorageArea::Length() {
+  InitialImportIfNeeded();
   return map_->Length();
 }
 
 NullableString16 DomStorageArea::Key(unsigned index) {
+  InitialImportIfNeeded();
   return map_->Key(index);
 }
 
 NullableString16 DomStorageArea::GetItem(const string16& key) {
+  InitialImportIfNeeded();
   return map_->GetItem(key);
 }
 
-bool DomStorageArea::SetItem(
-    const string16& key, const string16& value,
-    NullableString16* old_value) {
+bool DomStorageArea::SetItem(const string16& key,
+                             const string16& value,
+                             NullableString16* old_value) {
+  InitialImportIfNeeded();
+
   if (!map_->HasOneRef())
     map_ = map_->DeepCopy();
-  return map_->SetItem(key, value, old_value);
+  bool success = map_->SetItem(key, value, old_value);
+  if (success && backing_.get()) {
+    changed_values_[key] = NullableString16(value, false);
+    ScheduleCommitChanges();
+  }
+  return success;
 }
 
-bool DomStorageArea::RemoveItem(
-    const string16& key,
-    string16* old_value) {
+bool DomStorageArea::RemoveItem(const string16& key, string16* old_value) {
+  InitialImportIfNeeded();
   if (!map_->HasOneRef())
     map_ = map_->DeepCopy();
-  return map_->RemoveItem(key, old_value);
+  bool success = map_->RemoveItem(key, old_value);
+  if (success && backing_.get()) {
+    changed_values_[key] = NullableString16(true);
+    ScheduleCommitChanges();
+  }
+  return success;
 }
 
 bool DomStorageArea::Clear() {
+  InitialImportIfNeeded();
   if (map_->Length() == 0)
     return false;
+
   map_ = new DomStorageMap();
+
+  if (backing_.get()) {
+    changed_values_.clear();
+    clear_all_next_commit_ = true;
+    ScheduleCommitChanges();
+  }
+
   return true;
 }
 
 DomStorageArea* DomStorageArea::ShallowCopy(int64 destination_namespace_id) {
   DCHECK_NE(kLocalStorageNamespaceId, namespace_id_);
   DCHECK_NE(kLocalStorageNamespaceId, destination_namespace_id);
   // SessionNamespaces aren't backed by files on disk.
+  DCHECK(!backing_.get());
+
   DomStorageArea* copy = new DomStorageArea(destination_namespace_id, origin_,
                                             FilePath(), task_runner_);
   copy->map_ = map_;
   return copy;
 }
 
+void DomStorageArea::InitialImportIfNeeded() {
+  if (initial_import_done_)
+    return;
+
+  DCHECK_EQ(kLocalStorageNamespaceId, namespace_id_);
+  DCHECK(backing_.get());
+
+  ValuesMap initial_values;
+  backing_->ReadAllValues(&initial_values);
+  map_->SwapValues(&initial_values);
+  initial_import_done_ = true;
+}
+
+void DomStorageArea::ScheduleCommitChanges() {
+  DCHECK_EQ(kLocalStorageNamespaceId, namespace_id_);
+  DCHECK(backing_.get());
+
+  if (!clear_all_next_commit_ && changed_values_.empty())

[michaeln, 2012/02/15 04:10:53]

given the usage of this method, it might make more sense to DCHECK() there's
something to be done instead of early returning if not

[benm (inactive), 2012/02/15 17:38:17]

sgtm.

+    return;
+
+  DCHECK(task_runner_.get());
+  if (!task_runner_->PostTask(

[michaeln, 2012/02/15 04:10:53]

As coded, this will result in many small transactions, one per every call to
set(), remove() and clear(). That would be noticable regression from the current
impl which batches changes and commits them on a one second timer.

Can you take a stab as logic to batch them up? I think the PostDelayedTask
function should help with that. Something like when a mutation happens, schedule
a delayed commit task if one is not already scheduled. When it runs clear the
flag that says one is scheduled.

[benm (inactive), 2012/02/15 17:38:17]

Done.

+      FROM_HERE, base::Bind(&DomStorageArea::CommitChanges, this))) {
+    // If we know that the task will not run, try and save changes synchronously
+    // so that we don't lose data.
+    CommitChanges();
+  }
+}
+
+void DomStorageArea::CommitChanges() {
+  DCHECK(backing_.get());
+  if (backing_->CommitChanges(clear_all_next_commit_, changed_values_)) {
+    clear_all_next_commit_ = false;
+    changed_values_.clear();
+  }
+}
+
+// static
+FilePath DomStorageArea::DatabaseFileNameFromOrigin(const GURL& origin) {
+  std::string filename = fileapi::GetOriginIdentifierFromURL(origin)
+      + ".localstorage";
+  return FilePath().AppendASCII(filename);
+}
+
 }  // namespace dom_storage