Split UserCloudPolicyManager implementation.

chrome/browser/policy/browser_policy_connector.cc

 // Copyright (c) 2012 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 "chrome/browser/policy/browser_policy_connector.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/policy/async_policy_provider.h"
 #include "chrome/browser/policy/cloud_policy_client.h"
 #include "chrome/browser/policy/cloud_policy_provider.h"
 #include "chrome/browser/policy/cloud_policy_service.h"
 #include "chrome/browser/policy/cloud_policy_subsystem.h"
 #include "chrome/browser/policy/configuration_policy_provider.h"
 #include "chrome/browser/policy/device_management_service.h"
 #include "chrome/browser/policy/managed_mode_policy_provider.h"
 #include "chrome/browser/policy/policy_service_impl.h"
 #include "chrome/browser/policy/policy_statistics_collector.h"
-#include "chrome/browser/policy/user_cloud_policy_manager.h"
 #include "chrome/browser/policy/user_policy_cache.h"
 #include "chrome/browser/policy/user_policy_token_cache.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/token_service.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
@@ skipping 19 matching lines @@
 #include "chrome/browser/chromeos/settings/cros_settings_provider.h"
 #include "chrome/browser/chromeos/settings/device_settings_service.h"
 #include "chrome/browser/chromeos/system/statistics_provider.h"
 #include "chrome/browser/chromeos/system/timezone_settings.h"
 #include "chrome/browser/policy/app_pack_updater.h"
 #include "chrome/browser/policy/cros_user_policy_cache.h"
 #include "chrome/browser/policy/device_cloud_policy_manager_chromeos.h"
 #include "chrome/browser/policy/device_cloud_policy_store_chromeos.h"
 #include "chrome/browser/policy/device_policy_cache.h"
 #include "chrome/browser/policy/network_configuration_updater.h"
