chrome/browser/policy/profile_policy_connector_factory.cc

   1 // Copyright (c) 2013 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/policy/profile_policy_connector_factory.h"
   6
   7 #include "base/logging.h"
   8 #include "base/memory/singleton.h"
   9 #include "chrome/browser/policy/profile_policy_connector.h"
  10 #include "chrome/browser/profiles/profile.h"
  11 #include "components/keyed_service/content/browser_context_dependency_manager.h"
  12
  13 #if defined(ENABLE_CONFIGURATION_POLICY)
  14 #include "chrome/browser/policy/schema_registry_service.h"
  15 #include "chrome/browser/policy/schema_registry_service_factory.h"
  16 #if defined(OS_CHROMEOS)
  17 #include "chrome/browser/chromeos/login/users/user.h"
  18 #include "chrome/browser/chromeos/login/users/user_manager.h"
  19 #include "chrome/browser/chromeos/policy/user_cloud_policy_manager_chromeos.h"
  20 #include "chrome/browser/chromeos/policy/user_cloud_policy_manager_factory_chromeos.h"
  21 #include "chrome/browser/chromeos/profiles/profile_helper.h"
  22 #else
  23 #include "chrome/browser/policy/cloud/user_cloud_policy_manager_factory.h"
  24 #include "components/policy/core/common/cloud/user_cloud_policy_manager.h"
  25 #endif
  26 #endif
  27
  28 namespace policy {
  29
  30 // static
  31 ProfilePolicyConnectorFactory* ProfilePolicyConnectorFactory::GetInstance() {
  32   return Singleton<ProfilePolicyConnectorFactory>::get();
  33 }
  34
  35 // static
  36 ProfilePolicyConnector* ProfilePolicyConnectorFactory::GetForProfile(
  37     Profile* profile) {
  38   return GetInstance()->GetForProfileInternal(profile);
  39 }
  40
  41 // static
  42 scoped_ptr<ProfilePolicyConnector>
  43 ProfilePolicyConnectorFactory::CreateForProfile(Profile* profile,
  44                                                 bool force_immediate_load) {
  45   return GetInstance()->CreateForProfileInternal(profile, force_immediate_load);
  46 }
  47
  48 void ProfilePolicyConnectorFactory::SetServiceForTesting(
  49     Profile* profile,
  50     ProfilePolicyConnector* connector) {
  51   ProfilePolicyConnector*& map_entry = connectors_[profile];
  52   CHECK(!map_entry);
  53   map_entry = connector;
  54 }
  55
  56 ProfilePolicyConnectorFactory::ProfilePolicyConnectorFactory()
  57     : BrowserContextKeyedBaseFactory(
  58         "ProfilePolicyConnector",
  59         BrowserContextDependencyManager::GetInstance()) {
  60 #if defined(ENABLE_CONFIGURATION_POLICY)
  61   DependsOn(SchemaRegistryServiceFactory::GetInstance());
  62 #if defined(OS_CHROMEOS)
  63   DependsOn(UserCloudPolicyManagerFactoryChromeOS::GetInstance());
  64 #else
  65   DependsOn(UserCloudPolicyManagerFactory::GetInstance());
  66 #endif
  67 #endif
  68 }
  69
  70 ProfilePolicyConnectorFactory::~ProfilePolicyConnectorFactory() {
  71   DCHECK(connectors_.empty());
  72 }
  73
  74 ProfilePolicyConnector*
  75     ProfilePolicyConnectorFactory::GetForProfileInternal(Profile* profile) {
  76   // Get the connector for the original Profile, so that the incognito Profile
  77   // gets managed settings from the same PolicyService.
  78   ConnectorMap::const_iterator it =
  79       connectors_.find(profile->GetOriginalProfile());
  80   CHECK(it != connectors_.end());
  81   return it->second;
  82 }
  83
  84 scoped_ptr<ProfilePolicyConnector>
  85 ProfilePolicyConnectorFactory::CreateForProfileInternal(
  86     Profile* profile,
  87     bool force_immediate_load) {
  88   DCHECK(connectors_.find(profile) == connectors_.end());
  89
  90   SchemaRegistry* schema_registry = NULL;
  91   CloudPolicyManager* user_cloud_policy_manager = NULL;
  92
  93 #if defined(ENABLE_CONFIGURATION_POLICY)
  94   schema_registry = SchemaRegistryServiceFactory::GetForContext(profile);
  95
  96 #if defined(OS_CHROMEOS)
  97   chromeos::User* user = NULL;
  98   if (!chromeos::ProfileHelper::IsSigninProfile(profile)) {
  99     chromeos::UserManager* user_manager = chromeos::UserManager::Get();
 100     user = user_manager->GetUserByProfile(profile);
 101     CHECK(user);
 102   }
 103   user_cloud_policy_manager =
 104       UserCloudPolicyManagerFactoryChromeOS::GetForProfile(profile);
 105 #else
 106   user_cloud_policy_manager =
 107       UserCloudPolicyManagerFactory::GetForBrowserContext(profile);
 108 #endif  // defined(OS_CHROMEOS)
 109 #endif  // defined(ENABLE_CONFIGURATION_POLICY)
 110
 111   ProfilePolicyConnector* connector = new ProfilePolicyConnector();
 112   connector->Init(force_immediate_load,
 113 #if defined(ENABLE_CONFIGURATION_POLICY) && defined(OS_CHROMEOS)
 114                   user,
 115 #endif
 116                   schema_registry,
 117                   user_cloud_policy_manager);
 118   connectors_[profile] = connector;
 119   return make_scoped_ptr(connector);
 120 }
 121
 122 void ProfilePolicyConnectorFactory::BrowserContextShutdown(
 123     content::BrowserContext* context) {
 124   Profile* profile = static_cast<Profile*>(context);
 125   if (profile->IsOffTheRecord())
 126     return;
 127   ConnectorMap::iterator it = connectors_.find(profile);
 128   if (it != connectors_.end())
 129     it->second->Shutdown();
 130 }
 131
 132 void ProfilePolicyConnectorFactory::BrowserContextDestroyed(
 133     content::BrowserContext* context) {
 134   ConnectorMap::iterator it = connectors_.find(static_cast<Profile*>(context));
 135   if (it != connectors_.end())
 136     connectors_.erase(it);
 137   BrowserContextKeyedBaseFactory::BrowserContextDestroyed(context);
 138 }
 139
 140 void ProfilePolicyConnectorFactory::SetEmptyTestingFactory(
 141     content::BrowserContext* context) {}
 142
 143 void ProfilePolicyConnectorFactory::CreateServiceNow(
 144     content::BrowserContext* context) {}
 145
 146 }  // namespace policy