| // Copyright 2019 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 "components/keyed_service/core/simple_keyed_service_factory.h" |
| |
| #include "base/bind.h" |
| #include "base/logging.h" |
| #include "base/memory/ptr_util.h" |
| #include "components/keyed_service/core/keyed_service.h" |
| #include "components/keyed_service/core/simple_dependency_manager.h" |
| #include "components/keyed_service/core/simple_factory_key.h" |
| |
| void SimpleKeyedServiceFactory::SetTestingFactory( |
| SimpleFactoryKey* key, |
| TestingFactory testing_factory) { |
| KeyedServiceFactory::TestingFactory wrapped_factory; |
| if (testing_factory) { |
| wrapped_factory = base::BindRepeating( |
| [](const TestingFactory& testing_factory, void* context) { |
| return testing_factory.Run(static_cast<SimpleFactoryKey*>(context)); |
| }, |
| std::move(testing_factory)); |
| } |
| KeyedServiceFactory::SetTestingFactory(key, std::move(wrapped_factory)); |
| } |
| |
| KeyedService* SimpleKeyedServiceFactory::SetTestingFactoryAndUse( |
| SimpleFactoryKey* key, |
| TestingFactory testing_factory) { |
| DCHECK(testing_factory); |
| return KeyedServiceFactory::SetTestingFactoryAndUse( |
| key, |
| base::BindRepeating( |
| [](const TestingFactory& testing_factory, void* context) { |
| return testing_factory.Run(static_cast<SimpleFactoryKey*>(context)); |
| }, |
| std::move(testing_factory))); |
| } |
| |
| SimpleKeyedServiceFactory::SimpleKeyedServiceFactory( |
| const char* name, |
| SimpleDependencyManager* manager) |
| : KeyedServiceFactory(name, manager, SIMPLE) {} |
| |
| SimpleKeyedServiceFactory::~SimpleKeyedServiceFactory() {} |
| |
| KeyedService* SimpleKeyedServiceFactory::GetServiceForKey(SimpleFactoryKey* key, |
| bool create) { |
| DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); |
| |
| return KeyedServiceFactory::GetServiceForContext(key, create); |
| } |
| |
| SimpleFactoryKey* SimpleKeyedServiceFactory::GetKeyToUse( |
| SimpleFactoryKey* key) const { |
| // Safe default for Incognito mode: no service. |
| if (key->IsOffTheRecord()) |
| return nullptr; |
| |
| return key; |
| } |
| |
| void SimpleKeyedServiceFactory::SimpleContextShutdown(SimpleFactoryKey* key) { |
| DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); |
| |
| KeyedServiceFactory::ContextShutdown(key); |
| } |
| |
| void SimpleKeyedServiceFactory::SimpleContextDestroyed(SimpleFactoryKey* key) { |
| DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); |
| |
| KeyedServiceFactory::ContextDestroyed(key); |
| } |
| |
| std::unique_ptr<KeyedService> |
| SimpleKeyedServiceFactory::BuildServiceInstanceFor(void* context) const { |
| return BuildServiceInstanceFor(static_cast<SimpleFactoryKey*>(context)); |
| } |
| |
| bool SimpleKeyedServiceFactory::IsOffTheRecord(void* context) const { |
| return static_cast<SimpleFactoryKey*>(context)->IsOffTheRecord(); |
| } |
| |
| void* SimpleKeyedServiceFactory::GetContextToUse(void* context) const { |
| AssertContextWasntDestroyed(context); |
| return GetKeyToUse(static_cast<SimpleFactoryKey*>(context)); |
| } |
| |
| bool SimpleKeyedServiceFactory::ServiceIsCreatedWithContext() const { |
| return false; |
| } |
| |
| void SimpleKeyedServiceFactory::ContextShutdown(void* context) { |
| SimpleContextShutdown(static_cast<SimpleFactoryKey*>(context)); |
| } |
| |
| void SimpleKeyedServiceFactory::ContextDestroyed(void* context) { |
| SimpleContextDestroyed(static_cast<SimpleFactoryKey*>(context)); |
| } |
| |
| void SimpleKeyedServiceFactory::RegisterPrefs( |
| user_prefs::PrefRegistrySyncable* registry) { |
| RegisterProfilePrefs(registry); |
| } |
| |
| void SimpleKeyedServiceFactory::SetEmptyTestingFactory(void* context) {} |
| |
| bool SimpleKeyedServiceFactory::HasTestingFactory(void* context) { |
| return false; |
| } |
| |
| void SimpleKeyedServiceFactory::CreateServiceNow(void* context) {} |