Support WebSQLDatabases in incognito mode.

webkit/database/database_tracker.cc

 // Copyright (c) 2010 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/database/database_tracker.h"
 
 #include <vector>
 
 #include "app/sql/connection.h"
 #include "app/sql/diagnostic_error_delegate.h"
 #include "app/sql/meta_table.h"
 #include "app/sql/statement.h"
 #include "app/sql/transaction.h"
 #include "base/basictypes.h"
-#include "base/file_path.h"
 #include "base/file_util.h"
+#include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "net/base/net_errors.h"
 #include "webkit/database/databases_table.h"
 #include "webkit/database/quota_table.h"
 
 namespace {
 
 class HistogramUniquifier {
  public:
   static const char* name() { return "Sqlite.DatabaseTracker.Error"; }
 };
 
 sql::ErrorDelegate* GetErrorHandlerForTrackerDb() {
   return new sql::DiagnosticErrorDelegate<HistogramUniquifier>();
 }
 
 }  // anon namespace
 
 namespace webkit_database {
 
 const FilePath::CharType kDatabaseDirectoryName[] =
     FILE_PATH_LITERAL("databases");
+const FilePath::CharType kIncognitoDatabaseDirectoryName[] =
+    FILE_PATH_LITERAL("databases-incognito");
 const FilePath::CharType kTrackerDatabaseFileName[] =
     FILE_PATH_LITERAL("Databases.db");
 static const int kCurrentVersion = 2;
 static const int kCompatibleVersion = 1;
 static const char* kExtensionOriginIdentifierPrefix = "chrome-extension_";
 
-DatabaseTracker::DatabaseTracker(const FilePath& profile_path)
+DatabaseTracker::DatabaseTracker(const FilePath& profile_path,
+                                 bool is_incognito)
     : is_initialized_(false),
-      is_incognito_(profile_path.empty()),
+      is_incognito_(is_incognito),
+      shutting_down_(false),
+      profile_path_(profile_path),
       db_dir_(is_incognito_ ?
-          FilePath() : profile_path.Append(kDatabaseDirectoryName)),
+              profile_path_.Append(kIncognitoDatabaseDirectoryName) :
+              profile_path_.Append(kDatabaseDirectoryName)),
       db_(new sql::Connection()),
       databases_table_(NULL),
       meta_table_(NULL),
-      default_quota_(5 * 1024 * 1024) {
+      default_quota_(5 * 1024 * 1024),
+      incognito_origin_directories_generator_(0) {
 }
 
 DatabaseTracker::~DatabaseTracker() {
   DCHECK(dbs_to_be_deleted_.empty());
   DCHECK(deletion_callbacks_.empty());
 }
 
 void DatabaseTracker::SetDefaultQuota(int64 quota) {
   default_quota_ = quota;
   ClearAllCachedOriginInfo();
@@ skipping 97 matching lines @@
 void DatabaseTracker::RemoveObserver(Observer* observer) {
   // When we remove a listener, we do not know which cached information
   // is still needed and which information can be discarded. So we just
   // clear all caches and re-populate them as needed.
   observers_.RemoveObserver(observer);
   ClearAllCachedOriginInfo();
 }
 
 void DatabaseTracker::CloseTrackerDatabaseAndClearCaches() {
   ClearAllCachedOriginInfo();
-  meta_table_.reset(NULL);
-  databases_table_.reset(NULL);
-  quota_table_.reset(NULL);
-  db_->Close();
-  is_initialized_ = false;
+
+  if (!is_incognito_) {
+    meta_table_.reset(NULL);
+    databases_table_.reset(NULL);
+    quota_table_.reset(NULL);
+    db_->Close();
+    is_initialized_ = false;
+  }
+}
+
+string16 DatabaseTracker::GetOriginDirectory(
+    const string16& origin_identifier) {
+  if (!is_incognito_)
+    return origin_identifier;
+
+  OriginDirectoriesMap::const_iterator it =
+      incognito_origin_directories_.find(origin_identifier);
+  if (it != incognito_origin_directories_.end())
+    return it->second;
+
+  string16 origin_directory =
+      IntToString16(incognito_origin_directories_generator_++);
+  incognito_origin_directories_[origin_identifier] = origin_directory;
+  return origin_directory;
 }
 
 FilePath DatabaseTracker::GetFullDBFilePath(
     const string16& origin_identifier,
     const string16& database_name) {
   DCHECK(!origin_identifier.empty());
   DCHECK(!database_name.empty());
   if (!LazyInit())
     return FilePath();
 
   int64 id = databases_table_->GetDatabaseID(
       origin_identifier, database_name);
   if (id < 0)
     return FilePath();
 
   FilePath file_name = FilePath::FromWStringHack(Int64ToWString(id));
   return db_dir_.Append(FilePath::FromWStringHack(
-      UTF16ToWide(origin_identifier))).Append(file_name);
+      UTF16ToWide(GetOriginDirectory(origin_identifier)))).Append(file_name);
 }
 
 bool DatabaseTracker::GetAllOriginsInfo(std::vector<OriginInfo>* origins_info) {
   DCHECK(origins_info);
   DCHECK(origins_info->empty());
   if (!LazyInit())
     return false;
 
   std::vector<string16> origins;
   if (!databases_table_->GetAllOrigins(&origins))
@@ skipping 88 matching lines @@
     const string16& database_name) {
   DatabaseSet::iterator it = dbs_to_be_deleted_.find(origin_identifier);
   if (it == dbs_to_be_deleted_.end())
     return false;
 
   std::set<string16>& databases = it->second;
   return (databases.find(database_name) != databases.end());
 }
 
 bool DatabaseTracker::LazyInit() {
-  if (!is_initialized_ && !is_incognito_) {
+  if (!is_initialized_ && !shutting_down_) {
     DCHECK(!db_->is_open());
     DCHECK(!databases_table_.get());
     DCHECK(!quota_table_.get());
     DCHECK(!meta_table_.get());
 
     // If the tracker database exists, but it's corrupt or doesn't
     // have a meta table, delete the database directory.
     const FilePath kTrackerDatabaseFullPath =
         db_dir_.Append(FilePath(kTrackerDatabaseFileName));
     if (file_util::DirectoryExists(db_dir_) &&
         file_util::PathExists(kTrackerDatabaseFullPath) &&
         (!db_->Open(kTrackerDatabaseFullPath) ||
          !sql::MetaTable::DoesTableExist(db_.get()))) {
       db_->Close();
       if (!file_util::Delete(db_dir_, true))
         return false;
     }
 
     db_->set_error_delegate(GetErrorHandlerForTrackerDb());
 
     databases_table_.reset(new DatabasesTable(db_.get()));
     quota_table_.reset(new QuotaTable(db_.get()));
     meta_table_.reset(new sql::MetaTable());
 
     is_initialized_ =
         file_util::CreateDirectory(db_dir_) &&
-        (db_->is_open() || db_->Open(kTrackerDatabaseFullPath)) &&
+        (db_->is_open() ||
+         (is_incognito_ ? db_->OpenInMemory() :
+          db_->Open(kTrackerDatabaseFullPath))) &&
         UpgradeToCurrentVersion();
     if (!is_initialized_) {
       databases_table_.reset(NULL);
       quota_table_.reset(NULL);
       meta_table_.reset(NULL);
       db_->Close();
     }
   }
   return is_initialized_;
 }
@@ skipping 217 matching lines @@
       DeleteClosedDatabase(origin, db->database_name);
   }
 
   if (!to_be_deleted.empty()) {
     ScheduleDatabasesForDeletion(to_be_deleted, callback);
     return net::ERR_IO_PENDING;
   }
   return net::OK;
 }
 
