extensions/browser/api/storage/local_value_store_cache.cc

   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
   3 // found in the LICENSE file.
   4
   5 #include "extensions/browser/api/storage/local_value_store_cache.h"
   6
   7 #include <limits>
   8
   9 #include "base/bind.h"
  10 #include "base/callback.h"
  11 #include "base/files/file_path.h"
  12 #include "content/public/browser/browser_thread.h"
  13 #include "extensions/browser/api/storage/settings_storage_factory.h"
  14 #include "extensions/browser/api/storage/settings_storage_quota_enforcer.h"
  15 #include "extensions/browser/api/storage/weak_unlimited_settings_storage.h"
  16 #include "extensions/browser/value_store/value_store.h"
  17 #include "extensions/common/api/storage.h"
  18 #include "extensions/common/constants.h"
  19 #include "extensions/common/extension.h"
  20 #include "extensions/common/permissions/api_permission.h"
  21 #include "extensions/common/permissions/permissions_data.h"
  22
  23 using content::BrowserThread;
  24
  25 namespace extensions {
  26
  27 namespace {
  28
  29 // Returns the quota limit for local storage, taken from the schema in
  30 // extensions/common/api/storage.json.
  31 SettingsStorageQuotaEnforcer::Limits GetLocalQuotaLimits() {
  32   SettingsStorageQuotaEnforcer::Limits limits = {
  33       static_cast<size_t>(api::storage::local::QUOTA_BYTES),
  34       std::numeric_limits<size_t>::max(), std::numeric_limits<size_t>::max()};
  35   return limits;
  36 }
  37
  38 }  // namespace
  39
  40 LocalValueStoreCache::LocalValueStoreCache(
  41     const scoped_refptr<SettingsStorageFactory>& factory,
  42     const base::FilePath& profile_path)
  43     : storage_factory_(factory),
  44       extension_base_path_(
  45           profile_path.AppendASCII(kLocalExtensionSettingsDirectoryName)),
  46       app_base_path_(profile_path.AppendASCII(kLocalAppSettingsDirectoryName)),
  47       quota_(GetLocalQuotaLimits()) {
  48   DCHECK_CURRENTLY_ON(BrowserThread::UI);
  49 }
  50
  51 LocalValueStoreCache::~LocalValueStoreCache() {
  52   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
  53 }
  54
  55 void LocalValueStoreCache::RunWithValueStoreForExtension(
  56     const StorageCallback& callback,
  57     scoped_refptr<const Extension> extension) {
  58   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
  59
  60   ValueStore* storage = GetStorage(extension);
  61
  62   // A neat way to implement unlimited storage; if the extension has the
  63   // unlimited storage permission, force through all calls to Set().
  64   if (extension->permissions_data()->HasAPIPermission(
  65           APIPermission::kUnlimitedStorage)) {
  66     WeakUnlimitedSettingsStorage unlimited_storage(storage);
  67     callback.Run(&unlimited_storage);
  68   } else {
  69     callback.Run(storage);
  70   }
  71 }
  72
  73 void LocalValueStoreCache::DeleteStorageSoon(const std::string& extension_id) {
  74   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
  75   storage_map_.erase(extension_id);
  76   storage_factory_->DeleteDatabaseIfExists(app_base_path_, extension_id);
  77   storage_factory_->DeleteDatabaseIfExists(extension_base_path_, extension_id);
  78 }
  79
  80 ValueStore* LocalValueStoreCache::GetStorage(
  81     scoped_refptr<const Extension> extension) {
  82   StorageMap::iterator iter = storage_map_.find(extension->id());
  83   if (iter != storage_map_.end())
  84     return iter->second.get();
  85
  86   const base::FilePath& file_path =
  87       extension->is_app() ? app_base_path_ : extension_base_path_;
  88   linked_ptr<SettingsStorageQuotaEnforcer> storage(
  89       new SettingsStorageQuotaEnforcer(
  90           quota_, storage_factory_->Create(file_path, extension->id())));
  91   DCHECK(storage.get());
  92
  93   storage_map_[extension->id()] = storage;
  94   return storage.get();
  95 }
  96
  97 }  // namespace extensions