Move user cloud policy to BrowserProcess.

chrome/browser/policy/browser_policy_connector.h

 // Copyright (c) 2011 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.
 
 #ifndef CHROME_BROWSER_POLICY_BROWSER_POLICY_CONNECTOR_H_
 #define CHROME_BROWSER_POLICY_BROWSER_POLICY_CONNECTOR_H_
 #pragma once
 
 #include <string>
 
 #include "base/basictypes.h"
+#include "base/file_util.h"

[Mattias Nissler (ping if slow), 2011/06/09 14:36:26]

no need for this include.

[sfeuz, 2011/06/13 06:53:53]

Need it for FilePath.

 #include "base/memory/scoped_ptr.h"
 #include "base/task.h"
 #include "chrome/browser/policy/enterprise_install_attributes.h"
+#include "content/common/notification_observer.h"
+#include "content/common/notification_registrar.h"
 
 class PrefService;
 class TestingBrowserProcess;
 class TokenService;
 
-namespace net {
-class URLRequestContextGetter;
-}
-
 namespace policy {
 
+class CloudPolicyProvider;
 class CloudPolicySubsystem;
 class ConfigurationPolicyProvider;
+class UserPolicyIdentityStrategy;
+
+#if defined(OS_CHROMEOS)
 class DevicePolicyIdentityStrategy;
+#endif
 
 // Manages the lifecycle of browser-global policy infrastructure, such as the
-// platform policy providers.
-class BrowserPolicyConnector {
+// platform policy providers, device- and the user-cloud policy infrastructure.
+class BrowserPolicyConnector : public NotificationObserver {
  public:
   static BrowserPolicyConnector* Create();
-  ~BrowserPolicyConnector();
+  virtual ~BrowserPolicyConnector();
 
   ConfigurationPolicyProvider* GetManagedPlatformProvider() const;
   ConfigurationPolicyProvider* GetManagedCloudProvider() const;
   ConfigurationPolicyProvider* GetRecommendedPlatformProvider() const;
   ConfigurationPolicyProvider* GetRecommendedCloudProvider() const;
 
-  // Returns a weak pointer to the CloudPolicySubsystem managed by this
-  // policy connector, or NULL if no such subsystem exists (i.e. when running
-  // outside ChromeOS).
-  CloudPolicySubsystem* cloud_policy_subsystem() {
-    return cloud_policy_subsystem_.get();
+  // Returns a weak pointer to the CloudPolicySubsystem corresponding to the
+  // device policy managed by this policy connector, or NULL if no such
+  // subsystem exists (i.e. when running outside ChromeOS).
+  CloudPolicySubsystem* device_cloud_policy_subsystem() {
+#if defined(OS_CHROMEOS)
+    return device_cloud_policy_subsystem_.get();
+#else
+    return NULL;
+#endif
+  }
+
+  // Returns a weak pointer to the CloudPolicySubsystem corresponding to the
+  // user policy managed by this policy connector, or NULL if no such
+  // subsystem exists (i.e. when user cloud policy is not active due to
+  // unmanaged or not logged in).
+  CloudPolicySubsystem* user_cloud_policy_subsystem() {
+    return user_cloud_policy_subsystem_.get();
   }
 
   // Used to set the credentials stored in the identity strategy associated
   // with this policy connector.
-  void SetCredentials(const std::string& owner_email,
-                      const std::string& gaia_token);
+  void SetDeviceCredentials(const std::string& owner_email,
+                            const std::string& gaia_token);
 
   // Returns true if this device is managed by an enterprise (as opposed to
   // a local owner).
   bool IsEnterpriseManaged();
 
   // Locks the device to an enterprise domain.
   EnterpriseInstallAttributes::LockResult LockDevice(const std::string& user);
 
   // Returns the enterprise domain if device is managed.
   std::string GetEnterpriseDomain();
 
   // Exposes the StopAutoRetry() method of the CloudPolicySubsystem managed
   // by this connector, which can be used to disable automatic
   // retrying behavior.
-  void StopAutoRetry();
+  void DeviceStopAutoRetry();
 
   // Initiates a policy fetch after a successful device registration.
-  void FetchPolicy();
+  void FetchDevicePolicy();
 
-  // Schedules initialization of the policy backend service, if the service is
-  // already constructed.
-  void ScheduleServiceInitialization(int64 delay_milliseconds);
+  // Schedules initialization of the device policy backend service, if the
+  // service is already constructed.
+  void ScheduleDeviceServiceInitialization(int64 delay_milliseconds);
+
+  // Schedules initialization of the user policy backend service, if the
+  // service is already constructed.
+  void ScheduleUserServiceInitialization(int64 delay_milliseconds);

[Mattias Nissler (ping if slow), 2011/06/09 14:36:26]

Maybe we should merge these into one call? After all, the intent is to trigger
any initialization operations that are still pending. Can't the connector just
decide what still needs to be initialized?

[sfeuz, 2011/06/13 06:53:53]

I agree. I think we can just call the ScheduleInit methods of both user- and
device- subsystem everytime. The backend-service keeps track if it already got
initialized and will discard the next requests.
I will check with gfeher, who implemented this part.

+
+  // Initializes the user cloud policy infrasturcture.
+  // TODO(sfeuz): Listen to log-out or going-away messages of TokenService and
+  // reset the backend at that point.
+  void InitializeUserPolicy(std::string& user_name,
+                            const FilePath& policy_dir,
+                            TokenService* token_service);
 
  private:
   friend class ::TestingBrowserProcess;
 
   BrowserPolicyConnector();
 
   static BrowserPolicyConnector* CreateForTests();
   static ConfigurationPolicyProvider* CreateManagedPlatformProvider();
   static ConfigurationPolicyProvider* CreateRecommendedPlatformProvider();
 
-  // Constructor for tests that allows tests to use fake platform policy
-  // providers instead of using the actual ones.
+  // Constructor for tests that allows tests to use fake platform and cloud
+  // policy providers instead of using the actual ones.
   BrowserPolicyConnector(
       ConfigurationPolicyProvider* managed_platform_provider,
-      ConfigurationPolicyProvider* recommended_platform_provider);
+      ConfigurationPolicyProvider* recommended_platform_provider,
+      CloudPolicyProvider* managed_cloud_provider,
+      CloudPolicyProvider* recommended_cloud_provider);
 
-  // Activates the cloud policy subsystem.
-  void Initialize();
+  // NotificationObserver method overrides:
+  virtual void Observe(NotificationType type,
+                       const NotificationSource& source,
+                       const NotificationDetails& details);
+
+  // Initializes the device cloud policy infrasturcture.
+  void InitializeDevicePolicy();
+
+  // Activates the device cloud policy subsystem. Will be delayed.

[Mattias Nissler (ping if slow), 2011/06/09 14:36:26]

"Will be delayed" isn't very helpful to a reader. Why and how?

[sfeuz, 2011/06/13 06:53:53]

Done.

+  void InitializeDevicePolicySubsystem();
 
   scoped_ptr<ConfigurationPolicyProvider> managed_platform_provider_;
   scoped_ptr<ConfigurationPolicyProvider> recommended_platform_provider_;
 
+  scoped_ptr<CloudPolicyProvider> managed_cloud_provider_;
+  scoped_ptr<CloudPolicyProvider> recommended_cloud_provider_;
+
 #if defined(OS_CHROMEOS)
-  scoped_ptr<DevicePolicyIdentityStrategy> identity_strategy_;
+  scoped_ptr<DevicePolicyIdentityStrategy> device_identity_strategy_;
+  scoped_ptr<CloudPolicySubsystem> device_cloud_policy_subsystem_;
   scoped_ptr<EnterpriseInstallAttributes> install_attributes_;
 #endif
-  scoped_ptr<CloudPolicySubsystem> cloud_policy_subsystem_;
+
+  scoped_ptr<UserPolicyIdentityStrategy> user_identity_strategy_;
+  scoped_ptr<CloudPolicySubsystem> user_cloud_policy_subsystem_;
 
   ScopedRunnableMethodFactory<BrowserPolicyConnector> method_factory_;
 
+  // Registers the provider for notification of successful Gaia logins.
+  NotificationRegistrar registrar_;
+
+  // Weak reference to the TokenService we are listening to for user cloud
+  // policy authentication tokens.
+  TokenService* token_service_;
+
   DISALLOW_COPY_AND_ASSIGN(BrowserPolicyConnector);
 };
 
 }  // namespace policy
 
 #endif  // CHROME_BROWSER_POLICY_BROWSER_POLICY_CONNECTOR_H_