Implement cloud policy invalidations using the invalidation service framework.

chrome/browser/policy/cloud/cloud_policy_refresh_scheduler.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_REFRESH_SCHEDULER_H_
 #define CHROME_BROWSER_POLICY_CLOUD_CLOUD_POLICY_REFRESH_SCHEDULER_H_
 
 #include "base/basictypes.h"
 #include "base/cancelable_callback.h"
 #include "base/memory/ref_counted.h"
@@ skipping 18 matching lines @@
  public:
   // Refresh constants.
   static const int64 kDefaultRefreshDelayMs;
   static const int64 kUnmanagedRefreshDelayMs;
   static const int64 kInitialErrorRetryDelayMs;
 
   // Refresh delay bounds.
   static const int64 kRefreshDelayMinMs;
   static const int64 kRefreshDelayMaxMs;
 
+  // The minimum amount of delay that should occur before the first refresh in
+  // milliseconds. This delay is intended to allow the CloudPolicyInvalidator to
+  // receive policy invalidations before a policy is automatically fetched on
+  // sign-in. The delay is only enforced if policy invalidations are enabled.
+  static const int64 kFirstRefreshDelayMs;
+
   // |client|, |store| and |prefs| pointers must stay valid throughout the
   // lifetime of CloudPolicyRefreshScheduler.
   CloudPolicyRefreshScheduler(
       CloudPolicyClient* client,
       CloudPolicyStore* store,
-      const scoped_refptr<base::SequencedTaskRunner>& task_runner);
+      const scoped_refptr<base::SequencedTaskRunner>& task_runner,
+      bool invalidations_enabled);

[Joao da Silva, 2013/07/23 20:44:47]

As discussed offline, you can revert the changes to this class.

It will have a method to set invalidations enabled/disabled. If they are
disabled from the command line then they should never be enabled from the
outside instead.

[Steve Condie, 2013/07/24 01:42:04]

Done.

   virtual ~CloudPolicyRefreshScheduler();
 
   base::Time last_refresh() const { return last_refresh_; }
   int64 refresh_delay() const { return refresh_delay_ms_; }
 
   // Sets the refresh delay to |refresh_delay| (subject to min/max clamping).
   void SetRefreshDelay(int64 refresh_delay);
 
   // Requests a policy refresh to be performed soon. This may apply throttling,
   // and the request may not be immediately sent.
   void RefreshSoon();
 
+  // Requests a policy refresh to be performed immediately due to a policy
+  // invalidation being received. Unlike RefreshSoon, throttling is not
+  // applied.
+  void RefreshForInvalidation();
+
   // CloudPolicyClient::Observer:
   virtual void OnPolicyFetched(CloudPolicyClient* client) OVERRIDE;
   virtual void OnRegistrationStateChanged(CloudPolicyClient* client) OVERRIDE;
   virtual void OnClientError(CloudPolicyClient* client) OVERRIDE;
 
   // CloudPolicyStore::Observer:
   virtual void OnStoreLoaded(CloudPolicyStore* store) OVERRIDE;
   virtual void OnStoreError(CloudPolicyStore* store) OVERRIDE;
 
   // net::NetworkChangeNotifier::IPAddressObserver:
@@ skipping 35 matching lines @@
 
   // Error retry delay in milliseconds.
   int64 error_retry_delay_ms_;
 
   // The refresh delay.
   int64 refresh_delay_ms_;
 
   // Used to limit the rate at which refreshes are scheduled.
   RateLimiter rate_limiter_;
 
+  // The time at which the first refresh can begin. This is used to introduce a
+  // small delay before a refresh can occur to allow policy invalidations to
+  // occur before automatically refreshing after login.
+  base::Time first_refresh_;
+
   DISALLOW_COPY_AND_ASSIGN(CloudPolicyRefreshScheduler);
 };
 
 }  // namespace policy
 
 #endif  // CHROME_BROWSER_POLICY_CLOUD_CLOUD_POLICY_REFRESH_SCHEDULER_H_