Implement cloud policy invalidations using the invalidation service framework.

chrome/browser/policy/cloud/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_CLOUD_CLOUD_POLICY_MANAGER_H_
 #define CHROME_BROWSER_POLICY_CLOUD_CLOUD_POLICY_MANAGER_H_
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/prefs/pref_member.h"
 #include "chrome/browser/policy/cloud/cloud_policy_constants.h"
 #include "chrome/browser/policy/cloud/cloud_policy_core.h"
+#include "chrome/browser/policy/cloud/cloud_policy_invalidator.h"
 #include "chrome/browser/policy/cloud/cloud_policy_store.h"
 #include "chrome/browser/policy/configuration_policy_provider.h"
 
 namespace policy {
 
 class PolicyBundle;
 
 // CloudPolicyManager is the main switching central between cloud policy and the
 // upper layers of the policy stack. It wires up a CloudPolicyCore to the
 // ConfigurationPolicyProvider interface.
 //
 // This class contains the base functionality, there are subclasses that add
 // functionality specific to user-level and device-level cloud policy, such as
 // blocking on initial user policy fetch or device enrollment.
 class CloudPolicyManager : public ConfigurationPolicyProvider,
-                           public CloudPolicyStore::Observer {
+                           public CloudPolicyStore::Observer,
+                           public CloudPolicyInvalidationHandler {
  public:
   CloudPolicyManager(const PolicyNamespaceKey& policy_ns_key,
                      CloudPolicyStore* cloud_policy_store);
   virtual ~CloudPolicyManager();
 
   CloudPolicyCore* core() { return &core_; }
   const CloudPolicyCore* core() const { return &core_; }
 
   // ConfigurationPolicyProvider:
   virtual void Shutdown() OVERRIDE;
   virtual bool IsInitializationComplete(PolicyDomain domain) const OVERRIDE;
   virtual void RefreshPolicies() OVERRIDE;
 
   // CloudPolicyStore::Observer:
   virtual void OnStoreLoaded(CloudPolicyStore* cloud_policy_store) OVERRIDE;
   virtual void OnStoreError(CloudPolicyStore* cloud_policy_store) OVERRIDE;
 
+  // CloudPolicyInvalidationHandler:
+  virtual void SetInvalidationInfo(
+      int64 version,
+      const std::string& payload) OVERRIDE;
+  virtual void InvalidatePolicy() OVERRIDE;
+  virtual void OnInvalidatorStateChanged(bool invalidations_enabled) OVERRIDE;
+
  protected:
   // Check whether fully initialized and if so, publish policy by calling
   // ConfigurationPolicyStore::UpdatePolicy().
   void CheckAndPublishPolicy();
 
+  // Starts the policy refresh scheduler. This must be called instead of calling
+  // enabling the scheduler on core() directly so that invalidations received
+  // before the refresh scheduler is started are handled correctly.
+  void StartRefreshScheduler();
+
   // Called by CheckAndPublishPolicy() to create a bundle with the current
   // policies.
   virtual scoped_ptr<PolicyBundle> CreatePolicyBundle();
 
   // Convenience accessors to core() components.
   CloudPolicyClient* client() { return core_.client(); }
   const CloudPolicyClient* client() const { return core_.client(); }
   CloudPolicyStore* store() { return core_.store(); }
   const CloudPolicyStore* store() const { return core_.store(); }
   CloudPolicyService* service() { return core_.service(); }
   const CloudPolicyService* service() const { return core_.service(); }
 
  private:
   // Completion handler for policy refresh operations.
   void OnRefreshComplete(bool success);
 
   CloudPolicyCore core_;
 
   // Whether there's a policy refresh operation pending, in which case all
   // policy update notifications are deferred until after it completes.
   bool waiting_for_policy_refresh_;
 
+  // Replays the latest invalidation that occurred before the refresh
+  // scheduler was started. Without storing the information, invalidations
+  // generated before the refresh scheduler started would be lost.
+  CloudPolicyInvalidationReplayer invalidation_replayer_;

[rlarocque, 2013/07/25 19:23:40]

Are you sure this is necessary?  The InvalidationService should buffer
invalidations while waiting for clients to register.  Why not just neglect to
register until you're ready to process the invalidations?

[Steve Condie, 2013/07/26 01:39:25]

With the new way of managing the lifetime of the UserCloudPolicyInvalidator, the
object is created when the profile creation is complete. There is a race
condition between that and the UserCloudPolicyManager being ready to handle the
invalidations, but there is no notification system to indicate when either one
is done, so the invalidator has no way of being alerted when it is time to
register for invalidations.

Joao, do you view the replayer as necessary? In your big comment about the
dependency management you mentioned that CloudPolicyManager would no longer be
able to assume that the refresh scheduler was started when an invalidation was
received, so it seems that you were acknowledging that an invalidation could be
received before the refresh scheduler is started.

[Steve Condie, 2013/07/26 08:47:27]

After thinking about it more, there is a fairly straightforward way I could
coordinate the events in order to delay invalidation registration until the
refresh scheduler is started. I'll upload a better solution in the morning.

+
   DISALLOW_COPY_AND_ASSIGN(CloudPolicyManager);
 };
 
 }  // namespace policy
 
 #endif  // CHROME_BROWSER_POLICY_CLOUD_CLOUD_POLICY_MANAGER_H_