+#include "chrome/browser/policy/user_cloud_policy_manager_chromeos.h"
+#include "chrome/browser/policy/user_cloud_policy_store_chromeos.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
+#else
+#include "chrome/browser/policy/user_cloud_policy_manager.h"
+#include "chrome/browser/policy/user_cloud_policy_manager_factory.h"
 #endif
 
 using content::BrowserThread;
 
 namespace policy {
 
 namespace {
 
 // Subdirectory in the user's profile for storing user policies.
 const FilePath::CharType kPolicyDir[] = FILE_PATH_LITERAL("Device Management");
@@ skipping 75 matching lines @@
     g_testing_provider->Shutdown();
   // Drop g_testing_provider so that tests executed with --single_process can
   // call SetPolicyProviderForTesting() again. It is still owned by the test.
   g_testing_provider = NULL;
   if (platform_provider_)
     platform_provider_->Shutdown();
   // The |cloud_provider_| must be shut down before destroying the cloud
   // policy subsystems, which own the caches that |cloud_provider_| uses.
   if (cloud_provider_)
     cloud_provider_->Shutdown();
-  user_cloud_policy_provider_.Shutdown();
 
 #if defined(OS_CHROMEOS)
   // Shutdown device cloud policy.
   if (device_cloud_policy_subsystem_)
     device_cloud_policy_subsystem_->Shutdown();
   // The AppPackUpdater may be observing the |device_cloud_policy_subsystem_|.
   // Delete it first.
   app_pack_updater_.reset();
   device_cloud_policy_subsystem_.reset();
   device_data_store_.reset();
 
   if (device_cloud_policy_manager_)
     device_cloud_policy_manager_->Shutdown();
+  if (user_cloud_policy_manager_)
+    user_cloud_policy_manager_->Shutdown();
+  global_user_cloud_policy_provider_.Shutdown();
 #endif
 
   // Shutdown user cloud policy.
   if (user_cloud_policy_subsystem_)
     user_cloud_policy_subsystem_->Shutdown();
   user_cloud_policy_subsystem_.reset();
   user_policy_token_cache_.reset();
   user_data_store_.reset();
 
   device_management_service_.reset();
 }
 
-scoped_ptr<UserCloudPolicyManager>
-    BrowserPolicyConnector::CreateCloudPolicyManager(
-        Profile* profile,
-        bool force_immediate_policy_load) {
-  scoped_ptr<UserCloudPolicyManager> manager;
-  const CommandLine* command_line = CommandLine::ForCurrentProcess();
-  if (command_line->HasSwitch(switches::kEnableCloudPolicyService)) {
-    UserCloudPolicyManager::PolicyInit policy_init =
-        UserCloudPolicyManager::POLICY_INIT_IN_BACKGROUND;
-#if defined(OS_CHROMEOS)
-    // TODO(mnissler): Revisit once Chrome OS gains multi-profiles support.
-    // Don't wait for a policy fetch if there's no logged in user.
-    if (chromeos::UserManager::Get()->IsUserLoggedIn()) {
-      std::string email =
-          chromeos::UserManager::Get()->GetLoggedInUser()->email();
-      if (GetUserAffiliation(email) == USER_AFFILIATION_MANAGED)
-        policy_init = UserCloudPolicyManager::POLICY_INIT_REFRESH_FROM_SERVER;
-    }
-#else
-    // On desktop, there's no way to figure out if a user is logged in yet
-    // because prefs are not yet initialized, and further there's no way to know
-    // if the user is managed. So this code does not request a policy refresh
-    // from the server because that would inhibit startup for non-signed-in
-    // users. This code relies on the fact that a signed-in profile should
-    // already have policy downloaded. If no policy is available
-    // (due to a previous fetch failing), the normal policy refresh mechanism
-    // will cause it to get downloaded eventually.
-    if (force_immediate_policy_load) {
-      // On desktop, profile creation on startup requires that policies get
-      // loaded immediately (the normal asynchronous policy initialization
-      // does not happen because services are initialized before the
-      // MessageLoop runs). So load policy immediately if desired.
-      policy_init = UserCloudPolicyManager::POLICY_INIT_IMMEDIATELY;
-    }
-#endif
-    manager = UserCloudPolicyManager::Create(profile, policy_init);
-  }
-  return manager.Pass();
-}
-
 scoped_ptr<PolicyService> BrowserPolicyConnector::CreatePolicyService(
     Profile* profile) {
   DCHECK(profile);
+  ConfigurationPolicyProvider* user_cloud_policy_provider = NULL;
+#if !defined(OS_CHROMEOS)
+  user_cloud_policy_provider =
+      UserCloudPolicyManagerFactory::GetForProfile(profile);
+#endif
   return CreatePolicyServiceWithProviders(
-      profile->GetUserCloudPolicyManager(),
+      user_cloud_policy_provider,
       profile->GetManagedModePolicyProvider());
 }
 
 PolicyService* BrowserPolicyConnector::GetPolicyService() {
-  if (!policy_service_) {
-    policy_service_ =
-        CreatePolicyServiceWithProviders(&user_cloud_policy_provider_, NULL);
-  }
+  if (!policy_service_)
+    policy_service_ = CreatePolicyServiceWithProviders(NULL, NULL);
   return policy_service_.get();
 }
 
 void BrowserPolicyConnector::RegisterForDevicePolicy(
     const std::string& owner_email,
     const std::string& token,
     bool known_machine_id,
     bool reregister) {
 #if defined(OS_CHROMEOS)
   if (device_data_store_.get()) {
@@ skipping 90 matching lines @@
 
 void BrowserPolicyConnector::InitializeUserPolicy(
     const std::string& user_name,
     bool wait_for_policy_fetch) {
 #if defined(OS_CHROMEOS)
   // If the user is managed then importing certificates from ONC policy is
   // allowed, otherwise it's not. Update this flag once the user has signed in,
   // and before user policy is loaded.
   GetNetworkConfigurationUpdater()->set_allow_web_trust(
       GetUserAffiliation(user_name) == USER_AFFILIATION_MANAGED);
+
+  if (user_cloud_policy_manager_.get()) {
+    global_user_cloud_policy_provider_.SetDelegate(NULL);
+    user_cloud_policy_manager_->Shutdown();
+    user_cloud_policy_manager_.reset();
+  }
 #endif
 
   // Throw away the old backend.
   user_cloud_policy_subsystem_.reset();
   user_policy_token_cache_.reset();
   user_data_store_.reset();
   token_service_ = NULL;
   registrar_.RemoveAll();
 
   CommandLine* command_line = CommandLine::ForCurrentProcess();
 
   int64 startup_delay =
       wait_for_policy_fetch ? 0 : kServiceInitializationStartupDelay;
 
-  if (!command_line->HasSwitch(switches::kEnableCloudPolicyService)) {
-    FilePath profile_dir;
-    PathService::Get(chrome::DIR_USER_DATA, &profile_dir);
+  FilePath profile_dir;
+  PathService::Get(chrome::DIR_USER_DATA, &profile_dir);
 #if defined(OS_CHROMEOS)
-    profile_dir = profile_dir.Append(
-        command_line->GetSwitchValuePath(switches::kLoginProfile));
+  profile_dir = profile_dir.Append(
+      command_line->GetSwitchValuePath(switches::kLoginProfile));
 #endif
-    const FilePath policy_dir = profile_dir.Append(kPolicyDir);
-    const FilePath policy_cache_file = policy_dir.Append(kPolicyCacheFile);
-    const FilePath token_cache_file = policy_dir.Append(kTokenCacheFile);
+  const FilePath policy_dir = profile_dir.Append(kPolicyDir);
+  const FilePath policy_cache_file = policy_dir.Append(kPolicyCacheFile);
+  const FilePath token_cache_file = policy_dir.Append(kTokenCacheFile);
+
+  if (command_line->HasSwitch(switches::kEnableCloudPolicyService)) {
+#if defined(OS_CHROMEOS)
+    scoped_ptr<CloudPolicyStore> store(
+        new UserCloudPolicyStoreChromeOS(
+            chromeos::DBusThreadManager::Get()->GetSessionManagerClient(),
+            policy_cache_file, token_cache_file));
+    user_cloud_policy_manager_.reset(
+        new UserCloudPolicyManagerChromeOS(store.Pass(),
+                                           wait_for_policy_fetch));
+    user_cloud_policy_manager_->Init();
+    user_cloud_policy_manager_->Initialize(g_browser_process->local_state(),
+                                           device_management_service_.get(),
+                                           GetUserAffiliation(user_name));
+    global_user_cloud_policy_provider_.SetDelegate(
+        user_cloud_policy_manager_.get());
+#endif
+  } else {
     CloudPolicyCacheBase* user_policy_cache = NULL;
 
     user_data_store_.reset(CloudPolicyDataStore::CreateForUserPolicies());
 #if defined(OS_CHROMEOS)
     user_policy_cache =
         new CrosUserPolicyCache(
             chromeos::DBusThreadManager::Get()->GetSessionManagerClient(),
             user_data_store_.get(),
             wait_for_policy_fetch,
             token_cache_file,
@@ skipping 175 matching lines @@
 #endif
 }
 
 void BrowserPolicyConnector::CompleteInitialization() {
   if (g_testing_provider)
     g_testing_provider->Init();
   if (platform_provider_)
     platform_provider_->Init();
   if (cloud_provider_)
     cloud_provider_->Init();
-  user_cloud_policy_provider_.Init();
 
 #if defined(OS_CHROMEOS)
+  global_user_cloud_policy_provider_.Init();
 
   // Create the AppPackUpdater to start updating the cache. It requires the
   // system request context, which isn't available in Init(); therefore it is
   // created only once the loops are running.
   GetAppPackUpdater();
 
   if (device_cloud_policy_subsystem_.get()) {
     // Read serial number and machine model. This must be done before we call
     // CompleteInitialization() below such that the serial number is available
     // for re-submission in case we're doing serial number recovery.
@@ skipping 66 matching lines @@
   if (g_testing_provider)
     providers.push_back(g_testing_provider);
   if (platform_provider_)
     providers.push_back(platform_provider_.get());
   if (cloud_provider_)
     providers.push_back(cloud_provider_.get());
 
 #if defined(OS_CHROMEOS)
   if (device_cloud_policy_manager_.get())
     providers.push_back(device_cloud_policy_manager_.get());
+  if (!user_cloud_policy_provider)
+    user_cloud_policy_provider = &global_user_cloud_policy_provider_;
 #endif
 
   if (user_cloud_policy_provider)
     providers.push_back(user_cloud_policy_provider);
   if (managed_mode_policy_provider)
     providers.push_back(managed_mode_policy_provider);
 
   return scoped_ptr<PolicyService>(new PolicyServiceImpl(providers));
 }
 
@@ skipping 16 matching lines @@
     return new AsyncPolicyProvider(loader.Pass());
   } else {
     return NULL;
   }
 #else
   return NULL;
 #endif
 }
 
 }  // namespace policy