Support WebSQLDatabases in incognito mode.

webkit/database/database_tracker.h

 // 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.
 
 #ifndef WEBKIT_DATABASE_DATABASE_TRACKER_H_
 #define WEBKIT_DATABASE_DATABASE_TRACKER_H_
 
 #include <map>
 #include <set>
 
 #include "base/file_path.h"
 #include "base/observer_list.h"
+#include "base/platform_file.h"
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/string16.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "net/base/completion_callback.h"
 #include "testing/gtest/include/gtest/gtest_prod.h"
 #include "webkit/database/database_connections.h"
 
 namespace sql {
@@ skipping 70 matching lines @@
     virtual void OnDatabaseSizeChanged(const string16& origin_identifier,
                                        const string16& database_name,
                                        int64 database_size,
                                        int64 space_available) = 0;
     virtual void OnDatabaseScheduledForDeletion(
         const string16& origin_identifier,
         const string16& database_name) = 0;
     virtual ~Observer() {}
   };
 
-  explicit DatabaseTracker(const FilePath& profile_path);
+  DatabaseTracker(const FilePath& profile_path, bool is_incognito);
 
   void DatabaseOpened(const string16& origin_identifier,
                       const string16& database_name,
                       const string16& database_details,
                       int64 estimated_size,
                       int64* database_size,
                       int64* space_available);
   void DatabaseModified(const string16& origin_identifier,
                         const string16& database_name);
   void DatabaseClosed(const string16& origin_identifier,
@@ skipping 35 matching lines @@
   // completion, if non-NULL.
   int DeleteDataModifiedSince(const base::Time& cutoff,
                               net::CompletionCallback* callback);
 
   // Delete all databases that belong to the given origin. Returns net::OK on
   // success, net::FAILED if not all databases could be deleted, and
   // net::ERR_IO_PENDING and |callback| is invoked upon completion, if non-NULL.
   int DeleteDataForOrigin(const string16& origin_identifier,
                           net::CompletionCallback* callback);
 
+  bool IsIncognitoProfile() const { return is_incognito_; }
+
+  void GetIncognitoFileHandle(const string16& vfs_file_path,
+                              base::PlatformFile* file_handle) const;
+  void SaveIncognitoFileHandle(const string16& vfs_file_path,
+                               const base::PlatformFile& file_handle);
+  bool CloseIncognitoFileHandle(const string16& vfs_file_path);
+  bool HasSavedIncognitoFileHandle(const string16& vfs_file_path) const;
+
+  // Deletes the directory that stores all DBs in incognito mode, if it exists.
+  void DeleteIncognitoDBDirectory();
+
   static void ClearLocalState(const FilePath& profile_path);
 
  private:
   // Need this here to allow RefCountedThreadSafe to call ~DatabaseTracker().
   friend class base::RefCountedThreadSafe<DatabaseTracker>;
 
   typedef std::map<string16, std::set<string16> > DatabaseSet;
   typedef std::map<net::CompletionCallback*, DatabaseSet> PendingCompletionMap;
+  typedef std::map<string16, base::PlatformFile> FileHandlesMap;
+  typedef std::map<string16, string16> OriginDirectoriesMap;
 
   class CachedOriginInfo : public OriginInfo {
    public:
     CachedOriginInfo() : OriginInfo(string16(), 0, 0) {}
     void SetOrigin(const string16& origin) { origin_ = origin; }
     void SetQuota(int64 new_quota) { quota_ = new_quota; }
     void SetDatabaseSize(const string16& database_name, int64 new_size) {
       int64 old_size = 0;
       if (database_info_.find(database_name) != database_info_.end())
         old_size = database_info_[database_name].first;
@@ skipping 32 matching lines @@
 
   int64 UpdateCachedDatabaseFileSize(const string16& origin_identifier,
                                      const string16& database_name);
   void ScheduleDatabaseForDeletion(const string16& origin_identifier,
                                    const string16& database_name);
   // Schedule a set of open databases for deletion. If non-null, callback is
   // invoked upon completion.
   void ScheduleDatabasesForDeletion(const DatabaseSet& databases,
                                     net::CompletionCallback* callback);
 
+  // Returns the directory where all DB files for the given origin are stored.
+  string16 GetOriginDirectory(const string16& origin_identifier);
+
   bool is_initialized_;
   const bool is_incognito_;
+  bool shutting_down_;
+  const FilePath profile_path_;
   const FilePath db_dir_;
   scoped_ptr<sql::Connection> db_;
   scoped_ptr<DatabasesTable> databases_table_;
   scoped_ptr<QuotaTable> quota_table_;
   scoped_ptr<sql::MetaTable> meta_table_;
   ObserverList<Observer, true> observers_;
   std::map<string16, CachedOriginInfo> origins_info_map_;
   DatabaseConnections database_connections_;
 
   // The set of databases that should be deleted but are still opened
   DatabaseSet dbs_to_be_deleted_;
   PendingCompletionMap deletion_callbacks_;
 
   // Default quota for all origins; changed only by tests
   int64 default_quota_;
 
   // Store quotas for extensions in memory, in order to prevent writing a row
   // to quota_table_ every time an extention is loaded.
   std::map<string16, int64> in_memory_quotas_;
 
-  FRIEND_TEST(DatabaseTrackerTest, DatabaseTracker);
-  FRIEND_TEST(DatabaseTrackerTest, NoInitIncognito);
+  // When in incognito mode, store a DELETE_ON_CLOSE handle to each
+  // main DB and journal file that was accessed. When the incognito profile
+  // goes away (or when the browser crashes), all these handles will be
+  // closed, and the files will be deleted.
+  FileHandlesMap incognito_file_handles_;
+
+  // In a non-incognito profile, all DBs in an origin are stored in a directory
+  // named after the origin. In an incognito profile though, we do not want the
+  // directory structure to reveal the origins visited by the user (in case the
+  // browser process crashes and those directories are not deleted). So we use
+  // this map to assign directory names that do not reveal this information.
+  OriginDirectoriesMap incognito_origin_directories_;
+  int incognito_origin_directories_generator_;
+
+  FRIEND_TEST(DatabaseTracker, TestHelper);
 };
 
 }  // namespace webkit_database
 
 #endif  // WEBKIT_DATABASE_DATABASE_TRACKER_H_