Implement cloud policy invalidations using the invalidation service framework.

chrome/browser/policy/cloud/cloud_policy_client.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_CLIENT_H_
 #define CHROME_BROWSER_POLICY_CLOUD_CLOUD_POLICY_CLIENT_H_
 
 #include <map>
 #include <set>
 #include <string>
@@ skipping 86 matching lines @@
 
   // Attempts to register with the device management service. Results in a
   // registration change or error notification.
   virtual void Register(
       enterprise_management::DeviceRegisterRequest::Type registration_type,
       const std::string& auth_token,
       const std::string& client_id,
       bool is_auto_enrollment,
       const std::string& requisition);
 
+  // Sets information about a policy invalidation. Subsequent fetch operations
+  // will use the given info, and callers can use fetched_invalidation_version
+  // to determine which version of policy was fetched.
+  void SetInvalidationInfo(int64 version, const std::string& payload);
+
   // Requests a policy fetch. The client being registered is a prerequisite to
   // this operation and this call will CHECK if the client is not in registered
   // state. FetchPolicy() triggers a policy fetch from the cloud. A policy
   // change notification is reported to the observers and the new policy blob
   // can be retrieved once the policy fetch operation completes. In case of
   // multiple requests to fetch policy, new requests will cancel any pending
   // requests and the latest request will eventually trigger notifications.
   virtual void FetchPolicy();
 
   // Requests OAuth2 auth codes for the device robot account. The client being
@@ skipping 62 matching lines @@
       const PolicyNamespaceKey& policy_ns_key) const;
 
   DeviceManagementStatus status() const {
     return status_;
   }
 
   const std::string& robot_api_auth_code() const {
     return robot_api_auth_code_;
   }
 
+  // Returns the invalidation version that was used for the last FetchPolicy.
+  // Observers can call this method from their OnPolicyFetched method to
+  // determine which at which invalidation version the policy was fetched.
+  int64 fetched_invalidation_version() const {
+    return fetched_invalidation_version_;
+  }
+
  protected:
   // A set of PolicyNamespaceKeys to fetch.
   typedef std::set<PolicyNamespaceKey> NamespaceSet;
 
   // Callback for retries of registration requests.
   void OnRetryRegister(DeviceManagementRequestJob* job);
 
   // Callback for registration requests.
   void OnRegisterCompleted(
       DeviceManagementStatus status,
@@ skipping 39 matching lines @@
 
   std::string dm_token_;
   DeviceMode device_mode_;
   std::string client_id_;
   bool submit_machine_id_;
   base::Time last_policy_timestamp_;
   int public_key_version_;
   bool public_key_version_valid_;
   std::string robot_api_auth_code_;
 
+  // Information for the latest policy invalidation received.
+  int64 invalidation_version_;
+  std::string invalidation_payload_;
+
+  // The invalidation version used for the most recent fetch operation.
+  int64 fetched_invalidation_version_;
+
   // Used for issuing requests to the cloud.
   DeviceManagementService* service_;
   scoped_ptr<DeviceManagementRequestJob> request_job_;
 
   // Status upload data is produced by |status_provider_|.
   StatusProvider* status_provider_;
 
   // The policy responses returned by the last policy fetch operation.
   ResponseMap responses_;
   DeviceManagementStatus status_;
 
   ObserverList<Observer, true> observers_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CloudPolicyClient);
 };
 
 }  // namespace policy
 
 #endif  // CHROME_BROWSER_POLICY_CLOUD_CLOUD_POLICY_CLIENT_H_