Enable user policy handling through the new cloud policy stack.

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/path_service.h"
 #include "chrome/browser/browser_process.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/policy_service_impl.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/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/net/gaia/gaia_constants.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
@@ skipping 72 matching lines @@
   device_data_store_.reset();
 #endif
 
   // Shutdown user cloud policy.
   if (user_cloud_policy_subsystem_.get())
     user_cloud_policy_subsystem_->Shutdown();
   user_cloud_policy_subsystem_.reset();
   user_policy_token_cache_.reset();
   user_data_store_.reset();
 
-  // Delete the providers while the |handler_list_| is still valid, since
-  // OnProviderGoingAway() can trigger refreshes at the
-  // ConfigurationPolicyPrefStore.
-  recommended_cloud_provider_.reset();
-  managed_cloud_provider_.reset();
-  recommended_platform_provider_.reset();
-  managed_platform_provider_.reset();
+  if (user_cloud_policy_manager_.get())
+    user_cloud_policy_manager_->Shutdown();
+  user_cloud_policy_manager_.reset();
+
+  device_management_service_.reset();
 }
 
 void BrowserPolicyConnector::Init() {
   managed_platform_provider_.reset(CreateManagedPlatformProvider());
   recommended_platform_provider_.reset(CreateRecommendedPlatformProvider());
 
 #if defined(OS_CHROMEOS)
   // The CloudPolicyProvider blocks asynchronous Profile creation until a login
   // is performed. This is used to ensure that the Profile's PrefService sees
   // managed preferences on managed Chrome OS devices. However, this also
   // prevents creation of new Profiles in Desktop Chrome. The implementation of
   // cloud policy on the Desktop requires a refactoring of the cloud provider,
   // but for now it just isn't created.
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kDeviceManagementUrl)) {
-    managed_cloud_provider_.reset(new CloudPolicyProvider(
-        this,
-        GetChromePolicyDefinitionList(),
-        POLICY_LEVEL_MANDATORY));
-    recommended_cloud_provider_.reset(new CloudPolicyProvider(
-        this,
-        GetChromePolicyDefinitionList(),
-        POLICY_LEVEL_RECOMMENDED));
+    device_management_service_.reset(
+        new DeviceManagementService(
+            command_line->GetSwitchValueASCII(switches::kDeviceManagementUrl)));
+    if (!command_line->HasSwitch(switches::kEnableCloudPolicyService)) {
+      managed_cloud_provider_.reset(new CloudPolicyProvider(
+          this,
+          GetChromePolicyDefinitionList(),
+          POLICY_LEVEL_MANDATORY));
+      recommended_cloud_provider_.reset(new CloudPolicyProvider(
+          this,
+          GetChromePolicyDefinitionList(),
+          POLICY_LEVEL_RECOMMENDED));
+    }
   }
 
   InitializeDevicePolicy();
 
   // Create the AppPackUpdater to start updating the cache. It requires the
   // system request context, which isn't available yet; therefore it is
   // created only once the loops are running.
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(base::IgnoreResult(&BrowserPolicyConnector::GetAppPackUpdater),
                  weak_ptr_factory_.GetWeakPtr()));
 #endif
 }
 
 PolicyService* BrowserPolicyConnector::CreatePolicyService(
-    Profile* profile) const {
+    Profile* profile) {
   // |providers| in decreasing order of priority.
   PolicyServiceImpl::Providers providers;
   if (managed_platform_provider_.get())
     providers.push_back(managed_platform_provider_.get());
   if (managed_cloud_provider_.get())
     providers.push_back(managed_cloud_provider_.get());
   if (recommended_platform_provider_.get())
     providers.push_back(recommended_platform_provider_.get());
   if (recommended_cloud_provider_.get())
     providers.push_back(recommended_cloud_provider_.get());
+
+  // The global policy service uses the proxy provider to allow for swapping in
+  // user policy after startup, while profiles use |user_cloud_policy_manager_|
+  // directly as their provider, which may also block initialization on a policy
+  // fetch at login time.
+  if (profile) {
+    if (user_cloud_policy_manager_.get())
+      providers.push_back(user_cloud_policy_manager_.get());
+  } else {
+    providers.push_back(&user_cloud_policy_provider_);
+  }
+
   return new PolicyServiceImpl(providers);
 }
 
 void BrowserPolicyConnector::RegisterForDevicePolicy(
     const std::string& owner_email,
     const std::string& token,
     bool known_machine_id) {
 #if defined(OS_CHROMEOS)
   if (device_data_store_.get()) {
     if (!device_data_store_->device_token().empty()) {
@@ skipping 78 matching lines @@
 #if defined(OS_CHROMEOS)
   if (device_cloud_policy_subsystem_.get())
     device_cloud_policy_subsystem_->RefreshPolicies(false);
   if (user_cloud_policy_subsystem_.get())
     user_cloud_policy_subsystem_->RefreshPolicies(true);  // wait_for_auth_token
 #endif
 }
 
 void BrowserPolicyConnector::ScheduleServiceInitialization(
     int64 delay_milliseconds) {
+  if (device_management_service_.get())
+    device_management_service_->ScheduleInitialization(delay_milliseconds);
   if (user_cloud_policy_subsystem_.get()) {
     user_cloud_policy_subsystem_->
         ScheduleServiceInitialization(delay_milliseconds);
   }
 #if defined(OS_CHROMEOS)
   if (device_cloud_policy_subsystem_.get()) {
     device_cloud_policy_subsystem_->
         ScheduleServiceInitialization(delay_milliseconds);
   }
 #endif
 }
 void BrowserPolicyConnector::InitializeUserPolicy(
     const std::string& user_name,
     bool wait_for_policy_fetch) {
   // Throw away the old backend.
+  user_cloud_policy_manager_.reset();
+
   user_cloud_policy_subsystem_.reset();
   user_policy_token_cache_.reset();
   user_data_store_.reset();
   token_service_ = NULL;
   registrar_.RemoveAll();
 
   CommandLine* command_line = CommandLine::ForCurrentProcess();
 
   if (command_line->HasSwitch(switches::kDeviceManagementUrl)) {
-    user_data_store_.reset(CloudPolicyDataStore::CreateForUserPolicies());
+    int64 startup_delay =
+        wait_for_policy_fetch ? 0 : kServiceInitializationStartupDelay;
 
-    FilePath profile_dir;
-    PathService::Get(chrome::DIR_USER_DATA, &profile_dir);
+    if (command_line->HasSwitch(switches::kEnableCloudPolicyService)) {
 #if defined(OS_CHROMEOS)
-    profile_dir = profile_dir.Append(
-        command_line->GetSwitchValuePath(switches::kLoginProfile));
+      user_cloud_policy_manager_ =
+          UserCloudPolicyManager::Create(wait_for_policy_fetch);
+      user_cloud_policy_manager_->Initialize(g_browser_process->local_state(),
+                                             device_management_service_.get(),
+                                             GetUserAffiliation(user_name));
+      user_cloud_policy_provider_.SetDelegate(user_cloud_policy_manager_.get());
+
+      device_management_service_->ScheduleInitialization(startup_delay);
 #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);
-    CloudPolicyCacheBase* user_policy_cache = NULL;
+    } else {
+      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));
+#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);
+      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,
-            policy_cache_file);
+      user_policy_cache =
+          new CrosUserPolicyCache(
+              chromeos::DBusThreadManager::Get()->GetSessionManagerClient(),
+              user_data_store_.get(),
+              wait_for_policy_fetch,
+              token_cache_file,
+              policy_cache_file);
 #else
-    user_policy_cache = new UserPolicyCache(policy_cache_file,
-                                            wait_for_policy_fetch);
-    user_policy_token_cache_.reset(
-        new UserPolicyTokenCache(user_data_store_.get(), token_cache_file));
+      user_policy_cache = new UserPolicyCache(policy_cache_file,
+                                              wait_for_policy_fetch);
+      user_policy_token_cache_.reset(
+          new UserPolicyTokenCache(user_data_store_.get(), token_cache_file));
 
-    // Initiate the DM-Token load.
-    user_policy_token_cache_->Load();
+      // Initiate the DM-Token load.
+      user_policy_token_cache_->Load();
 #endif
 
-    managed_cloud_provider_->SetUserPolicyCache(user_policy_cache);
-    recommended_cloud_provider_->SetUserPolicyCache(user_policy_cache);
-    user_cloud_policy_subsystem_.reset(new CloudPolicySubsystem(
-        user_data_store_.get(),
-        user_policy_cache));
+      user_cloud_policy_subsystem_.reset(new CloudPolicySubsystem(
+          user_data_store_.get(),
+          user_policy_cache));
 
-    user_data_store_->set_user_name(user_name);
-    user_data_store_->set_user_affiliation(GetUserAffiliation(user_name));
+      user_data_store_->set_user_name(user_name);
+      user_data_store_->set_user_affiliation(GetUserAffiliation(user_name));
 
-    int64 delay =
-        wait_for_policy_fetch ? 0 : kServiceInitializationStartupDelay;
-    user_cloud_policy_subsystem_->CompleteInitialization(
-        prefs::kUserPolicyRefreshRate,
-        delay);
+      user_cloud_policy_subsystem_->CompleteInitialization(
+          prefs::kUserPolicyRefreshRate,
+          startup_delay);
+
+      managed_cloud_provider_->SetUserPolicyCache(user_policy_cache);
+      recommended_cloud_provider_->SetUserPolicyCache(user_policy_cache);
+    }
   }
 }
 
 void BrowserPolicyConnector::SetUserPolicyTokenService(
     TokenService* token_service) {
   token_service_ = token_service;
   registrar_.Add(this,
                  chrome::NOTIFICATION_TOKEN_AVAILABLE,
                  content::Source<TokenService>(token_service_));
 
@@ skipping 11 matching lines @@
     // the user policy cache of this, so that a potential blocked login
     // proceeds without waiting for user policy.
     if (user_cloud_policy_subsystem_.get()) {
       user_cloud_policy_subsystem_->GetCloudPolicyCacheBase()->
           SetFetchingDone();
     }
   } else {
     if (user_data_store_.get())
       user_data_store_->SetOAuthToken(oauth_token);
   }
