Update policy backend and testserver for the newest policy protocol

chrome/browser/policy/cloud_policy_cache.cc

 // 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.
 
 #include "chrome/browser/policy/cloud_policy_cache.h"
 
 #include <limits>
 
 #include "base/file_util.h"
 #include "base/logging.h"
@@ skipping 64 matching lines @@
   // Policy level this provider will handle.
   CloudPolicyCache::PolicyLevel level_;
 
   DISALLOW_COPY_AND_ASSIGN(CloudPolicyProvider);
 };
 
 // Saves policy information to a file.
 class PersistPolicyTask : public Task {
  public:
   PersistPolicyTask(const FilePath& path,
-                    const em::CloudPolicyResponse* cloud_policy_response,
+                    const em::PolicyFetchResponse* cloud_policy_response,
                     const em::DevicePolicyResponse* device_policy_response,
                     const bool is_unmanaged)
       : path_(path),
         cloud_policy_response_(cloud_policy_response),
         device_policy_response_(device_policy_response),
         is_unmanaged_(is_unmanaged) {}
 
  private:
   // Task override.
   virtual void Run();
 
   const FilePath path_;
-  scoped_ptr<const em::CloudPolicyResponse> cloud_policy_response_;
+  scoped_ptr<const em::PolicyFetchResponse> cloud_policy_response_;
   scoped_ptr<const em::DevicePolicyResponse> device_policy_response_;
   const bool is_unmanaged_;
 };
 
 void PersistPolicyTask::Run() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   std::string data;
   em::CachedCloudPolicyResponse cached_policy;
   if (cloud_policy_response_.get()) {
     cached_policy.mutable_cloud_policy()->CopyFrom(*cloud_policy_response_);
@@ skipping 16 matching lines @@
     return;
   }
 }
 
 CloudPolicyCache::CloudPolicyCache(
     const FilePath& backing_file_path)
     : backing_file_path_(backing_file_path),
       device_policy_(new DictionaryValue),
       initialization_complete_(false),
       is_unmanaged_(false),
-      has_device_policy_(false) {
+      has_device_policy_(false),
+      last_policy_server_timestamp_(0) {
   managed_policy_provider_.reset(
       new CloudPolicyProvider(
           ConfigurationPolicyPrefStore::GetChromePolicyDefinitionList(),
           this,
           POLICY_LEVEL_MANDATORY));
   recommended_policy_provider_.reset(
       new CloudPolicyProvider(
           ConfigurationPolicyPrefStore::GetChromePolicyDefinitionList(),
           this,
           POLICY_LEVEL_RECOMMENDED));
@@ skipping 19 matching lines @@
     return;
   }
 
   em::CachedCloudPolicyResponse cached_response;
   if (!cached_response.ParseFromArray(data.c_str(), data.size())) {
     LOG(WARNING) << "Failed to parse policy data read from "
                  << backing_file_path_.value();
     return;
   }
   base::Time timestamp;
+  int64 raw_timestamp;
   PolicyMap mandatory_policy;
   PolicyMap recommended_policy;
   is_unmanaged_ = cached_response.unmanaged();
   if (is_unmanaged_ || cached_response.has_device_policy())
     timestamp = base::Time::FromTimeT(cached_response.timestamp());
   if (cached_response.has_cloud_policy()) {
     DCHECK(!is_unmanaged_);
     bool ok = DecodePolicyResponse(cached_response.cloud_policy(),
                                    &mandatory_policy,
                                    &recommended_policy,
-                                   &timestamp);
+                                   &timestamp,
+                                   &raw_timestamp);
     if (!ok) {
       LOG(WARNING) << "Decoding policy data failed.";
       return;
     }
   }
   if (timestamp > base::Time::NowFromSystemTime()) {
     LOG(WARNING) << "Rejected policy data from " << backing_file_path_.value()
                  << ", file is from the future.";
     return;
   }
   // Swap in the new policy information.
   if (cached_response.has_cloud_policy()) {
     mandatory_policy_.Swap(&mandatory_policy);
     recommended_policy_.Swap(&recommended_policy);
+    last_policy_server_timestamp_ = raw_timestamp;
     has_device_policy_ = false;
   } else if (cached_response.has_device_policy()) {
     scoped_ptr<DictionaryValue> value(
         DecodeDevicePolicy(cached_response.device_policy()));
     device_policy_.reset(value.release());
     has_device_policy_ = true;
   }
   last_policy_refresh_time_ = timestamp;
   initialization_complete_ = true;
 
   FOR_EACH_OBSERVER(ConfigurationPolicyProvider::Observer,
                     observer_list_, OnUpdatePolicy());
 }
 
