storage/browser/database/database_tracker.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef STORAGE_BROWSER_DATABASE_DATABASE_TRACKER_H_
   6 #define STORAGE_BROWSER_DATABASE_DATABASE_TRACKER_H_
   7
   8 #include <map>
   9 #include <set>
  10 #include <utility>
  11
  12 #include "base/files/file.h"
  13 #include "base/files/file_path.h"
  14 #include "base/gtest_prod_util.h"
  15 #include "base/memory/ref_counted.h"
  16 #include "base/memory/scoped_ptr.h"
  17 #include "base/observer_list.h"
  18 #include "base/strings/string16.h"
  19 #include "base/strings/string_util.h"
  20 #include "base/time/time.h"
  21 #include "net/base/completion_callback.h"
  22 #include "storage/browser/storage_browser_export.h"
  23 #include "storage/common/database/database_connections.h"
  24
  25 namespace base {
  26 class MessageLoopProxy;
  27 }
  28
  29 namespace content {
  30 class DatabaseTracker_TestHelper_Test;
  31 class MockDatabaseTracker;
  32 }
  33
  34 namespace sql {
  35 class Connection;
  36 class MetaTable;
  37 }
  38
  39 namespace storage {
  40 class QuotaManagerProxy;
  41 class SpecialStoragePolicy;
  42 }
  43
  44 namespace storage {
  45
  46 STORAGE_EXPORT extern const base::FilePath::CharType
  47     kDatabaseDirectoryName[];
  48 STORAGE_EXPORT extern const base::FilePath::CharType
  49     kTrackerDatabaseFileName[];
  50
  51 class DatabasesTable;
  52
  53 // This class is used to store information about all databases in an origin.
  54 class STORAGE_EXPORT OriginInfo {
  55  public:
  56   OriginInfo();
  57   OriginInfo(const OriginInfo& origin_info);
  58   ~OriginInfo();
  59
  60   const std::string& GetOriginIdentifier() const { return origin_identifier_; }
  61   int64 TotalSize() const { return total_size_; }
  62   void GetAllDatabaseNames(std::vector<base::string16>* databases) const;
  63   int64 GetDatabaseSize(const base::string16& database_name) const;
  64   base::string16 GetDatabaseDescription(
  65       const base::string16& database_name) const;
  66
  67  protected:
  68   typedef std::map<base::string16, std::pair<int64, base::string16> >
  69       DatabaseInfoMap;
  70
  71   OriginInfo(const std::string& origin_identifier, int64 total_size);
  72
  73   std::string origin_identifier_;
  74   int64 total_size_;
  75   DatabaseInfoMap database_info_;
  76 };
  77
  78 // This class manages the main database and keeps track of open databases.
  79 //
  80 // The data in this class is not thread-safe, so all methods of this class
  81 // should be called on the same thread. The only exceptions are the ctor(),
  82 // the dtor() and the database_directory() and quota_manager_proxy() getters.
  83 //
  84 // Furthermore, some methods of this class have to read/write data from/to
  85 // the disk. Therefore, in a multi-threaded application, all methods of this
  86 // class should be called on the thread dedicated to file operations (file
  87 // thread in the browser process, for example), if such a thread exists.
  88 class STORAGE_EXPORT DatabaseTracker
  89     : public base::RefCountedThreadSafe<DatabaseTracker> {
  90  public:
  91   class Observer {
  92    public:
  93     virtual void OnDatabaseSizeChanged(const std::string& origin_identifier,
  94                                        const base::string16& database_name,
  95                                        int64 database_size) = 0;
  96     virtual void OnDatabaseScheduledForDeletion(
  97         const std::string& origin_identifier,
  98         const base::string16& database_name) = 0;
  99
 100    protected:
 101     virtual ~Observer() {}
 102   };
 103
 104   DatabaseTracker(const base::FilePath& profile_path,
 105                   bool is_incognito,
 106                   storage::SpecialStoragePolicy* special_storage_policy,
 107                   storage::QuotaManagerProxy* quota_manager_proxy,
 108                   base::MessageLoopProxy* db_tracker_thread);
 109
 110   void DatabaseOpened(const std::string& origin_identifier,
 111                       const base::string16& database_name,
 112                       const base::string16& database_details,
 113                       int64 estimated_size,
 114                       int64* database_size);
 115   void DatabaseModified(const std::string& origin_identifier,
 116                         const base::string16& database_name);
 117   void DatabaseClosed(const std::string& origin_identifier,
 118                       const base::string16& database_name);
 119   void HandleSqliteError(const std::string& origin_identifier,
 120                          const base::string16& database_name,
 121                          int error);
 122
 123   void CloseDatabases(const DatabaseConnections& connections);
 124
 125   void AddObserver(Observer* observer);
 126   void RemoveObserver(Observer* observer);
 127
 128   void CloseTrackerDatabaseAndClearCaches();
 129
 130   const base::FilePath& DatabaseDirectory() const { return db_dir_; }
 131   base::FilePath GetFullDBFilePath(const std::string& origin_identifier,
 132                                    const base::string16& database_name);
 133
 134   // virtual for unit-testing only
 135   virtual bool GetOriginInfo(const std::string& origin_id, OriginInfo* info);
 136   virtual bool GetAllOriginIdentifiers(std::vector<std::string>* origin_ids);
 137   virtual bool GetAllOriginsInfo(std::vector<OriginInfo>* origins_info);
 138
 139   // Safe to call on any thread.
 140   storage::QuotaManagerProxy* quota_manager_proxy() const {
 141     return quota_manager_proxy_.get();
 142   }
 143
 144   bool IsDatabaseScheduledForDeletion(const std::string& origin_identifier,
 145                                       const base::string16& database_name);
 146
 147   // Deletes a single database. Returns net::OK on success, net::FAILED on
 148   // failure, or net::ERR_IO_PENDING and |callback| is invoked upon completion,
 149   // if non-NULL.
 150   int DeleteDatabase(const std::string& origin_identifier,
 151                      const base::string16& database_name,
 152                      const net::CompletionCallback& callback);
 153
 154   // Delete any databases that have been touched since the cutoff date that's
 155   // supplied, omitting any that match IDs within |protected_origins|.
 156   // Returns net::OK on success, net::FAILED if not all databases could be
 157   // deleted, and net::ERR_IO_PENDING and |callback| is invoked upon completion,
 158   // if non-NULL. Protected origins, according the the SpecialStoragePolicy,
 159   // are not deleted by this method.
 160   int DeleteDataModifiedSince(const base::Time& cutoff,
 161                               const net::CompletionCallback& callback);
 162
 163   // Delete all databases that belong to the given origin. Returns net::OK on
 164   // success, net::FAILED if not all databases could be deleted, and
 165   // net::ERR_IO_PENDING and |callback| is invoked upon completion, if non-NULL.
 166   // virtual for unit testing only
 167   virtual int DeleteDataForOrigin(const std::string& origin_identifier,
 168                                   const net::CompletionCallback& callback);
 169
 170   bool IsIncognitoProfile() const { return is_incognito_; }
 171
 172   const base::File* GetIncognitoFile(const base::string16& vfs_file_path) const;
 173   const base::File* SaveIncognitoFile(const base::string16& vfs_file_path,
 174                                       base::File file);
 175   void CloseIncognitoFileHandle(const base::string16& vfs_file_path);
 176   bool HasSavedIncognitoFileHandle(const base::string16& vfs_file_path) const;
 177
 178   // Shutdown the database tracker, deleting database files if the tracker is
 179   // used for an incognito profile.
 180   void Shutdown();
 181   // Disables the exit-time deletion of session-only data.
 182   void SetForceKeepSessionState();
 183
 184  private:
 185   friend class base::RefCountedThreadSafe<DatabaseTracker>;
 186   friend class content::DatabaseTracker_TestHelper_Test;
 187   friend class content::MockDatabaseTracker; // for testing
 188
 189   typedef std::map<std::string, std::set<base::string16> > DatabaseSet;
 190   typedef std::vector<std::pair<net::CompletionCallback, DatabaseSet> >
 191       PendingDeletionCallbacks;
 192   typedef std::map<base::string16, base::File*> FileHandlesMap;
 193   typedef std::map<std::string, base::string16> OriginDirectoriesMap;
 194
 195   class CachedOriginInfo : public OriginInfo {
 196    public:
 197     CachedOriginInfo() : OriginInfo(std::string(), 0) {}
 198     void SetOriginIdentifier(const std::string& origin_identifier) {
 199       origin_identifier_ = origin_identifier;
 200     }
 201     void SetDatabaseSize(const base::string16& database_name, int64 new_size) {
 202       int64 old_size = 0;
 203       if (database_info_.find(database_name) != database_info_.end())
 204         old_size = database_info_[database_name].first;
 205       database_info_[database_name].first = new_size;
 206       if (new_size != old_size)
 207         total_size_ += new_size - old_size;
 208     }
 209     void SetDatabaseDescription(const base::string16& database_name,
 210                                 const base::string16& description) {
 211       database_info_[database_name].second = description;
 212     }
 213   };
 214
 215   // virtual for unit-testing only.
 216   virtual ~DatabaseTracker();
 217
 218   // Deletes the directory that stores all DBs in incognito mode, if it exists.
 219   void DeleteIncognitoDBDirectory();
 220
 221   // Deletes session-only databases. Blocks databases from being created/opened.
 222   void ClearSessionOnlyOrigins();
 223
 224   bool DeleteClosedDatabase(const std::string& origin_identifier,
 225                             const base::string16& database_name);
 226
 227   // Delete all files belonging to the given origin given that no database
 228   // connections within this origin are open, or if |force| is true, delete
 229   // the meta data and rename the associated directory.
 230   bool DeleteOrigin(const std::string& origin_identifier, bool force);
 231   void DeleteDatabaseIfNeeded(const std::string& origin_identifier,
 232                               const base::string16& database_name);
 233
 234   bool LazyInit();
 235   bool UpgradeToCurrentVersion();
 236   void InsertOrUpdateDatabaseDetails(const std::string& origin_identifier,
 237                                      const base::string16& database_name,
 238                                      const base::string16& database_details,
 239                                      int64 estimated_size);
 240
 241   void ClearAllCachedOriginInfo();
 242   CachedOriginInfo* MaybeGetCachedOriginInfo(
 243       const std::string& origin_identifier,
 244       bool create_if_needed);
 245   CachedOriginInfo* GetCachedOriginInfo(
 246       const std::string& origin_identifier) {
 247     return MaybeGetCachedOriginInfo(origin_identifier, true);
 248   }
 249
 250   int64 GetDBFileSize(const std::string& origin_identifier,
 251                       const base::string16& database_name);
 252   int64 SeedOpenDatabaseInfo(const std::string& origin_identifier,
 253                              const base::string16& database_name,
 254                              const base::string16& description);
 255   int64 UpdateOpenDatabaseInfoAndNotify(const std::string& origin_identifier,
 256                                         const base::string16& database_name,
 257                                         const base::string16* opt_description);
 258   int64 UpdateOpenDatabaseSizeAndNotify(const std::string& origin_identifier,
 259                                         const base::string16& database_name) {
 260     return UpdateOpenDatabaseInfoAndNotify(
 261         origin_identifier, database_name, NULL);
 262   }
 263
 264
 265   void ScheduleDatabaseForDeletion(const std::string& origin_identifier,
 266                                    const base::string16& database_name);
 267   // Schedule a set of open databases for deletion. If non-null, callback is
 268   // invoked upon completion.
 269   void ScheduleDatabasesForDeletion(const DatabaseSet& databases,
 270                                     const net::CompletionCallback& callback);
 271
 272   // Returns the directory where all DB files for the given origin are stored.
 273   base::string16 GetOriginDirectory(const std::string& origin_identifier);
 274
 275   bool is_initialized_;
 276   const bool is_incognito_;
 277   bool force_keep_session_state_;
 278   bool shutting_down_;
 279   const base::FilePath profile_path_;
 280   const base::FilePath db_dir_;
 281   scoped_ptr<sql::Connection> db_;
 282   scoped_ptr<DatabasesTable> databases_table_;
 283   scoped_ptr<sql::MetaTable> meta_table_;
 284   ObserverList<Observer, true> observers_;
 285   std::map<std::string, CachedOriginInfo> origins_info_map_;
 286   DatabaseConnections database_connections_;
 287
 288   // The set of databases that should be deleted but are still opened
 289   DatabaseSet dbs_to_be_deleted_;
 290   PendingDeletionCallbacks deletion_callbacks_;
 291
 292   // Apps and Extensions can have special rights.
 293   scoped_refptr<storage::SpecialStoragePolicy> special_storage_policy_;
 294
 295   scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy_;
 296
 297   // The database tracker thread we're supposed to run file IO on.
 298   scoped_refptr<base::MessageLoopProxy> db_tracker_thread_;
 299
 300   // When in incognito mode, store a DELETE_ON_CLOSE handle to each
 301   // main DB and journal file that was accessed. When the incognito profile
 302   // goes away (or when the browser crashes), all these handles will be
 303   // closed, and the files will be deleted.
 304   FileHandlesMap incognito_file_handles_;
 305
 306   // In a non-incognito profile, all DBs in an origin are stored in a directory
 307   // named after the origin. In an incognito profile though, we do not want the
 308   // directory structure to reveal the origins visited by the user (in case the
 309   // browser process crashes and those directories are not deleted). So we use
 310   // this map to assign directory names that do not reveal this information.
 311   OriginDirectoriesMap incognito_origin_directories_;
 312   int incognito_origin_directories_generator_;
 313
 314   FRIEND_TEST_ALL_PREFIXES(DatabaseTracker, TestHelper);
 315 };
 316
 317 }  // namespace storage
 318
 319 #endif  // STORAGE_BROWSER_DATABASE_DATABASE_TRACKER_H_