src/chrome/browser/policy/profile_policy_connector.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.h"
   6
   7 #include <vector>
   8
   9 #include "base/bind.h"
  10 #include "base/logging.h"
  11 #include "chrome/browser/browser_process.h"
  12 #include "components/policy/core/browser/browser_policy_connector.h"
  13 #include "components/policy/core/common/cloud/cloud_policy_core.h"
  14 #include "components/policy/core/common/cloud/cloud_policy_manager.h"
  15 #include "components/policy/core/common/cloud/cloud_policy_store.h"
  16 #include "components/policy/core/common/configuration_policy_provider.h"
  17 #include "components/policy/core/common/forwarding_policy_provider.h"
  18 #include "components/policy/core/common/policy_service_impl.h"
  19 #include "google_apis/gaia/gaia_auth_util.h"
  20
  21 #if defined(OS_CHROMEOS)
  22 #include "chrome/browser/chromeos/login/user.h"
  23 #include "chrome/browser/chromeos/login/user_manager.h"
  24 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
  25 #include "chrome/browser/chromeos/policy/device_cloud_policy_manager_chromeos.h"
  26 #include "chrome/browser/chromeos/policy/device_local_account_policy_provider.h"
  27 #include "chrome/browser/chromeos/policy/login_profile_policy_provider.h"
  28 #endif
  29
  30 namespace policy {
  31
  32 ProfilePolicyConnector::ProfilePolicyConnector()
  33 #if defined(OS_CHROMEOS)
  34     : is_primary_user_(false),
  35       user_cloud_policy_manager_(NULL)
  36 #else
  37     : user_cloud_policy_manager_(NULL)
  38 #endif
  39       {}
  40
  41 ProfilePolicyConnector::~ProfilePolicyConnector() {}
  42
  43 void ProfilePolicyConnector::Init(
  44     bool force_immediate_load,
  45 #if defined(OS_CHROMEOS)
  46     const chromeos::User* user,
  47 #endif
  48     SchemaRegistry* schema_registry,
  49     CloudPolicyManager* user_cloud_policy_manager) {
  50   user_cloud_policy_manager_ = user_cloud_policy_manager;
  51
  52   // |providers| contains a list of the policy providers available for the
  53   // PolicyService of this connector, in decreasing order of priority.
  54   //
  55   // Note: all the providers appended to this vector must eventually become
  56   // initialized for every policy domain, otherwise some subsystems will never
  57   // use the policies exposed by the PolicyService!
  58   // The default ConfigurationPolicyProvider::IsInitializationComplete()
  59   // result is true, so take care if a provider overrides that.
  60   std::vector<ConfigurationPolicyProvider*> providers;
  61
  62 #if defined(OS_CHROMEOS)
  63   BrowserPolicyConnectorChromeOS* connector =
  64       g_browser_process->platform_part()->browser_policy_connector_chromeos();
  65 #else
  66   BrowserPolicyConnector* connector =
  67       g_browser_process->browser_policy_connector();
  68 #endif
  69
  70   if (connector->GetPlatformProvider()) {
  71     forwarding_policy_provider_.reset(
  72         new ForwardingPolicyProvider(connector->GetPlatformProvider()));
  73     forwarding_policy_provider_->Init(schema_registry);
  74     providers.push_back(forwarding_policy_provider_.get());
  75   }
  76
  77 #if defined(OS_CHROMEOS)
  78   if (connector->GetDeviceCloudPolicyManager())
  79     providers.push_back(connector->GetDeviceCloudPolicyManager());
  80 #endif
  81
  82   if (user_cloud_policy_manager)
  83     providers.push_back(user_cloud_policy_manager);
  84
  85 #if defined(OS_CHROMEOS)
  86   if (!user) {
  87     DCHECK(schema_registry);
  88     // This case occurs for the signin profile.
  89     special_user_policy_provider_.reset(
  90         new LoginProfilePolicyProvider(connector->GetPolicyService()));
  91     special_user_policy_provider_->Init(schema_registry);
  92   } else {
  93     // |user| should never be NULL except for the signin profile.
  94     is_primary_user_ = user == chromeos::UserManager::Get()->GetPrimaryUser();
  95     if (user->GetType() == chromeos::User::USER_TYPE_PUBLIC_ACCOUNT) {
  96       InitializeDeviceLocalAccountPolicyProvider(user->email(),
  97                                                  schema_registry);
  98     }
  99   }
 100   if (special_user_policy_provider_)
 101     providers.push_back(special_user_policy_provider_.get());
 102 #endif
 103
 104   policy_service_.reset(new PolicyServiceImpl(providers));
 105
 106 #if defined(OS_CHROMEOS)
 107   if (is_primary_user_) {
 108     if (user_cloud_policy_manager)
 109       connector->SetUserPolicyDelegate(user_cloud_policy_manager);
 110     else if (special_user_policy_provider_)
 111       connector->SetUserPolicyDelegate(special_user_policy_provider_.get());
 112   }
 113 #endif
 114 }
 115
 116 void ProfilePolicyConnector::InitForTesting(scoped_ptr<PolicyService> service) {
 117   policy_service_ = service.Pass();
 118 }
 119
 120 void ProfilePolicyConnector::Shutdown() {
 121 #if defined(OS_CHROMEOS)
 122   BrowserPolicyConnectorChromeOS* connector =
 123       g_browser_process->platform_part()->browser_policy_connector_chromeos();
 124   if (is_primary_user_)
 125     connector->SetUserPolicyDelegate(NULL);
 126   if (special_user_policy_provider_)
 127     special_user_policy_provider_->Shutdown();
 128 #endif
 129   if (forwarding_policy_provider_)
 130     forwarding_policy_provider_->Shutdown();
 131 }
 132
 133 bool ProfilePolicyConnector::IsManaged() const {
 134   return !GetManagementDomain().empty();
 135 }
 136
 137 std::string ProfilePolicyConnector::GetManagementDomain() const {
 138   if (!user_cloud_policy_manager_)
 139     return "";
 140   CloudPolicyStore* store = user_cloud_policy_manager_->core()->store();
 141   if (store && store->is_managed() && store->policy()->has_username())
 142     return gaia::ExtractDomainName(store->policy()->username());
 143   return "";
 144 }
 145
 146 #if defined(OS_CHROMEOS)
 147 void ProfilePolicyConnector::InitializeDeviceLocalAccountPolicyProvider(
 148     const std::string& username,
 149     SchemaRegistry* schema_registry) {
 150   BrowserPolicyConnectorChromeOS* connector =
 151       g_browser_process->platform_part()->browser_policy_connector_chromeos();
 152   DeviceLocalAccountPolicyService* device_local_account_policy_service =
 153       connector->GetDeviceLocalAccountPolicyService();
 154   if (!device_local_account_policy_service)
 155     return;
 156   special_user_policy_provider_.reset(new DeviceLocalAccountPolicyProvider(
 157       username, device_local_account_policy_service));
 158   special_user_policy_provider_->Init(schema_registry);
 159 }
 160 #endif
 161
 162 }  // namespace policy