Update policy backend and testserver for the newest policy protocol

chrome/browser/policy/cloud_policy_cache.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_CLOUD_POLICY_CACHE_H_
 #define CHROME_BROWSER_POLICY_CLOUD_POLICY_CACHE_H_
 
 #include <string>
 
 #include "base/file_path.h"
@@ skipping 34 matching lines @@
   };
 
   explicit CloudPolicyCache(const FilePath& backing_file_path);
   ~CloudPolicyCache();
 
   // Loads policy information from the backing file. Non-existing or erroneous
   // cache files are ignored.
   void LoadFromFile();
 
   // Resets the policy information.
-  void SetPolicy(const em::CloudPolicyResponse& policy);
+  void SetPolicy(const em::PolicyFetchResponse& policy);
   void SetDevicePolicy(const em::DevicePolicyResponse& policy);
 
   ConfigurationPolicyProvider* GetManagedPolicyProvider();
   ConfigurationPolicyProvider* GetRecommendedPolicyProvider();
 
   void SetUnmanaged();
   bool is_unmanaged() const {
     return is_unmanaged_;
   }
 
   // Returns the time at which the policy was last fetched.
   base::Time last_policy_refresh_time() const {
     return last_policy_refresh_time_;
   }
 
+  int64 last_policy_server_timestamp() {
+    return last_policy_server_timestamp_;
+  }
+
   // Returns true if this cache holds (old-style) device policy that should be
   // given preference over (new-style) mandatory/recommended policy.
   bool has_device_policy() const {
     return has_device_policy_;
   }
 
  private:
   class CloudPolicyProvider;
 
   friend class CloudPolicyCacheTest;
   friend class DeviceManagementPolicyCacheTest;
   friend class DeviceManagementPolicyCacheDecodeTest;
 
   // Decodes a CloudPolicyResponse into two (ConfigurationPolicyType -> Value*)
   // maps and a timestamp. Also performs verification, returns NULL if any
   // check fails.
   static bool DecodePolicyResponse(
-      const em::CloudPolicyResponse& policy_response,
+      const em::PolicyFetchResponse& policy_response,
       PolicyMap* mandatory,
       PolicyMap* recommended,
-      base::Time* timestamp);
+      base::Time* timestamp,
+      int64* raw_timestamp);
 
   // Returns true if |certificate_chain| is trusted and a |signature| created
   // from it matches |data|.
   static bool VerifySignature(
       const std::string& signature,
       const std::string& data,
       const RepeatedPtrField<std::string>& certificate_chain);
 
   // Decodes an int64 value. Checks whether the passed value fits the numeric
   // limits of the value representation. Returns a value (ownership is
@@ skipping 25 matching lines @@
   // Whether the the server has indicated this device is unmanaged.
   bool is_unmanaged_;
 
   // Tracks whether the cache currently stores |device_policy_| that should be
   // given preference over |mandatory_policy_| and |recommended_policy_|.
   bool has_device_policy_;
 
   // The time at which the policy was last refreshed.
   base::Time last_policy_refresh_time_;
 
+  // The last timestamp received from the server with policy.
+  int64 last_policy_server_timestamp_;

[Jakob Kummerow, 2011/02/28 11:06:31]

Why do we need this as a separate field? As discussed, please use just
|last_policy_refresh_time_|.

[gfeher, 2011/02/28 12:21:32]

Another reason for using this was that SetUnmanaged() is setting this value to
the current time and we don't want to send that value back to the server.

But now I realize that I can filter is_unamaned_ == true before sending the
value. (And in each case when is_unamanaged_ is possibly set to false, then
last_policy_refresh_time_ is updated with a sensible value.)

In short: Done.

+
   // Policy providers.
   scoped_ptr<ConfigurationPolicyProvider> managed_policy_provider_;
   scoped_ptr<ConfigurationPolicyProvider> recommended_policy_provider_;
 
   // Provider observers that are registered with this cache's providers.
   ObserverList<ConfigurationPolicyProvider::Observer, true> observer_list_;
 
   DISALLOW_COPY_AND_ASSIGN(CloudPolicyCache);
 };
 
 }  // namespace policy
 
 #endif  // CHROME_BROWSER_POLICY_CLOUD_POLICY_CACHE_H_