| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2013 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 WEBKIT_BROWSER_QUOTA_QUOTA_MANAGER_H_ | |
| 6 #define WEBKIT_BROWSER_QUOTA_QUOTA_MANAGER_H_ | |
| 7 | |
| 8 #include <deque> | |
| 9 #include <list> | |
| 10 #include <map> | |
| 11 #include <set> | |
| 12 #include <string> | |
| 13 #include <utility> | |
| 14 #include <vector> | |
| 15 | |
| 16 #include "base/basictypes.h" | |
| 17 #include "base/callback.h" | |
| 18 #include "base/files/file_path.h" | |
| 19 #include "base/memory/ref_counted.h" | |
| 20 #include "base/memory/scoped_ptr.h" | |
| 21 #include "base/memory/weak_ptr.h" | |
| 22 #include "base/sequenced_task_runner_helpers.h" | |
| 23 #include "webkit/browser/quota/quota_callbacks.h" | |
| 24 #include "webkit/browser/quota/quota_client.h" | |
| 25 #include "webkit/browser/quota/quota_database.h" | |
| 26 #include "webkit/browser/quota/quota_task.h" | |
| 27 #include "webkit/browser/quota/special_storage_policy.h" | |
| 28 #include "webkit/browser/quota/storage_observer.h" | |
| 29 #include "webkit/browser/webkit_storage_browser_export.h" | |
| 30 | |
| 31 namespace base { | |
| 32 class FilePath; | |
| 33 class SequencedTaskRunner; | |
| 34 class SingleThreadTaskRunner; | |
| 35 } | |
| 36 | |
| 37 namespace quota_internals { | |
| 38 class QuotaInternalsProxy; | |
| 39 } | |
| 40 | |
| 41 namespace content { | |
| 42 class MockQuotaManager; | |
| 43 class MockStorageClient; | |
| 44 class QuotaManagerTest; | |
| 45 class StorageMonitorTest; | |
| 46 | |
| 47 } | |
| 48 | |
| 49 namespace quota { | |
| 50 | |
| 51 class QuotaDatabase; | |
| 52 class QuotaManagerProxy; | |
| 53 class QuotaTemporaryStorageEvictor; | |
| 54 class StorageMonitor; | |
| 55 class UsageTracker; | |
| 56 | |
| 57 struct QuotaManagerDeleter; | |
| 58 | |
| 59 struct WEBKIT_STORAGE_BROWSER_EXPORT UsageAndQuota { | |
| 60 int64 usage; | |
| 61 int64 global_limited_usage; | |
| 62 int64 quota; | |
| 63 int64 available_disk_space; | |
| 64 | |
| 65 UsageAndQuota(); | |
| 66 UsageAndQuota(int64 usage, | |
| 67 int64 global_limited_usage, | |
| 68 int64 quota, | |
| 69 int64 available_disk_space); | |
| 70 }; | |
| 71 | |
| 72 // An interface called by QuotaTemporaryStorageEvictor. | |
| 73 class WEBKIT_STORAGE_BROWSER_EXPORT QuotaEvictionHandler { | |
| 74 public: | |
| 75 typedef base::Callback<void(const GURL&)> GetLRUOriginCallback; | |
| 76 typedef StatusCallback EvictOriginDataCallback; | |
| 77 typedef base::Callback<void(QuotaStatusCode status, | |
| 78 const UsageAndQuota& usage_and_quota)> | |
| 79 UsageAndQuotaCallback; | |
| 80 | |
| 81 // Returns the least recently used origin. It might return empty | |
| 82 // GURL when there are no evictable origins. | |
| 83 virtual void GetLRUOrigin( | |
| 84 StorageType type, | |
| 85 const GetLRUOriginCallback& callback) = 0; | |
| 86 | |
| 87 virtual void EvictOriginData( | |
| 88 const GURL& origin, | |
| 89 StorageType type, | |
| 90 const EvictOriginDataCallback& callback) = 0; | |
| 91 | |
| 92 virtual void GetUsageAndQuotaForEviction( | |
| 93 const UsageAndQuotaCallback& callback) = 0; | |
| 94 | |
| 95 protected: | |
| 96 virtual ~QuotaEvictionHandler() {} | |
| 97 }; | |
| 98 | |
| 99 struct UsageInfo { | |
| 100 UsageInfo(const std::string& host, StorageType type, int64 usage) | |
| 101 : host(host), | |
| 102 type(type), | |
| 103 usage(usage) {} | |
| 104 std::string host; | |
| 105 StorageType type; | |
| 106 int64 usage; | |
| 107 }; | |
| 108 | |
| 109 // The quota manager class. This class is instantiated per profile and | |
| 110 // held by the profile. With the exception of the constructor and the | |
| 111 // proxy() method, all methods should only be called on the IO thread. | |
| 112 class WEBKIT_STORAGE_BROWSER_EXPORT QuotaManager | |
| 113 : public QuotaTaskObserver, | |
| 114 public QuotaEvictionHandler, | |
| 115 public base::RefCountedThreadSafe<QuotaManager, QuotaManagerDeleter> { | |
| 116 public: | |
| 117 typedef base::Callback<void(QuotaStatusCode, | |
| 118 int64 /* usage */, | |
| 119 int64 /* quota */)> | |
| 120 GetUsageAndQuotaCallback; | |
| 121 | |
| 122 static const int64 kIncognitoDefaultQuotaLimit; | |
| 123 static const int64 kNoLimit; | |
| 124 | |
| 125 QuotaManager(bool is_incognito, | |
| 126 const base::FilePath& profile_path, | |
| 127 base::SingleThreadTaskRunner* io_thread, | |
| 128 base::SequencedTaskRunner* db_thread, | |
| 129 SpecialStoragePolicy* special_storage_policy); | |
| 130 | |
| 131 // Returns a proxy object that can be used on any thread. | |
| 132 QuotaManagerProxy* proxy() { return proxy_.get(); } | |
| 133 | |
| 134 // Called by clients or webapps. Returns usage per host. | |
| 135 void GetUsageInfo(const GetUsageInfoCallback& callback); | |
| 136 | |
| 137 // Called by Web Apps. | |
| 138 // This method is declared as virtual to allow test code to override it. | |
| 139 virtual void GetUsageAndQuotaForWebApps( | |
| 140 const GURL& origin, | |
| 141 StorageType type, | |
| 142 const GetUsageAndQuotaCallback& callback); | |
| 143 | |
| 144 // Called by StorageClients. | |
| 145 // This method is declared as virtual to allow test code to override it. | |
| 146 // | |
| 147 // For UnlimitedStorage origins, this version skips usage and quota handling | |
| 148 // to avoid extra query cost. | |
| 149 // Do not call this method for apps/user-facing code. | |
| 150 virtual void GetUsageAndQuota( | |
| 151 const GURL& origin, | |
| 152 StorageType type, | |
| 153 const GetUsageAndQuotaCallback& callback); | |
| 154 | |
| 155 // Called by clients via proxy. | |
| 156 // Client storage should call this method when storage is accessed. | |
| 157 // Used to maintain LRU ordering. | |
| 158 void NotifyStorageAccessed(QuotaClient::ID client_id, | |
| 159 const GURL& origin, | |
| 160 StorageType type); | |
| 161 | |
| 162 // Called by clients via proxy. | |
| 163 // Client storage must call this method whenever they have made any | |
| 164 // modifications that change the amount of data stored in their storage. | |
| 165 void NotifyStorageModified(QuotaClient::ID client_id, | |
| 166 const GURL& origin, | |
| 167 StorageType type, | |
| 168 int64 delta); | |
| 169 | |
| 170 // Used to avoid evicting origins with open pages. | |
| 171 // A call to NotifyOriginInUse must be balanced by a later call | |
| 172 // to NotifyOriginNoLongerInUse. | |
| 173 void NotifyOriginInUse(const GURL& origin); | |
| 174 void NotifyOriginNoLongerInUse(const GURL& origin); | |
| 175 bool IsOriginInUse(const GURL& origin) const { | |
| 176 return origins_in_use_.find(origin) != origins_in_use_.end(); | |
| 177 } | |
| 178 | |
| 179 void SetUsageCacheEnabled(QuotaClient::ID client_id, | |
| 180 const GURL& origin, | |
| 181 StorageType type, | |
| 182 bool enabled); | |
| 183 | |
| 184 // DeleteOriginData and DeleteHostData (surprisingly enough) delete data of a | |
| 185 // particular StorageType associated with either a specific origin or set of | |
| 186 // origins. Each method additionally requires a |quota_client_mask| which | |
| 187 // specifies the types of QuotaClients to delete from the origin. This is | |
| 188 // specified by the caller as a bitmask built from QuotaClient::IDs. Setting | |
| 189 // the mask to QuotaClient::kAllClientsMask will remove all clients from the | |
| 190 // origin, regardless of type. | |
| 191 virtual void DeleteOriginData(const GURL& origin, | |
| 192 StorageType type, | |
| 193 int quota_client_mask, | |
| 194 const StatusCallback& callback); | |
| 195 void DeleteHostData(const std::string& host, | |
| 196 StorageType type, | |
| 197 int quota_client_mask, | |
| 198 const StatusCallback& callback); | |
| 199 | |
| 200 // Called by UI and internal modules. | |
| 201 void GetAvailableSpace(const AvailableSpaceCallback& callback); | |
| 202 void GetTemporaryGlobalQuota(const QuotaCallback& callback); | |
| 203 | |
| 204 // Ok to call with NULL callback. | |
| 205 void SetTemporaryGlobalOverrideQuota(int64 new_quota, | |
| 206 const QuotaCallback& callback); | |
| 207 | |
| 208 void GetPersistentHostQuota(const std::string& host, | |
| 209 const QuotaCallback& callback); | |
| 210 void SetPersistentHostQuota(const std::string& host, | |
| 211 int64 new_quota, | |
| 212 const QuotaCallback& callback); | |
| 213 void GetGlobalUsage(StorageType type, const GlobalUsageCallback& callback); | |
| 214 void GetHostUsage(const std::string& host, StorageType type, | |
| 215 const UsageCallback& callback); | |
| 216 void GetHostUsage(const std::string& host, StorageType type, | |
| 217 QuotaClient::ID client_id, | |
| 218 const UsageCallback& callback); | |
| 219 | |
| 220 bool IsTrackingHostUsage(StorageType type, QuotaClient::ID client_id) const; | |
| 221 | |
| 222 void GetStatistics(std::map<std::string, std::string>* statistics); | |
| 223 | |
| 224 bool IsStorageUnlimited(const GURL& origin, StorageType type) const; | |
| 225 | |
| 226 bool CanQueryDiskSize(const GURL& origin) const { | |
| 227 return special_storage_policy_.get() && | |
| 228 special_storage_policy_->CanQueryDiskSize(origin); | |
| 229 } | |
| 230 | |
| 231 virtual void GetOriginsModifiedSince(StorageType type, | |
| 232 base::Time modified_since, | |
| 233 const GetOriginsCallback& callback); | |
| 234 | |
| 235 bool ResetUsageTracker(StorageType type); | |
| 236 | |
| 237 // Used to register/deregister observers that wish to monitor storage events. | |
| 238 void AddStorageObserver(StorageObserver* observer, | |
| 239 const StorageObserver::MonitorParams& params); | |
| 240 void RemoveStorageObserver(StorageObserver* observer); | |
| 241 void RemoveStorageObserverForFilter(StorageObserver* observer, | |
| 242 const StorageObserver::Filter& filter); | |
| 243 | |
| 244 // Determines the portion of the temp pool that can be | |
| 245 // utilized by a single host (ie. 5 for 20%). | |
| 246 static const int kPerHostTemporaryPortion; | |
| 247 | |
| 248 static const int64 kPerHostPersistentQuotaLimit; | |
| 249 | |
| 250 static const char kDatabaseName[]; | |
| 251 | |
| 252 static const int kThresholdOfErrorsToBeBlacklisted; | |
| 253 | |
| 254 static const int kEvictionIntervalInMilliSeconds; | |
| 255 | |
| 256 // These are kept non-const so that test code can change the value. | |
| 257 // TODO(kinuko): Make this a real const value and add a proper way to set | |
| 258 // the quota for syncable storage. (http://crbug.com/155488) | |
| 259 static int64 kMinimumPreserveForSystem; | |
| 260 static int64 kSyncableStorageDefaultHostQuota; | |
| 261 | |
| 262 protected: | |
| 263 virtual ~QuotaManager(); | |
| 264 | |
| 265 private: | |
| 266 friend class base::DeleteHelper<QuotaManager>; | |
| 267 friend class base::RefCountedThreadSafe<QuotaManager, QuotaManagerDeleter>; | |
| 268 friend class content::QuotaManagerTest; | |
| 269 friend class content::StorageMonitorTest; | |
| 270 friend class content::MockQuotaManager; | |
| 271 friend class content::MockStorageClient; | |
| 272 friend class quota_internals::QuotaInternalsProxy; | |
| 273 friend class QuotaManagerProxy; | |
| 274 friend class QuotaTemporaryStorageEvictor; | |
| 275 friend struct QuotaManagerDeleter; | |
| 276 | |
| 277 class GetUsageInfoTask; | |
| 278 | |
| 279 class OriginDataDeleter; | |
| 280 class HostDataDeleter; | |
| 281 | |
| 282 class GetModifiedSinceHelper; | |
| 283 class DumpQuotaTableHelper; | |
| 284 class DumpOriginInfoTableHelper; | |
| 285 | |
| 286 typedef QuotaDatabase::QuotaTableEntry QuotaTableEntry; | |
| 287 typedef QuotaDatabase::OriginInfoTableEntry OriginInfoTableEntry; | |
| 288 typedef std::vector<QuotaTableEntry> QuotaTableEntries; | |
| 289 typedef std::vector<OriginInfoTableEntry> OriginInfoTableEntries; | |
| 290 | |
| 291 // Function pointer type used to store the function which returns the | |
| 292 // available disk space for the disk containing the given FilePath. | |
| 293 typedef int64 (*GetAvailableDiskSpaceFn)(const base::FilePath&); | |
| 294 | |
| 295 typedef base::Callback<void(const QuotaTableEntries&)> | |
| 296 DumpQuotaTableCallback; | |
| 297 typedef base::Callback<void(const OriginInfoTableEntries&)> | |
| 298 DumpOriginInfoTableCallback; | |
| 299 | |
| 300 struct EvictionContext { | |
| 301 EvictionContext(); | |
| 302 virtual ~EvictionContext(); | |
| 303 GURL evicted_origin; | |
| 304 StorageType evicted_type; | |
| 305 | |
| 306 EvictOriginDataCallback evict_origin_data_callback; | |
| 307 }; | |
| 308 | |
| 309 typedef QuotaEvictionHandler::UsageAndQuotaCallback | |
| 310 UsageAndQuotaDispatcherCallback; | |
| 311 | |
| 312 // This initialization method is lazily called on the IO thread | |
| 313 // when the first quota manager API is called. | |
| 314 // Initialize must be called after all quota clients are added to the | |
| 315 // manager by RegisterStorage. | |
| 316 void LazyInitialize(); | |
| 317 | |
| 318 // Called by clients via proxy. | |
| 319 // Registers a quota client to the manager. | |
| 320 // The client must remain valid until OnQuotaManagerDestored is called. | |
| 321 void RegisterClient(QuotaClient* client); | |
| 322 | |
| 323 UsageTracker* GetUsageTracker(StorageType type) const; | |
| 324 | |
| 325 // Extract cached origins list from the usage tracker. | |
| 326 // (Might return empty list if no origin is tracked by the tracker.) | |
| 327 void GetCachedOrigins(StorageType type, std::set<GURL>* origins); | |
| 328 | |
| 329 // These internal methods are separately defined mainly for testing. | |
| 330 void NotifyStorageAccessedInternal( | |
| 331 QuotaClient::ID client_id, | |
| 332 const GURL& origin, | |
| 333 StorageType type, | |
| 334 base::Time accessed_time); | |
| 335 void NotifyStorageModifiedInternal( | |
| 336 QuotaClient::ID client_id, | |
| 337 const GURL& origin, | |
| 338 StorageType type, | |
| 339 int64 delta, | |
| 340 base::Time modified_time); | |
| 341 | |
| 342 void DumpQuotaTable(const DumpQuotaTableCallback& callback); | |
| 343 void DumpOriginInfoTable(const DumpOriginInfoTableCallback& callback); | |
| 344 | |
| 345 // Methods for eviction logic. | |
| 346 void StartEviction(); | |
| 347 void DeleteOriginFromDatabase(const GURL& origin, StorageType type); | |
| 348 | |
| 349 void DidOriginDataEvicted(QuotaStatusCode status); | |
| 350 | |
| 351 void ReportHistogram(); | |
| 352 void DidGetTemporaryGlobalUsageForHistogram(int64 usage, | |
| 353 int64 unlimited_usage); | |
| 354 void DidGetPersistentGlobalUsageForHistogram(int64 usage, | |
| 355 int64 unlimited_usage); | |
| 356 | |
| 357 // QuotaEvictionHandler. | |
| 358 virtual void GetLRUOrigin( | |
| 359 StorageType type, | |
| 360 const GetLRUOriginCallback& callback) OVERRIDE; | |
| 361 virtual void EvictOriginData( | |
| 362 const GURL& origin, | |
| 363 StorageType type, | |
| 364 const EvictOriginDataCallback& callback) OVERRIDE; | |
| 365 virtual void GetUsageAndQuotaForEviction( | |
| 366 const UsageAndQuotaCallback& callback) OVERRIDE; | |
| 367 | |
| 368 void DidSetTemporaryGlobalOverrideQuota(const QuotaCallback& callback, | |
| 369 const int64* new_quota, | |
| 370 bool success); | |
| 371 void DidGetPersistentHostQuota(const std::string& host, | |
| 372 const int64* quota, | |
| 373 bool success); | |
| 374 void DidSetPersistentHostQuota(const std::string& host, | |
| 375 const QuotaCallback& callback, | |
| 376 const int64* new_quota, | |
| 377 bool success); | |
| 378 void DidInitialize(int64* temporary_quota_override, | |
| 379 int64* desired_available_space, | |
| 380 bool success); | |
| 381 void DidGetLRUOrigin(const GURL* origin, | |
| 382 bool success); | |
| 383 void DidGetInitialTemporaryGlobalQuota(QuotaStatusCode status, | |
| 384 int64 quota_unused); | |
| 385 void DidInitializeTemporaryOriginsInfo(bool success); | |
| 386 void DidGetAvailableSpace(int64 space); | |
| 387 void DidDatabaseWork(bool success); | |
| 388 | |
| 389 void DeleteOnCorrectThread() const; | |
| 390 | |
| 391 void PostTaskAndReplyWithResultForDBThread( | |
| 392 const tracked_objects::Location& from_here, | |
| 393 const base::Callback<bool(QuotaDatabase*)>& task, | |
| 394 const base::Callback<void(bool)>& reply); | |
| 395 | |
| 396 const bool is_incognito_; | |
| 397 const base::FilePath profile_path_; | |
| 398 | |
| 399 scoped_refptr<QuotaManagerProxy> proxy_; | |
| 400 bool db_disabled_; | |
| 401 bool eviction_disabled_; | |
| 402 scoped_refptr<base::SingleThreadTaskRunner> io_thread_; | |
| 403 scoped_refptr<base::SequencedTaskRunner> db_thread_; | |
| 404 mutable scoped_ptr<QuotaDatabase> database_; | |
| 405 | |
| 406 GetLRUOriginCallback lru_origin_callback_; | |
| 407 std::set<GURL> access_notified_origins_; | |
| 408 | |
| 409 QuotaClientList clients_; | |
| 410 | |
| 411 scoped_ptr<UsageTracker> temporary_usage_tracker_; | |
| 412 scoped_ptr<UsageTracker> persistent_usage_tracker_; | |
| 413 scoped_ptr<UsageTracker> syncable_usage_tracker_; | |
| 414 // TODO(michaeln): Need a way to clear the cache, drop and | |
| 415 // reinstantiate the trackers when they're not handling requests. | |
| 416 | |
| 417 scoped_ptr<QuotaTemporaryStorageEvictor> temporary_storage_evictor_; | |
| 418 EvictionContext eviction_context_; | |
| 419 | |
| 420 ClosureQueue db_initialization_callbacks_; | |
| 421 AvailableSpaceCallbackQueue available_space_callbacks_; | |
| 422 GlobalQuotaCallbackQueue temporary_global_quota_callbacks_; | |
| 423 HostQuotaCallbackMap persistent_host_quota_callbacks_; | |
| 424 | |
| 425 bool temporary_quota_initialized_; | |
| 426 int64 temporary_quota_override_; | |
| 427 | |
| 428 int64 desired_available_space_; | |
| 429 | |
| 430 // Map from origin to count. | |
| 431 std::map<GURL, int> origins_in_use_; | |
| 432 // Map from origin to error count. | |
| 433 std::map<GURL, int> origins_in_error_; | |
| 434 | |
| 435 scoped_refptr<SpecialStoragePolicy> special_storage_policy_; | |
| 436 | |
| 437 base::RepeatingTimer<QuotaManager> histogram_timer_; | |
| 438 | |
| 439 // Pointer to the function used to get the available disk space. This is | |
| 440 // overwritten by QuotaManagerTest in order to attain a deterministic reported | |
| 441 // value. The default value points to base::SysInfo::AmountOfFreeDiskSpace. | |
| 442 GetAvailableDiskSpaceFn get_disk_space_fn_; | |
| 443 | |
| 444 scoped_ptr<StorageMonitor> storage_monitor_; | |
| 445 | |
| 446 base::WeakPtrFactory<QuotaManager> weak_factory_; | |
| 447 | |
| 448 DISALLOW_COPY_AND_ASSIGN(QuotaManager); | |
| 449 }; | |
| 450 | |
| 451 struct QuotaManagerDeleter { | |
| 452 static void Destruct(const QuotaManager* manager) { | |
| 453 manager->DeleteOnCorrectThread(); | |
| 454 } | |
| 455 }; | |
| 456 | |
| 457 } // namespace quota | |
| 458 | |
| 459 #endif // WEBKIT_BROWSER_QUOTA_QUOTA_MANAGER_H_ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 442383002:
Move storage-related files from webkit/ to new top-level directory storage/ (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src