+void DatabaseTracker::GetIncognitoFileHandle(
+    const string16& vfs_file_name, base::PlatformFile* file_handle) const {
+  DCHECK(is_incognito_);
+  FileHandlesMap::const_iterator it =
+      incognito_file_handles_.find(vfs_file_name);
+  if (it != incognito_file_handles_.end())
+    *file_handle = it->second;
+  else
+    *file_handle = base::kInvalidPlatformFileValue;
+}
+
+void DatabaseTracker::SaveIncognitoFileHandle(
+    const string16& vfs_file_name, const base::PlatformFile& file_handle) {
+  DCHECK(is_incognito_);
+  DCHECK(incognito_file_handles_.find(vfs_file_name) ==
+         incognito_file_handles_.end());
+  if (file_handle != base::kInvalidPlatformFileValue)
+    incognito_file_handles_[vfs_file_name] = file_handle;
+}
+
+bool DatabaseTracker::CloseIncognitoFileHandle(const string16& vfs_file_name) {
+  DCHECK(is_incognito_);
+  DCHECK(incognito_file_handles_.find(vfs_file_name) !=
+         incognito_file_handles_.end());
+
+  bool handle_closed = false;
+  FileHandlesMap::iterator it = incognito_file_handles_.find(vfs_file_name);
+  if (it != incognito_file_handles_.end()) {
+    handle_closed = !base::ClosePlatformFile(it->second);
+    if (handle_closed)
+      incognito_file_handles_.erase(it);
+  }
+  return handle_closed;
+}
+
+bool DatabaseTracker::HasSavedIncognitoFileHandle(
+    const string16& vfs_file_name) const {
+  return (incognito_file_handles_.find(vfs_file_name) !=
+          incognito_file_handles_.end());
+}
+
+void DatabaseTracker::DeleteIncognitoDBDirectory() {
+  shutting_down_ = true;
+  is_initialized_ = false;
+
+  for (FileHandlesMap::iterator it = incognito_file_handles_.begin();
+       it != incognito_file_handles_.end(); it++)
+    base::ClosePlatformFile(it->second);
+
+  FilePath incognito_db_dir =
+      profile_path_.Append(kIncognitoDatabaseDirectoryName);
+  if (file_util::DirectoryExists(incognito_db_dir))
+    file_util::Delete(incognito_db_dir, true);
+}
+
 // static
 void DatabaseTracker::ClearLocalState(const FilePath& profile_path) {
   FilePath db_dir = profile_path.Append(FilePath(kDatabaseDirectoryName));
   FilePath db_tracker = db_dir.Append(FilePath(kTrackerDatabaseFileName));
   if (file_util::DirectoryExists(db_dir) &&
       file_util::PathExists(db_tracker)) {
     scoped_ptr<sql::Connection> db_(new sql::Connection);
     if (!db_->Open(db_tracker) ||
         !db_->DoesTableExist("Databases")) {
       db_->Close();
@@ skipping 18 matching lines @@
        file_path = file_enumerator.Next()) {
     if (file_path.BaseName() != FilePath(kTrackerDatabaseFileName)) {
       if (!StartsWith(file_path.BaseName().ToWStringHack(),
                       ASCIIToWide(kExtensionOriginIdentifierPrefix), true))
         file_util::Delete(file_path, true);
     }
   }
 }
 
 }  // namespace webkit_database