user_cloud_policy_manager_factory_chromeos.cc revision 90dce4d38c5ff5333bea97d859d4e484e27edf0c
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/chromeos/policy/user_cloud_policy_manager_factory_chromeos.h" 6 7#include "base/command_line.h" 8#include "base/files/file_path.h" 9#include "base/logging.h" 10#include "base/path_service.h" 11#include "chrome/browser/browser_process.h" 12#include "chrome/browser/chromeos/login/user.h" 13#include "chrome/browser/chromeos/login/user_manager.h" 14#include "chrome/browser/chromeos/policy/user_cloud_policy_manager_chromeos.h" 15#include "chrome/browser/chromeos/policy/user_cloud_policy_store_chromeos.h" 16#include "chrome/browser/chromeos/profiles/profile_helper.h" 17#include "chrome/browser/policy/browser_policy_connector.h" 18#include "chrome/browser/policy/cloud/device_management_service.h" 19#include "chrome/browser/policy/cloud/resource_cache.h" 20#include "chrome/browser/profiles/profile.h" 21#include "chrome/common/chrome_switches.h" 22#include "chromeos/chromeos_paths.h" 23#include "chromeos/chromeos_switches.h" 24#include "chromeos/dbus/dbus_thread_manager.h" 25#include "components/browser_context_keyed_service/browser_context_dependency_manager.h" 26#include "net/url_request/url_request_context_getter.h" 27 28namespace policy { 29 30namespace { 31 32// Subdirectory in the user's profile for storing legacy user policies. 33const base::FilePath::CharType kDeviceManagementDir[] = 34 FILE_PATH_LITERAL("Device Management"); 35// File in the above directory for storing legacy user policy dmtokens. 36const base::FilePath::CharType kToken[] = FILE_PATH_LITERAL("Token"); 37// This constant is used to build two different paths. It can be a file inside 38// kDeviceManagementDir where legacy user policy data is stored, and it can be 39// a directory inside the profile directory where other resources are stored. 40const base::FilePath::CharType kPolicy[] = FILE_PATH_LITERAL("Policy"); 41// Directory under kPolicy, in the user's profile dir, where external policy 42// resources are stored. 43const base::FilePath::CharType kResourceDir[] = FILE_PATH_LITERAL("Resources"); 44 45} // namespace 46 47// static 48UserCloudPolicyManagerFactoryChromeOS* 49 UserCloudPolicyManagerFactoryChromeOS::GetInstance() { 50 return Singleton<UserCloudPolicyManagerFactoryChromeOS>::get(); 51} 52 53// static 54UserCloudPolicyManagerChromeOS* 55 UserCloudPolicyManagerFactoryChromeOS::GetForProfile( 56 Profile* profile) { 57 return GetInstance()->GetManagerForProfile(profile); 58} 59 60// static 61scoped_ptr<UserCloudPolicyManagerChromeOS> 62 UserCloudPolicyManagerFactoryChromeOS::CreateForProfile( 63 Profile* profile, 64 bool force_immediate_load) { 65 return GetInstance()->CreateManagerForProfile(profile, force_immediate_load); 66} 67 68UserCloudPolicyManagerFactoryChromeOS::UserCloudPolicyManagerFactoryChromeOS() 69 : BrowserContextKeyedBaseFactory( 70 "UserCloudPolicyManagerChromeOS", 71 BrowserContextDependencyManager::GetInstance()) {} 72 73UserCloudPolicyManagerFactoryChromeOS:: 74 ~UserCloudPolicyManagerFactoryChromeOS() {} 75 76UserCloudPolicyManagerChromeOS* 77 UserCloudPolicyManagerFactoryChromeOS::GetManagerForProfile( 78 Profile* profile) { 79 // Get the manager for the original profile, since the PolicyService is 80 // also shared between the incognito Profile and the original Profile. 81 ManagerMap::const_iterator it = managers_.find(profile->GetOriginalProfile()); 82 return it != managers_.end() ? it->second : NULL; 83} 84 85scoped_ptr<UserCloudPolicyManagerChromeOS> 86 UserCloudPolicyManagerFactoryChromeOS::CreateManagerForProfile( 87 Profile* profile, 88 bool force_immediate_load) { 89 const CommandLine* command_line = CommandLine::ForCurrentProcess(); 90 // Don't initialize cloud policy for the signin profile. 91 if (chromeos::ProfileHelper::IsSigninProfile(profile)) 92 return scoped_ptr<UserCloudPolicyManagerChromeOS>(); 93 94 // |user| should never be NULL except for the signin profile. This object is 95 // created as part of the Profile creation, which happens right after 96 // sign-in. The just-signed-in User is the active user during that time. 97 chromeos::UserManager* user_manager = chromeos::UserManager::Get(); 98 chromeos::User* user = user_manager->GetActiveUser(); 99 CHECK(user); 100 101 // Only USER_TYPE_REGULAR users have user cloud policy. 102 // USER_TYPE_RETAIL_MODE, USER_TYPE_KIOSK_APP and USER_TYPE_GUEST are not 103 // signed in and can't authenticate the policy registration. 104 // USER_TYPE_PUBLIC_ACCOUNT gets its policy from the 105 // DeviceLocalAccountPolicyService. 106 // USER_TYPE_LOCALLY_MANAGED gets its policy from the 107 // ManagedModePolicyProvider. 108 const std::string& username = user->email(); 109 if (user->GetType() != chromeos::User::USER_TYPE_REGULAR || 110 BrowserPolicyConnector::IsNonEnterpriseUser(username)) { 111 return scoped_ptr<UserCloudPolicyManagerChromeOS>(); 112 } 113 114 BrowserPolicyConnector* connector = 115 g_browser_process->browser_policy_connector(); 116 UserAffiliation affiliation = connector->GetUserAffiliation(username); 117 const bool is_managed_user = affiliation == USER_AFFILIATION_MANAGED; 118 const bool is_browser_restart = 119 command_line->HasSwitch(chromeos::switches::kLoginUser) && 120 !command_line->HasSwitch(chromeos::switches::kLoginPassword); 121 const bool wait_for_initial_policy = is_managed_user && !is_browser_restart; 122 123 DeviceManagementService* device_management_service = 124 connector->device_management_service(); 125 if (wait_for_initial_policy) 126 device_management_service->ScheduleInitialization(0); 127 128 base::FilePath profile_dir = profile->GetPath(); 129 const base::FilePath legacy_dir = profile_dir.Append(kDeviceManagementDir); 130 const base::FilePath policy_cache_file = legacy_dir.Append(kPolicy); 131 const base::FilePath token_cache_file = legacy_dir.Append(kToken); 132 const base::FilePath resource_cache_dir = 133 profile_dir.Append(kPolicy).Append(kResourceDir); 134 base::FilePath policy_key_dir; 135 CHECK(PathService::Get(chromeos::DIR_USER_POLICY_KEYS, &policy_key_dir)); 136 137 scoped_ptr<CloudPolicyStore> store( 138 new UserCloudPolicyStoreChromeOS( 139 chromeos::DBusThreadManager::Get()->GetCryptohomeClient(), 140 chromeos::DBusThreadManager::Get()->GetSessionManagerClient(), 141 username, policy_key_dir, token_cache_file, policy_cache_file)); 142 scoped_ptr<ResourceCache> resource_cache; 143 if (command_line->HasSwitch(switches::kEnableComponentCloudPolicy)) 144 resource_cache.reset(new ResourceCache(resource_cache_dir)); 145 scoped_ptr<UserCloudPolicyManagerChromeOS> manager( 146 new UserCloudPolicyManagerChromeOS(store.Pass(), 147 resource_cache.Pass(), 148 wait_for_initial_policy)); 149 manager->Init(); 150 manager->Connect(g_browser_process->local_state(), 151 device_management_service, 152 g_browser_process->system_request_context(), 153 affiliation); 154 155 DCHECK(managers_.find(profile) == managers_.end()); 156 managers_[profile] = manager.get(); 157 return manager.Pass(); 158} 159 160void UserCloudPolicyManagerFactoryChromeOS::BrowserContextShutdown( 161 content::BrowserContext* context) { 162 Profile* profile = static_cast<Profile*>(context); 163 if (profile->IsOffTheRecord()) 164 return; 165 UserCloudPolicyManagerChromeOS* manager = GetManagerForProfile(profile); 166 if (manager) 167 manager->Shutdown(); 168} 169 170void UserCloudPolicyManagerFactoryChromeOS::BrowserContextDestroyed( 171 content::BrowserContext* context) { 172 Profile* profile = static_cast<Profile*>(context); 173 managers_.erase(profile); 174 BrowserContextKeyedBaseFactory::BrowserContextDestroyed(context); 175} 176 177void UserCloudPolicyManagerFactoryChromeOS::SetEmptyTestingFactory( 178 content::BrowserContext* context) {} 179 180void UserCloudPolicyManagerFactoryChromeOS::CreateServiceNow( 181 content::BrowserContext* context) {} 182 183} // namespace policy 184