DomStorage data deletion and memory purging.

webkit/dom_storage/dom_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/dom_storage_database.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "sql/diagnostic_error_delegate.h"
 #include "sql/statement.h"
 #include "sql/transaction.h"
 #include "third_party/sqlite/sqlite3.h"
 
 namespace {
 
+const FilePath::CharType kJournal[] = FILE_PATH_LITERAL("-journal");
+
 class HistogramUniquifier {
  public:
   static const char* name() { return "Sqlite.DomStorageDatabase.Error"; }
 };
 
 sql::ErrorDelegate* GetErrorHandlerForDomStorageDatabase() {
   return new sql::DiagnosticErrorDelegate<HistogramUniquifier>();
 }
 
 }  // anon namespace
 
 namespace dom_storage {
 
+// static
+FilePath DomStorageDatabase::GetJournalFilePath(
+    const FilePath& database_path) {
+  FilePath::StringType journal_file_name =
+      database_path.BaseName().value() + kJournal;
+  return database_path.DirName().Append(journal_file_name);
+}
+
 DomStorageDatabase::DomStorageDatabase(const FilePath& file_path)
     : file_path_(file_path) {
   // Note: in normal use we should never get an empty backing path here.
-  // However, the unit test for this class defines another constructor
-  // that will bypass this check to allow an empty path that signifies
-  // we should operate on an in-memory database for performance/reliability
-  // reasons.
-  DCHECK(!file_path_.empty());
+  // However, the unit test for this class can contruct an instance
+  // with an empty path.
   Init();
 }
 
 DomStorageDatabase::DomStorageDatabase() {
   Init();
 }
 
 void DomStorageDatabase::Init() {
   failed_to_open_ = false;
   tried_to_recreate_ = false;
   known_to_be_empty_ = false;
 }
 
 DomStorageDatabase::~DomStorageDatabase() {
   if (known_to_be_empty_ && !file_path_.empty()) {
-    // Delete the db from disk, it's empty.
+    // Delete the db and any lingering journal file from disk.
     Close();
     file_util::Delete(file_path_, false);
+    file_util::Delete(GetJournalFilePath(file_path_), false);
   }
 }
 
 void DomStorageDatabase::ReadAllValues(ValuesMap* result) {
   if (!LazyOpen(false))
     return;
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE,
                                                    "SELECT * from ItemTable"));
   DCHECK(statement.is_valid());
 
   while (statement.Step()) {
     string16 key = statement.ColumnString16(0);
     string16 value;
     statement.ColumnBlobAsString16(1, &value);
     (*result)[key] = NullableString16(value, false);
   }
   known_to_be_empty_ = result->empty();
 }
 
 bool DomStorageDatabase::CommitChanges(bool clear_all_first,
                                        const ValuesMap& changes) {
-  if (!LazyOpen(!changes.empty()))
-    return false;
+  if (!LazyOpen(!changes.empty())) {
+    // If we're being asked to commit changes that will result in an
+    // empty database, we return true if the database file doesn't exist.
+    return clear_all_first && changes.empty() &&
+           !file_util::PathExists(file_path_);
+  }
 
   bool old_known_to_be_empty = known_to_be_empty_;
   sql::Transaction transaction(db_.get());
   if (!transaction.Begin())
     return false;
 
   if (clear_all_first) {
     if (!db_->Execute("DELETE FROM ItemTable"))
       return false;
     known_to_be_empty_ = true;
@@ skipping 194 matching lines @@
       CreateTableV2() &&
       CommitChanges(false, values) &&
       migration.Commit();
 }
 
 void DomStorageDatabase::Close() {
   db_.reset(NULL);
 }
 
 }  // namespace dom_storage