1 // Copyright 2020 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/federated_learning/floc_id_provider_factory.h"
6 
7 #include "base/memory/singleton.h"
8 #include "chrome/browser/content_settings/cookie_settings_factory.h"
9 #include "chrome/browser/federated_learning/floc_id_provider_impl.h"
10 #include "chrome/browser/federated_learning/floc_remote_permission_service.h"
11 #include "chrome/browser/federated_learning/floc_remote_permission_service_factory.h"
12 #include "chrome/browser/history/history_service_factory.h"
13 #include "chrome/browser/profiles/profile.h"
14 #include "chrome/browser/sync/profile_sync_service_factory.h"
15 #include "chrome/browser/sync/user_event_service_factory.h"
16 #include "components/content_settings/core/browser/cookie_settings.h"
17 #include "components/history/core/browser/history_service.h"
18 #include "components/keyed_service/content/browser_context_dependency_manager.h"
19 #include "components/sync/driver/sync_service.h"
20 #include "components/sync_user_events/user_event_service.h"
21 
22 namespace federated_learning {
23 
24 // static
GetForProfile(Profile * profile)25 FlocIdProvider* FlocIdProviderFactory::GetForProfile(Profile* profile) {
26   return static_cast<FlocIdProvider*>(
27       GetInstance()->GetServiceForBrowserContext(profile, true));
28 }
29 
30 // static
GetInstance()31 FlocIdProviderFactory* FlocIdProviderFactory::GetInstance() {
32   return base::Singleton<FlocIdProviderFactory>::get();
33 }
34 
FlocIdProviderFactory()35 FlocIdProviderFactory::FlocIdProviderFactory()
36     : BrowserContextKeyedServiceFactory(
37           "FlocIdProvider",
38           BrowserContextDependencyManager::GetInstance()) {
39   DependsOn(ProfileSyncServiceFactory::GetInstance());
40   DependsOn(CookieSettingsFactory::GetInstance());
41   DependsOn(FlocRemotePermissionServiceFactory::GetInstance());
42   DependsOn(HistoryServiceFactory::GetInstance());
43   DependsOn(browser_sync::UserEventServiceFactory::GetInstance());
44 }
45 
46 FlocIdProviderFactory::~FlocIdProviderFactory() = default;
47 
BuildServiceInstanceFor(content::BrowserContext * context) const48 KeyedService* FlocIdProviderFactory::BuildServiceInstanceFor(
49     content::BrowserContext* context) const {
50   Profile* profile = Profile::FromBrowserContext(context);
51 
52   syncer::SyncService* sync_service =
53       ProfileSyncServiceFactory::GetForProfile(profile);
54   if (!sync_service)
55     return nullptr;
56 
57   scoped_refptr<content_settings::CookieSettings> cookie_settings =
58       CookieSettingsFactory::GetForProfile(profile);
59   if (!cookie_settings)
60     return nullptr;
61 
62   FlocRemotePermissionService* floc_remote_permission_service =
63       FlocRemotePermissionServiceFactory::GetForProfile(profile);
64   if (!floc_remote_permission_service)
65     return nullptr;
66 
67   history::HistoryService* history_service =
68       HistoryServiceFactory::GetForProfile(profile,
69                                            ServiceAccessType::IMPLICIT_ACCESS);
70   if (!history_service)
71     return nullptr;
72 
73   syncer::UserEventService* user_event_service =
74       browser_sync::UserEventServiceFactory::GetForProfile(profile);
75   if (!user_event_service)
76     return nullptr;
77 
78   return new FlocIdProviderImpl(sync_service, std::move(cookie_settings),
79                                 floc_remote_permission_service, history_service,
80                                 user_event_service);
81 }
82 
83 }  // namespace federated_learning
84