Home | History | Annotate | Download | only in storage 
      1 // Copyright (c) 2012 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/settings_test_util.h"
      6 
      7 #include "base/files/file_path.h"
      8 #include "chrome/browser/extensions/api/storage/settings_frontend.h"
      9 #include "chrome/browser/extensions/extension_system_factory.h"
     10 #include "chrome/common/extensions/extension.h"
     11 #include "chrome/common/extensions/permissions/permissions_data.h"
     12 
     13 namespace extensions {
     14 
     15 namespace settings_test_util {
     16 
     17 // Intended as a StorageCallback from GetStorage.
     18 static void AssignStorage(ValueStore** dst, ValueStore* src) {
     19   *dst = src;
     20 }
     21 
     22 ValueStore* GetStorage(
     23     const std::string& extension_id,
     24     settings_namespace::Namespace settings_namespace,
     25     SettingsFrontend* frontend) {
     26   ValueStore* storage = NULL;
     27   frontend->RunWithStorage(
     28       extension_id,
     29       settings_namespace,
     30       base::Bind(&AssignStorage, &storage));
     31   base::MessageLoop::current()->RunUntilIdle();
     32   return storage;
     33 }
     34 
     35 ValueStore* GetStorage(
     36     const std::string& extension_id, SettingsFrontend* frontend) {
     37   return GetStorage(extension_id, settings_namespace::SYNC, frontend);
     38 }
     39 
     40 // MockExtensionService
     41 
     42 MockExtensionService::MockExtensionService() {}
     43 
     44 MockExtensionService::~MockExtensionService() {}
     45 
     46 const Extension* MockExtensionService::GetExtensionById(
     47     const std::string& id, bool include_disabled) const {
     48   std::map<std::string, scoped_refptr<Extension> >::const_iterator
     49       maybe_extension = extensions_.find(id);
     50   return maybe_extension == extensions_.end() ?
     51       NULL : maybe_extension->second.get();
     52 }
     53 
     54 void MockExtensionService::AddExtensionWithId(
     55     const std::string& id, Manifest::Type type) {
     56   std::set<std::string> empty_permissions;
     57   AddExtensionWithIdAndPermissions(id, type, empty_permissions);
     58 }
     59 
     60 void MockExtensionService::AddExtensionWithIdAndPermissions(
     61     const std::string& id,
     62     Manifest::Type type,
     63     const std::set<std::string>& permissions_set) {
     64   base::DictionaryValue manifest;
     65   manifest.SetString("name", std::string("Test extension ") + id);
     66   manifest.SetString("version", "1.0");
     67 
     68   scoped_ptr<base::ListValue> permissions(new base::ListValue());
     69   for (std::set<std::string>::const_iterator it = permissions_set.begin();
     70       it != permissions_set.end(); ++it) {
     71     permissions->Append(Value::CreateStringValue(*it));
     72   }
     73   manifest.Set("permissions", permissions.release());
     74 
     75   switch (type) {
     76     case Manifest::TYPE_EXTENSION:
     77       break;
     78 
     79     case Manifest::TYPE_LEGACY_PACKAGED_APP: {
     80       base::DictionaryValue* app = new base::DictionaryValue();
     81       base::DictionaryValue* app_launch = new base::DictionaryValue();
     82       app_launch->SetString("local_path", "fake.html");
     83       app->Set("launch", app_launch);
     84       manifest.Set("app", app);
     85       break;
     86     }
     87 
     88     default:
     89       NOTREACHED();
     90   }
     91 
     92   std::string error;
     93   scoped_refptr<Extension> extension(Extension::Create(
     94       base::FilePath(),
     95       Manifest::INTERNAL,
     96       manifest,
     97       Extension::NO_FLAGS,
     98       id,
     99       &error));
    100   DCHECK(extension.get());
    101   DCHECK(error.empty());
    102   extensions_[id] = extension;
    103 
    104   for (std::set<std::string>::const_iterator it = permissions_set.begin();
    105       it != permissions_set.end(); ++it) {
    106     DCHECK(extension->HasAPIPermission(*it));
    107   }
    108 }
    109 
    110 // MockExtensionSystem
    111 
    112 MockExtensionSystem::MockExtensionSystem(Profile* profile)
    113       : TestExtensionSystem(profile) {}
    114 MockExtensionSystem::~MockExtensionSystem() {}
    115 
    116 EventRouter* MockExtensionSystem::event_router() {
    117   if (!event_router_.get())
    118     event_router_.reset(new EventRouter(profile_, NULL));
    119   return event_router_.get();
    120 }
    121 
    122 ExtensionService* MockExtensionSystem::extension_service() {
    123   ExtensionServiceInterface* as_interface =
    124       static_cast<ExtensionServiceInterface*>(&extension_service_);
    125   return static_cast<ExtensionService*>(as_interface);
    126 }
    127 
    128 BrowserContextKeyedService* BuildMockExtensionSystem(
    129     content::BrowserContext* profile) {
    130   return new MockExtensionSystem(static_cast<Profile*>(profile));
    131 }
    132 
    133 // MockProfile
    134 
    135 MockProfile::MockProfile(const base::FilePath& file_path)
    136     : TestingProfile(file_path) {
    137   ExtensionSystemFactory::GetInstance()->SetTestingFactoryAndUse(this,
    138       &BuildMockExtensionSystem);
    139 }
    140 
    141 MockProfile::~MockProfile() {}
    142 
    143 // ScopedSettingsFactory
    144 
    145 ScopedSettingsStorageFactory::ScopedSettingsStorageFactory() {}
    146 
    147 ScopedSettingsStorageFactory::ScopedSettingsStorageFactory(
    148     const scoped_refptr<SettingsStorageFactory>& delegate)
    149     : delegate_(delegate) {}
    150 
    151 ScopedSettingsStorageFactory::~ScopedSettingsStorageFactory() {}
    152 
    153 void ScopedSettingsStorageFactory::Reset(
    154     const scoped_refptr<SettingsStorageFactory>& delegate) {
    155   delegate_ = delegate;
    156 }
    157 
    158 ValueStore* ScopedSettingsStorageFactory::Create(
    159     const base::FilePath& base_path,
    160     const std::string& extension_id) {
    161   DCHECK(delegate_.get());
    162   return delegate_->Create(base_path, extension_id);
    163 }
    164 
    165 }  // namespace settings_test_util
    166 
    167 }  // namespace extensions
    168