DomStorage data deletion and memory purging.

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 "base/file_util.h"
 #include "base/logging.h"
 #include "base/time.h"
 #include "base/tracked_objects.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebString.h"
+#include "webkit/database/database_util.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/dom_storage/dom_storage_types.h"
 #include "webkit/fileapi/file_system_util.h"
+#include "webkit/glue/webkit_glue.h"
+
+using webkit_database::DatabaseUtil;
 
 namespace dom_storage {
 
 static const int kCommitTimerSeconds = 1;
 
 DomStorageArea::CommitBatch::CommitBatch()
   : clear_all_first(false) {
 }
 DomStorageArea::CommitBatch::~CommitBatch() {}
 
 
 // static
 const FilePath::CharType DomStorageArea::kDatabaseFileExtension[] =
     FILE_PATH_LITERAL(".localstorage");
 
 // static
 FilePath DomStorageArea::DatabaseFileNameFromOrigin(const GURL& origin) {
   std::string filename = fileapi::GetOriginIdentifierFromURL(origin);
   // There is no FilePath.AppendExtension() method, so start with just the
   // extension as the filename, and then InsertBeforeExtension the desired
   // name.
   return FilePath().Append(kDatabaseFileExtension).
       InsertBeforeExtensionASCII(filename);
 }
 
+// static
+GURL DomStorageArea::OriginFromDatabaseFileName(const FilePath& name) {
+  DCHECK(name.MatchesExtension(kDatabaseFileExtension));
+  WebKit::WebString origin_id = webkit_glue::FilePathToWebString(
+      name.BaseName().RemoveExtension());
+  return DatabaseUtil::GetOriginFromIdentifier(origin_id);
+}
+
 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(kPerAreaQuota)),
       is_initial_import_done_(true),
       is_shutdown_(false) {
   if (namespace_id == kLocalStorageNamespaceId && !directory.empty()) {
@@ skipping 80 matching lines @@
   DCHECK_NE(kLocalStorageNamespaceId, destination_namespace_id);
   DCHECK(!backing_.get());  // SessionNamespaces aren't stored on disk.
 
   DomStorageArea* copy = new DomStorageArea(destination_namespace_id, origin_,
                                             FilePath(), task_runner_);
   copy->map_ = map_;
   copy->is_shutdown_ = is_shutdown_;
   return copy;
 }
 
+bool DomStorageArea::HasUncommittedChanges() const {
+  DCHECK(!is_shutdown_);
+  return commit_batch_.get() || in_flight_commit_batch_.get();
+}
+
+void DomStorageArea::DeleteOrigin() {
+  DCHECK(!is_shutdown_);
+  if (HasUncommittedChanges()) {
+    // TODO(michaeln): This logically deletes the data immediately,
+    // and in a matter of a second, deletes the rows from the backing
+    // database file, but the file itself will linger until shutdown
+    // or purge time. Ideally, this should delete the file more
+    // quickly.
+    Clear();
+    return;
+  }
+  map_ = new DomStorageMap(kPerAreaQuota);
+  if (backing_.get()) {
+    backing_.reset(new DomStorageDatabase(backing_->file_path()));
+    file_util::Delete(backing_->file_path(), false);
+    is_initial_import_done_ = false;
+  }
+}
+
+void DomStorageArea::PurgeMemory() {
+  DCHECK(!is_shutdown_);
+  if (!is_initial_import_done_ ||  // We're not using any memory.
+      !backing_.get() ||  // We can't purge anything.
+      HasUncommittedChanges())  // We leave things alone with changes pending.
+    return;
+
+  // Drop the in memory cache, we'll reload when needed.
+  is_initial_import_done_ = false;
+  map_ = new DomStorageMap(kPerAreaQuota);
+
+  // Recreate the database object, this frees up the open sqlite connection
+  // and its page cache.
+  backing_.reset(new DomStorageDatabase(backing_->file_path()));
+}
+
 void DomStorageArea::Shutdown() {
   DCHECK(!is_shutdown_);
   is_shutdown_ = true;
   map_ = NULL;
   if (!backing_.get())
     return;
 
   bool success = task_runner_->PostShutdownBlockingTask(
       FROM_HERE,
       DomStorageTaskRunner::COMMIT_SEQUENCE,
@@ skipping 86 matching lines @@
         commit_batch_->clear_all_first,
         commit_batch_->changed_values);
     DCHECK(success);
   }
   commit_batch_.reset();
   in_flight_commit_batch_.reset();
   backing_.reset();
 }
 
 }  // namespace dom_storage