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