Move code to clear web databases on shutdown to the database tracker

webkit/database/database_tracker.h

 // Copyright (c) 2011 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>
 
@@ skipping 70 matching lines @@
    public:
     virtual void OnDatabaseSizeChanged(const string16& origin_identifier,
                                        const string16& database_name,
                                        int64 database_size) = 0;
     virtual void OnDatabaseScheduledForDeletion(
         const string16& origin_identifier,
         const string16& database_name) = 0;
     virtual ~Observer() {}
   };
 
-  DatabaseTracker(const FilePath& profile_path, bool is_incognito,
+  DatabaseTracker(const FilePath& profile_path,
+                  bool is_incognito,
+                  bool clear_local_state_on_exit,
                   quota::SpecialStoragePolicy* special_storage_policy,
                   quota::QuotaManagerProxy* quota_manager_proxy,
                   base::MessageLoopProxy* db_tracker_thread);
 
   void DatabaseOpened(const string16& origin_identifier,
                       const string16& database_name,
                       const string16& database_details,
                       int64 estimated_size,
                       int64* database_size);
   void DatabaseModified(const string16& origin_identifier,
@@ skipping 14 matching lines @@
   // virtual for unittesting only
   virtual bool GetOriginInfo(const string16& origin_id, OriginInfo* info);
   virtual bool GetAllOriginIdentifiers(std::vector<string16>* origin_ids);
   virtual bool GetAllOriginsInfo(std::vector<OriginInfo>* origins_info);
 
   // Safe to call on any thread.
   quota::QuotaManagerProxy* quota_manager_proxy() const {
     return quota_manager_proxy_.get();
   }
 
+  // Safe to call on any thread.
+  quota::SpecialStoragePolicy* special_storage_policy() const {
+    return special_storage_policy_.get();
+  }
+
+
   bool IsDatabaseScheduledForDeletion(const string16& origin_identifier,
                                       const string16& database_name);
 
   // Deletes a single database. Returns net::OK on success, net::FAILED on
   // failure, or net::ERR_IO_PENDING and |callback| is invoked upon completion,
   // if non-NULL.
   int DeleteDatabase(const string16& origin_identifier,
                      const string16& database_name,
                      net::CompletionCallback* callback);
 
   // Delete any databases that have been touched since the cutoff date that's
   // supplied, omitting any that match IDs within |protected_origins|.
   // 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. Protected origins, according the the SpecialStoragePolicy,
   // are not deleted by this method.
   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.
   // virtual for unit testing only
   virtual int DeleteDataForOrigin(const string16& origin_identifier,
                                   net::CompletionCallback* callback);
 
+  // Delete all files belonging to the given origin given that no database
+  // connections within this origin are open, or if |force| is true, delete
+  // the meta data and rename the associated directory.
+  bool DeleteOrigin(const string16& origin_identifier, bool force);
+
   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);
+  // Deletes databases not protected by the special storage policy if
+  // |clear_local_state_on_exit_| is true and blocks databases from being
+  // created/opened.
+  void Shutdown();
+  void SetClearLocalStateOnExit(bool clear_local_state_on_exit);
 
  private:
   friend class base::RefCountedThreadSafe<DatabaseTracker>;
   friend class MockDatabaseTracker;  // for testing
 
   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;
 
@@ skipping 13 matching lines @@
                                 const string16& description) {
       database_info_[database_name].second = description;
     }
   };
 
   // virtual for unittesting only
   virtual ~DatabaseTracker();
 
   bool DeleteClosedDatabase(const string16& origin_identifier,
                             const string16& database_name);
-  bool DeleteOrigin(const string16& origin_identifier);
   void DeleteDatabaseIfNeeded(const string16& origin_identifier,
                               const string16& database_name);
 
   bool LazyInit();
   bool UpgradeToCurrentVersion();
   void InsertOrUpdateDatabaseDetails(const string16& origin_identifier,
                                      const string16& database_name,
                                      const string16& database_details,
                                      int64 estimated_size);
 
@@ skipping 12 matching lines @@
   // 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 clear_local_state_on_exit_;
   bool shutting_down_;
   const FilePath profile_path_;
   const FilePath db_dir_;
   scoped_ptr<sql::Connection> db_;
   scoped_ptr<DatabasesTable> databases_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_;
 
   // Apps and Extensions can have special rights.
   scoped_refptr<quota::SpecialStoragePolicy> special_storage_policy_;
 
   scoped_refptr<quota::QuotaManagerProxy> quota_manager_proxy_;
 
+  // The database tracker thread we're supposed to run file IO on.
+  scoped_refptr<base::MessageLoopProxy> db_tracker_thread_;
+
   // 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_ALL_PREFIXES(DatabaseTracker, TestHelper);
 };
 
 }  // namespace webkit_database
 
 #endif  // WEBKIT_DATABASE_DATABASE_TRACKER_H_