text: // Copyright (c) 2012 The Chromium Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  
  #include "chrome/browser/extensions/api/storage/settings_test_util.h"
  
  #include "base/files/file_path.h"
  #include "chrome/browser/extensions/api/storage/settings_frontend.h"
  #include "chrome/browser/extensions/extension_system_factory.h"
  #include "chrome/common/extensions/extension.h"
  #include "chrome/common/extensions/permissions/permissions_data.h"
  
  namespace extensions {
  
  namespace settings_test_util {
  
  // Intended as a StorageCallback from GetStorage.
  static void AssignStorage(ValueStore** dst, ValueStore* src) {
    *dst = src;
  }
  
  ValueStore* GetStorage(
      const std::string& extension_id,
      settings_namespace::Namespace settings_namespace,
      SettingsFrontend* frontend) {
    ValueStore* storage = NULL;
    frontend->RunWithStorage(
        extension_id,
        settings_namespace,
        base::Bind(&AssignStorage, &storage));
    base::MessageLoop::current()->RunUntilIdle();
    return storage;
  }
  
  ValueStore* GetStorage(
      const std::string& extension_id, SettingsFrontend* frontend) {
    return GetStorage(extension_id, settings_namespace::SYNC, frontend);
  }
  
  // MockExtensionService
  
  MockExtensionService::MockExtensionService() {}
  
  MockExtensionService::~MockExtensionService() {}
  
  const Extension* MockExtensionService::GetExtensionById(
      const std::string& id, bool include_disabled) const {
    std::map<std::string, scoped_refptr<Extension> >::const_iterator
        maybe_extension = extensions_.find(id);
    return maybe_extension == extensions_.end() ?
        NULL : maybe_extension->second.get();
  }
  
  void MockExtensionService::AddExtensionWithId(
      const std::string& id, Manifest::Type type) {
    std::set<std::string> empty_permissions;
    AddExtensionWithIdAndPermissions(id, type, empty_permissions);
  }
  
  void MockExtensionService::AddExtensionWithIdAndPermissions(
      const std::string& id,
      Manifest::Type type,
      const std::set<std::string>& permissions_set) {
    base::DictionaryValue manifest;
    manifest.SetString("name", std::string("Test extension ") + id);
    manifest.SetString("version", "1.0");
  
    scoped_ptr<base::ListValue> permissions(new base::ListValue());
    for (std::set<std::string>::const_iterator it = permissions_set.begin();
        it != permissions_set.end(); ++it) {
      permissions->Append(new base::StringValue(*it));
    }
    manifest.Set("permissions", permissions.release());
  
    switch (type) {
      case Manifest::TYPE_EXTENSION:
        break;
  
      case Manifest::TYPE_LEGACY_PACKAGED_APP: {
        base::DictionaryValue* app = new base::DictionaryValue();
        base::DictionaryValue* app_launch = new base::DictionaryValue();
        app_launch->SetString("local_path", "fake.html");
        app->Set("launch", app_launch);
        manifest.Set("app", app);
        break;
      }
  
      default:
        NOTREACHED();
    }
  
    std::string error;
    scoped_refptr<Extension> extension(Extension::Create(
        base::FilePath(),
        Manifest::INTERNAL,
        manifest,
        Extension::NO_FLAGS,
        id,
        &error));
    DCHECK(extension.get());
    DCHECK(error.empty());
    extensions_[id] = extension;
  
    for (std::set<std::string>::const_iterator it = permissions_set.begin();
        it != permissions_set.end(); ++it) {
      DCHECK(extension->HasAPIPermission(*it));
    }
  }
  
  // MockExtensionSystem
  
  MockExtensionSystem::MockExtensionSystem(Profile* profile)
        : TestExtensionSystem(profile) {}
  MockExtensionSystem::~MockExtensionSystem() {}
  
  EventRouter* MockExtensionSystem::event_router() {
    if (!event_router_.get())
      event_router_.reset(new EventRouter(profile_, NULL));
    return event_router_.get();
  }
  
  ExtensionService* MockExtensionSystem::extension_service() {
    ExtensionServiceInterface* as_interface =
        static_cast<ExtensionServiceInterface*>(&extension_service_);
    return static_cast<ExtensionService*>(as_interface);
  }
  
  BrowserContextKeyedService* BuildMockExtensionSystem(
      content::BrowserContext* profile) {
    return new MockExtensionSystem(static_cast<Profile*>(profile));
  }
  
  // MockProfile
  
  MockProfile::MockProfile(const base::FilePath& file_path)
      : TestingProfile(file_path) {
    ExtensionSystemFactory::GetInstance()->SetTestingFactoryAndUse(this,
        &BuildMockExtensionSystem);
  }
  
  MockProfile::~MockProfile() {}
  
  // ScopedSettingsFactory
  
  ScopedSettingsStorageFactory::ScopedSettingsStorageFactory() {}
  
  ScopedSettingsStorageFactory::ScopedSettingsStorageFactory(
      const scoped_refptr<SettingsStorageFactory>& delegate)
      : delegate_(delegate) {}
  
  ScopedSettingsStorageFactory::~ScopedSettingsStorageFactory() {}
  
  void ScopedSettingsStorageFactory::Reset(
      const scoped_refptr<SettingsStorageFactory>& delegate) {
    delegate_ = delegate;
  }
  
  ValueStore* ScopedSettingsStorageFactory::Create(
      const base::FilePath& base_path,
      const std::string& extension_id) {
    DCHECK(delegate_.get());
    return delegate_->Create(base_path, extension_id);
  }
  
  }  // namespace settings_test_util
  
  }  // namespace extensions
  