chrome/browser/extensions/api/storage/sync_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 "chrome/browser/extensions/api/storage/sync_value_store_cache.h"
   6
   7 #include "base/bind.h"
   8 #include "base/callback.h"
   9 #include "base/files/file_path.h"
  10 #include "base/sequenced_task_runner.h"
  11 #include "chrome/browser/extensions/api/storage/sync_storage_backend.h"
  12 #include "chrome/browser/sync/glue/sync_start_util.h"
  13 #include "content/public/browser/browser_thread.h"
  14 #include "extensions/browser/api/storage/settings_storage_quota_enforcer.h"
  15 #include "extensions/browser/api/storage/storage_frontend.h"
  16 #include "extensions/common/api/storage.h"
  17 #include "extensions/common/constants.h"
  18 #include "extensions/common/extension.h"
  19
  20 using content::BrowserThread;
  21
  22 namespace extensions {
  23
  24 namespace {
  25
  26 // Returns the quota limit for sync storage, taken from the schema in
  27 // extensions/common/api/storage.json.
  28 SettingsStorageQuotaEnforcer::Limits GetSyncQuotaLimits() {
  29   SettingsStorageQuotaEnforcer::Limits limits = {
  30     static_cast<size_t>(core_api::storage::sync::QUOTA_BYTES),
  31     static_cast<size_t>(core_api::storage::sync::QUOTA_BYTES_PER_ITEM),
  32     static_cast<size_t>(core_api::storage::sync::MAX_ITEMS)
  33   };
  34   return limits;
  35 }
  36
  37 }  // namespace
  38
  39 SyncValueStoreCache::SyncValueStoreCache(
  40     const scoped_refptr<SettingsStorageFactory>& factory,
  41     const scoped_refptr<SettingsObserverList>& observers,
  42     const base::FilePath& profile_path)
  43     : initialized_(false) {
  44   DCHECK_CURRENTLY_ON(BrowserThread::UI);
  45
  46   // This post is safe since the destructor can only be invoked from the
  47   // same message loop, and any potential post of a deletion task must come
  48   // after the constructor returns.
  49   BrowserThread::PostTask(
  50       BrowserThread::FILE, FROM_HERE,
  51       base::Bind(&SyncValueStoreCache::InitOnFileThread,
  52                  base::Unretained(this),
  53                  factory, observers, profile_path));
  54 }
  55
  56 SyncValueStoreCache::~SyncValueStoreCache() {
  57   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
  58 }
  59
  60 syncer::SyncableService* SyncValueStoreCache::GetSyncableService(
  61     syncer::ModelType type) const {
  62   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
  63   DCHECK(initialized_);
  64
  65   switch (type) {
  66     case syncer::APP_SETTINGS:
  67       return app_backend_.get();
  68     case syncer::EXTENSION_SETTINGS:
  69       return extension_backend_.get();
  70     default:
  71       NOTREACHED();
  72       return NULL;
  73   }
  74 }
  75
  76 void SyncValueStoreCache::RunWithValueStoreForExtension(
  77     const StorageCallback& callback,
  78     scoped_refptr<const Extension> extension) {
  79   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
  80   DCHECK(initialized_);
  81   SyncStorageBackend* backend =
  82       extension->is_app() ? app_backend_.get() : extension_backend_.get();
  83   callback.Run(backend->GetStorage(extension->id()));
  84 }
  85
  86 void SyncValueStoreCache::DeleteStorageSoon(const std::string& extension_id) {
  87   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
  88   app_backend_->DeleteStorage(extension_id);
  89   extension_backend_->DeleteStorage(extension_id);
  90 }
  91
  92 void SyncValueStoreCache::InitOnFileThread(
  93     const scoped_refptr<SettingsStorageFactory>& factory,
  94     const scoped_refptr<SettingsObserverList>& observers,
  95     const base::FilePath& profile_path) {
  96   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
  97   DCHECK(!initialized_);
  98   app_backend_.reset(new SyncStorageBackend(
  99       factory,
 100       profile_path.AppendASCII(kSyncAppSettingsDirectoryName),
 101       GetSyncQuotaLimits(),
 102       observers,
 103       syncer::APP_SETTINGS,
 104       sync_start_util::GetFlareForSyncableService(profile_path)));
 105   extension_backend_.reset(new SyncStorageBackend(
 106       factory,
 107       profile_path.AppendASCII(kSyncExtensionSettingsDirectoryName),
 108       GetSyncQuotaLimits(),
 109       observers,
 110       syncer::EXTENSION_SETTINGS,
 111       sync_start_util::GetFlareForSyncableService(profile_path)));
 112   initialized_ = true;
 113 }
 114
 115 }  // namespace extensions