-void CloudPolicyCache::SetPolicy(const em::CloudPolicyResponse& policy) {
+void CloudPolicyCache::SetPolicy(const em::PolicyFetchResponse& policy) {
   DCHECK(CalledOnValidThread());
   bool initialization_was_not_complete = !initialization_complete_;
   is_unmanaged_ = false;
   base::Time timestamp;
+  int64 raw_timestamp;
   PolicyMap mandatory_policy;
   PolicyMap recommended_policy;
   bool ok = DecodePolicyResponse(policy, &mandatory_policy, &recommended_policy,
-                                 &timestamp);
+                                 &timestamp, &raw_timestamp);
   if (!ok)
     return;
 
   const bool new_policy_differs =
       !mandatory_policy_.Equals(mandatory_policy) ||
       !recommended_policy_.Equals(recommended_policy);
   mandatory_policy_.Swap(&mandatory_policy);
   recommended_policy_.Swap(&recommended_policy);
   initialization_complete_ = true;
   last_policy_refresh_time_ = timestamp;
+  last_policy_server_timestamp_ = raw_timestamp;
   has_device_policy_ = false;
 
   if (new_policy_differs || initialization_was_not_complete) {
     FOR_EACH_OBSERVER(ConfigurationPolicyProvider::Observer,
                       observer_list_, OnUpdatePolicy());
   }
 
   if (timestamp > base::Time::NowFromSystemTime() +
                   base::TimeDelta::FromMinutes(1)) {
     LOG(WARNING) << "Server returned policy with timestamp from the future, "
                     "not persisting to disk.";
   } else {
-    em::CloudPolicyResponse* policy_copy = new em::CloudPolicyResponse;
+    em::PolicyFetchResponse* policy_copy = new em::PolicyFetchResponse;
     policy_copy->CopyFrom(policy);
     BrowserThread::PostTask(
         BrowserThread::FILE,
         FROM_HERE,
         new PersistPolicyTask(backing_file_path_, policy_copy, NULL, false));
   }
 }
 
 void CloudPolicyCache::SetDevicePolicy(const em::DevicePolicyResponse& policy) {
   DCHECK(CalledOnValidThread());
@@ skipping 42 matching lines @@
                     observer_list_, OnUpdatePolicy());
 
   BrowserThread::PostTask(
       BrowserThread::FILE,
       FROM_HERE,
       new PersistPolicyTask(backing_file_path_, NULL, NULL, true));
 }
 
 // static
 bool CloudPolicyCache::DecodePolicyResponse(
-    const em::CloudPolicyResponse& policy_response,
+    const em::PolicyFetchResponse& policy_response,
     PolicyMap* mandatory,
     PolicyMap* recommended,
-    base::Time* timestamp) {
-  std::string data = policy_response.signed_response();
+    base::Time* timestamp,
+    int64* raw_timestamp) {
+  std::string data = policy_response.policy_data();
 
-  if (!VerifySignature(policy_response.signature(), data,
+  if (!VerifySignature(policy_response.policy_data_signature(), data,
                        policy_response.certificate_chain())) {
     LOG(WARNING) << "Failed to verify signature.";
     return false;
   }
 
-  em::SignedCloudPolicyResponse response;
-  if (!response.ParseFromArray(data.c_str(), data.size())) {
-    LOG(WARNING) << "Failed to parse SignedCloudPolicyResponse protobuf.";
+  em::PolicyData policy_data;
+  if (!policy_data.ParseFromString(data)) {
+    LOG(WARNING) << "Failed to parse PolicyData protobuf.";
     return false;
   }
 
-  // TODO(jkummerow): Verify response.device_token(). Needs final specification
-  // which token we're actually sending / expecting to get back.
+  // TODO(jkummerow): Verify policy_data.device_token(). Needs final
+  // specification which token we're actually sending / expecting to get back.
 
-  // TODO(jkummerow): Store response.device_name(), if we decide to transfer
+  // TODO(jkummerow): Store policy_data.device_name(), if we decide to transfer
   // it from the server to the client.
 
   DCHECK(timestamp);
-  *timestamp = base::Time::FromTimeT(response.timestamp());
-  DecodePolicy(response.settings(), mandatory, recommended);
+  DCHECK(raw_timestamp);
+  *raw_timestamp = policy_data.timestamp();
+  *timestamp = base::Time::UnixEpoch() +
+               base::TimeDelta::FromMilliseconds(*raw_timestamp);
+  em::CloudPolicySettings policy;
+  if (!policy.ParseFromString(policy_data.policy_value())) {
+    LOG(WARNING) << "Failed to parse CloudPolicySettingsj protobuf.";

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

nit: j?

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

Done.

+    return false;
+  }
+  DecodePolicy(policy, mandatory, recommended);
   return true;
 }
 
 // static
 bool CloudPolicyCache::VerifySignature(
     const std::string& signature,
     const std::string& data,
     const RepeatedPtrField<std::string>& certificate_chain) {
   // TODO(jkummerow): Implement this. Non-trivial because we want to do it
   // for all platforms -> it's enough work to deserve its own CL.
@@ skipping 109 matching lines @@
             CloudPolicyCache::DecodeValue(named_value->value());
         if (decoded_value)
           result->Set(named_value->name(), decoded_value);
       }
     }
   }
   return result;
 }
 
 }  // namespace policy