+  if (user_cloud_policy_manager_.get()) {
+    CloudPolicyService* service =
+        user_cloud_policy_manager_->cloud_policy_service();
+    if (service->client() &&
+        !service->client()->is_registered() &&
+        !oauth_token.empty()) {
+      service->client()->Register(oauth_token);
+    } else {
+      user_cloud_policy_manager_->CancelWaitForPolicyFetch();
+    }
+  }
 }
 
 CloudPolicyDataStore* BrowserPolicyConnector::GetDeviceCloudPolicyDataStore() {
 #if defined(OS_CHROMEOS)
   return device_data_store_.get();
 #else
   return NULL;
 #endif
 }
 
@@ skipping 59 matching lines @@
 }
 
 void BrowserPolicyConnector::InitializeDevicePolicy() {
 #if defined(OS_CHROMEOS)
   // Throw away the old backend.
   device_cloud_policy_subsystem_.reset();
   device_data_store_.reset();
 
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kEnableDevicePolicy)) {
-    device_data_store_.reset(CloudPolicyDataStore::CreateForDevicePolicies());
-    chromeos::CryptohomeLibrary* cryptohome =
-        chromeos::CrosLibrary::Get()->GetCryptohomeLibrary();
-    install_attributes_.reset(new EnterpriseInstallAttributes(cryptohome));
-    DevicePolicyCache* device_policy_cache =
-        new DevicePolicyCache(device_data_store_.get(),
-                              install_attributes_.get());
+    if (command_line->HasSwitch(switches::kEnableCloudPolicyService)) {
+      // TODO(mnissler): Initialize new-style device policy here once it's
+      // implemented.
+    } else {
+      device_data_store_.reset(CloudPolicyDataStore::CreateForDevicePolicies());
+      chromeos::CryptohomeLibrary* cryptohome =
+          chromeos::CrosLibrary::Get()->GetCryptohomeLibrary();
+      install_attributes_.reset(new EnterpriseInstallAttributes(cryptohome));
+      DevicePolicyCache* device_policy_cache =
+          new DevicePolicyCache(device_data_store_.get(),
+                                install_attributes_.get());
 
-    managed_cloud_provider_->SetDevicePolicyCache(device_policy_cache);
-    recommended_cloud_provider_->SetDevicePolicyCache(device_policy_cache);
+      managed_cloud_provider_->SetDevicePolicyCache(device_policy_cache);
+      recommended_cloud_provider_->SetDevicePolicyCache(device_policy_cache);
 
-    device_cloud_policy_subsystem_.reset(new CloudPolicySubsystem(
-        device_data_store_.get(),
-        device_policy_cache));
+      device_cloud_policy_subsystem_.reset(new CloudPolicySubsystem(
+          device_data_store_.get(),
+          device_policy_cache));
 
-    // Initialize the subsystem once the message loops are spinning.
-    MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(&BrowserPolicyConnector::CompleteInitialization,
-                   weak_ptr_factory_.GetWeakPtr()));
+      // Initialize the subsystem once the message loops are spinning.
+      MessageLoop::current()->PostTask(
+          FROM_HERE,
+          base::Bind(&BrowserPolicyConnector::CompleteInitialization,
+                     weak_ptr_factory_.GetWeakPtr()));
+    }
   }
 #endif
 }
 
 void BrowserPolicyConnector::CompleteInitialization() {
 #if defined(OS_CHROMEOS)
   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 @@
         config_dir_path.Append(FILE_PATH_LITERAL("recommended")));
   } else {
     return NULL;
   }
 #else
   return NULL;
 #endif
 }
 
 }  // namespace policy