Add support for loading user cloud policy on desktop.

chrome/browser/policy/user_cloud_policy_manager.h

 // 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.
 
 #ifndef CHROME_BROWSER_POLICY_USER_CLOUD_POLICY_MANAGER_H_
 #define CHROME_BROWSER_POLICY_USER_CLOUD_POLICY_MANAGER_H_
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "chrome/browser/policy/cloud_policy_client.h"
 #include "chrome/browser/policy/cloud_policy_constants.h"
 #include "chrome/browser/policy/cloud_policy_store.h"
 #include "chrome/browser/policy/configuration_policy_provider.h"
 
 class PrefService;
+class Profile;
 
 namespace policy {
 
 class CloudPolicyRefreshScheduler;
 class CloudPolicyService;
 class DeviceManagementService;
 
 // UserCloudPolicyManager keeps track of all things user policy, drives the
 // corresponding cloud policy service and publishes policy through the
 // ConfigurationPolicyProvider interface.
 class UserCloudPolicyManager : public ConfigurationPolicyProvider,
                                public CloudPolicyClient::Observer,
                                public CloudPolicyStore::Observer {
  public:
   // If |wait_for_policy| fetch is true, IsInitializationComplete() will return
   // false as long as there hasn't been a successful policy fetch.
   UserCloudPolicyManager(scoped_ptr<CloudPolicyStore> store,
                          bool wait_for_policy_fetch);
   virtual ~UserCloudPolicyManager();
 
-#if defined(OS_CHROMEOS)
-  // Creates a UserCloudPolicyService instance for the Chrome OS platform.
-  static scoped_ptr<UserCloudPolicyManager> Create(bool wait_for_policy_fetch);
-#endif
+  // Creates a UserCloudPolicyService instance associated with the passed
+  // |profile|.
+  static scoped_ptr<UserCloudPolicyManager> Create(Profile* profile,
+                                                   bool wait_for_policy_fetch);
 
-  // Initializes the cloud connection. |prefs| and |service| must stay valid
-  // until Shutdown() gets called.
-  void Initialize(PrefService* prefs,
-                  DeviceManagementService* service,
-                  UserAffiliation user_affiliation);
-  void Shutdown();
+  // Initializes the cloud connection. |local_prefs| and |service| must stay
+  // valid until Shutdown() gets called. Virtual for mocking.
+  virtual void Initialize(PrefService* local_prefs,

[Mattias Nissler (ping if slow), 2012/08/03 12:19:08]

Wait, are you passing g_browser_process->local_state() here? That is incorrect
as the Profile PrefService can have different policy than local_state.

[Andrew T Wilson (Slow), 2012/08/04 00:54:41]

As far as I can tell, the only thing local_state is used for is to pull in
kUserPolicyRefreshRate, which lives in the local prefs. Honestly, it probably
would be better to have the refresh rate passed in, rather than plumb the
local_prefs all the way down into CloudPolicyRefreshScheduler. What do you
think?

The prefs accessed by by the CloudPolicyStore are still the profile prefs (they
are pulled directly from the profile in Create()).

[Mattias Nissler (ping if slow), 2012/08/06 08:33:52]

Ah, correct, I was mistaken. FWIW, in the future we might have different refresh
rates for different Profile instances in case each Profile has its own policy.
In that case we'd have to read from the profile PrefService. Nothing to worry
about right now though.

Honestly, it probably
You can do that as well, but then you need an external entity that reacts to
pref changes and updates the value.
 

[Andrew T Wilson (Slow), 2012/08/06 20:30:23]

Hmmm. Good point (or we could ignore policy polling frequency changes until the
next restart). But I agree we're fine for now.

+                          DeviceManagementService* service,
+                          UserAffiliation user_affiliation);
+
+  // Virtual for mocks.
+  virtual void Shutdown();
 
   // Cancels waiting for the policy fetch and flags the
   // ConfigurationPolicyProvider ready (assuming all other initialization tasks
   // have completed).
   void CancelWaitForPolicyFetch();
 
+  // Returns true if the underlying CloudPolicyClient is already registered.
+  // Virtual for mocking.
+  virtual bool IsClientRegistered() const;
+
+  // Register the CloudPolicyClient using the passed OAuth token.
+  void RegisterClient(const std::string& access_token);
+
   CloudPolicyService* cloud_policy_service() { return service_.get(); }
 
   // ConfigurationPolicyProvider:
   virtual bool IsInitializationComplete() const OVERRIDE;
   virtual void RefreshPolicies() OVERRIDE;
 
   // CloudPolicyClient::Observer:
   virtual void OnPolicyFetched(CloudPolicyClient* client) OVERRIDE;
   virtual void OnRegistrationStateChanged(CloudPolicyClient* client) OVERRIDE;
   virtual void OnClientError(CloudPolicyClient* client) OVERRIDE;
@@ skipping 28 matching lines @@
 
   // The pref service to pass to the refresh scheduler on initialization.
   PrefService* prefs_;
 
   DISALLOW_COPY_AND_ASSIGN(UserCloudPolicyManager);
 };
 
 }  // namespace policy
 
 #endif  // CHROME_BROWSER_POLICY_USER_CLOUD_POLICY_MANAGER_H_