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 116