Removed ConfigurationPolicyType and extended PolicyMap.

chrome/browser/policy/user_policy_cache.cc

 // 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.
 
 #include "chrome/browser/policy/user_policy_cache.h"
 
 #include <limits>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "chrome/browser/policy/enterprise_metrics.h"
 #include "chrome/browser/policy/policy_map.h"
 #include "chrome/browser/policy/proto/cloud_policy.pb.h"
 #include "chrome/browser/policy/proto/device_management_local.pb.h"
 #include "chrome/browser/policy/proto/old_generic_format.pb.h"
 #include "policy/configuration_policy_type.h"
 #include "policy/policy_constants.h"
 
 namespace em = enterprise_management;
 
 namespace policy {
 
-// Decodes a CloudPolicySettings object into two maps with mandatory and
-// recommended settings, respectively. The implementation is generated code
-// in policy/cloud_policy_generated.cc.
-void DecodePolicy(const em::CloudPolicySettings& policy,
-                  PolicyMap* mandatory, PolicyMap* recommended);
+// Decodes a CloudPolicySettings object into a PolicyMap. All the policies will
+// be POLICY_SCOPE_USER. The PolicyLevel is decoded from the protobuf.
+// The implementation is generated code in policy/cloud_policy_generated.cc.
+void DecodePolicy(const em::CloudPolicySettings& policy, PolicyMap* map);
 
 UserPolicyCache::UserPolicyCache(const FilePath& backing_file_path,
                                  bool wait_for_policy_fetch)
     : ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)),
       disk_cache_ready_(false),
       fetch_ready_(!wait_for_policy_fetch) {
   disk_cache_ = new UserPolicyDiskCache(weak_ptr_factory_.GetWeakPtr(),
                                         backing_file_path);
 }
 
@@ skipping 58 matching lines @@
         set_last_policy_refresh_time(timestamp);
     }
   }
 
   // Ready to feed policy up the chain!
   disk_cache_ready_ = true;
   CheckIfReady();
 }
 
 bool UserPolicyCache::DecodePolicyData(const em::PolicyData& policy_data,
-                                       PolicyMap* mandatory,
-                                       PolicyMap* recommended) {
+                                       PolicyMap* policies) {
   // TODO(jkummerow): Verify policy_data.device_token(). Needs final
   // specification which token we're actually sending / expecting to get back.
   em::CloudPolicySettings policy;
   if (!policy.ParseFromString(policy_data.policy_value())) {
     LOG(WARNING) << "Failed to parse CloudPolicySettings protobuf.";
     return false;
   }
-  DecodePolicy(policy, mandatory, recommended);
-  MaybeDecodeOldstylePolicy(policy_data.policy_value(), mandatory, recommended);
+  DecodePolicy(policy, policies);
+  MaybeDecodeOldstylePolicy(policy_data.policy_value(), policies);
   return true;
 }
 
 void UserPolicyCache::CheckIfReady() {
   if (!IsReady() && disk_cache_ready_ && fetch_ready_)
     SetReady();
 }
 
 // Everything below is only needed for supporting old-style GenericNamedValue
 // based policy data and can be removed once this support is no longer needed.
 
 using google::protobuf::RepeatedField;
 using google::protobuf::RepeatedPtrField;
 
 void UserPolicyCache::MaybeDecodeOldstylePolicy(
     const std::string& policy_data,
-    PolicyMap* mandatory,
-    PolicyMap* recommended) {
+    PolicyMap* policies) {
   // Return immediately if we already have policy information in the maps.
-  if (!mandatory->empty() || !recommended->empty())
+  if (!policies->empty())
     return;
   em::LegacyChromeSettingsProto policy;
   // Return if the input string doesn't match the protobuf definition.
   if (!policy.ParseFromString(policy_data))
     return;
   // Return if there's no old-style policy to decode.
   if (policy.named_value_size() == 0)
     return;
 
   // Inspect GenericNamedValues and decode them.
   DictionaryValue result;
   RepeatedPtrField<em::GenericNamedValue>::const_iterator named_value;
   for (named_value = policy.named_value().begin();
        named_value != policy.named_value().end();
        ++named_value) {
     if (named_value->has_value()) {
       Value* decoded_value = DecodeValue(named_value->value());
       if (decoded_value)
         result.Set(named_value->name(), decoded_value);
     }
   }
-  mandatory->LoadFrom(&result, GetChromePolicyDefinitionList());
+  policies->LoadFrom(&result,
+                     GetChromePolicyDefinitionList(),
+                     POLICY_LEVEL_MANDATORY,
+                     POLICY_SCOPE_USER);
 }
 
 Value* UserPolicyCache::DecodeIntegerValue(
     google::protobuf::int64 value) const {
   if (value < std::numeric_limits<int>::min() ||
       value > std::numeric_limits<int>::max()) {
     LOG(WARNING) << "Integer value " << value
                  << " out of numeric limits, ignoring.";
     return NULL;
   }
@@ skipping 64 matching lines @@
       return list;
     }
     default:
       NOTREACHED() << "Unhandled value type";
   }
 
   return NULL;
 }
 
 }  // namespace policy