Removed ConfigurationPolicyType and extended PolicyMap.

chrome/browser/policy/device_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/device_policy_cache.h"
 
 #include <limits>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/cros_settings.h"
 #include "chrome/browser/chromeos/dbus/dbus_thread_manager.h"
 #include "chrome/browser/chromeos/dbus/update_engine_client.h"
 #include "chrome/browser/chromeos/login/ownership_service.h"
 #include "chrome/browser/chromeos/login/signed_settings_helper.h"
 #include "chrome/browser/policy/cloud_policy_data_store.h"
 #include "chrome/browser/policy/enterprise_install_attributes.h"
 #include "chrome/browser/policy/enterprise_metrics.h"
 #include "chrome/browser/policy/policy_map.h"
 #include "chrome/browser/policy/proto/device_management_backend.pb.h"
 #include "chrome/browser/policy/proto/device_management_local.pb.h"
-#include "policy/configuration_policy_type.h"
 
 namespace em = enterprise_management;
 
 namespace {
 
 // Stores policy, updates the owner key if required and reports the status
 // through a callback.
 class StorePolicyOperation : public chromeos::OwnerManager::KeyUpdateDelegate {
  public:
   typedef base::Callback<void(chromeos::SignedSettings::ReturnCode)> Callback;
@@ skipping 178 matching lines @@
     }
     bool ok = SetPolicyInternal(policy, NULL, false);
     if (ok) {
       UMA_HISTOGRAM_ENUMERATION(kMetricPolicy, kMetricPolicyFetchOK,
                                 kMetricPolicySize);
     }
   }
 }
 
 bool DevicePolicyCache::DecodePolicyData(const em::PolicyData& policy_data,
-                                         PolicyMap* mandatory,
-                                         PolicyMap* recommended) {
+                                         PolicyMap* policies) {
   em::ChromeDeviceSettingsProto policy;
   if (!policy.ParseFromString(policy_data.policy_value())) {
     LOG(WARNING) << "Failed to parse ChromeDeviceSettingsProto.";
     return false;
   }
-  DecodeDevicePolicy(policy, mandatory, recommended);
+  DecodeDevicePolicy(policy, policies);
   return true;
 }
 
 void DevicePolicyCache::PolicyStoreOpCompleted(
     chromeos::SignedSettings::ReturnCode code) {
   DCHECK(CalledOnValidThread());
   if (code != chromeos::SignedSettings::SUCCESS) {
     UMA_HISTOGRAM_ENUMERATION(kMetricPolicy, kMetricPolicyStoreFailed,
                               kMetricPolicySize);
     if (code == chromeos::SignedSettings::BAD_SIGNATURE) {
@@ skipping 59 matching lines @@
   data_store_->set_device_id(policy_data.device_id());
   *device_token = policy_data.request_token();
   base::Time timestamp;
   if (SetPolicyInternal(policy, &timestamp, true))
     set_last_policy_refresh_time(timestamp);
 }
 
 // static
 void DevicePolicyCache::DecodeDevicePolicy(
     const em::ChromeDeviceSettingsProto& policy,
-    PolicyMap* mandatory,
-    PolicyMap* recommended) {
+    PolicyMap* policies) {
   if (policy.has_device_policy_refresh_rate()) {
     const em::DevicePolicyRefreshRateProto container =
         policy.device_policy_refresh_rate();
     if (container.has_device_policy_refresh_rate()) {
-      mandatory->Set(kPolicyDevicePolicyRefreshRate,
-                     DecodeIntegerValue(
-                         container.device_policy_refresh_rate()));
+      policies->Set(key::kDevicePolicyRefreshRate,
+                    POLICY_LEVEL_MANDATORY,
+                    POLICY_SCOPE_DEVICE,
+                    DecodeIntegerValue(container.device_policy_refresh_rate()));
     }
   }
 
   if (policy.has_device_proxy_settings()) {
     const em::DeviceProxySettingsProto container =
         policy.device_proxy_settings();
     if (container.has_proxy_mode()) {
-      recommended->Set(kPolicyProxyMode,
-                       Value::CreateStringValue(container.proxy_mode()));
+      policies->Set(key::kProxyMode,
+                    POLICY_LEVEL_RECOMMENDED,
+                    POLICY_SCOPE_DEVICE,
+                    Value::CreateStringValue(container.proxy_mode()));
     }
     if (container.has_proxy_server()) {
-      recommended->Set(kPolicyProxyServer,
-                       Value::CreateStringValue(container.proxy_server()));
+      policies->Set(key::kProxyServer,
+                    POLICY_LEVEL_RECOMMENDED,
+                    POLICY_SCOPE_DEVICE,
+                    Value::CreateStringValue(container.proxy_server()));
     }
     if (container.has_proxy_pac_url()) {
-      recommended->Set(kPolicyProxyPacUrl,
-                       Value::CreateStringValue(container.proxy_pac_url()));
+      policies->Set(key::kProxyPacUrl,
+                    POLICY_LEVEL_RECOMMENDED,
+                    POLICY_SCOPE_DEVICE,
+                    Value::CreateStringValue(container.proxy_pac_url()));
     }
     if (container.has_proxy_bypass_list()) {
-      recommended->Set(kPolicyProxyBypassList,
-                       Value::CreateStringValue(container.proxy_bypass_list()));
+      policies->Set(key::kProxyBypassList,
+                    POLICY_LEVEL_RECOMMENDED,
+                    POLICY_SCOPE_DEVICE,
+                    Value::CreateStringValue(container.proxy_bypass_list()));
     }
   }
 
   if (policy.has_release_channel() &&
       policy.release_channel().has_release_channel()) {
     std::string channel(policy.release_channel().release_channel());
-    mandatory->Set(kPolicyChromeOsReleaseChannel,
-                   Value::CreateStringValue(channel));
+    policies->Set(key::kChromeOsReleaseChannel,
+                  POLICY_LEVEL_MANDATORY,
+                  POLICY_SCOPE_DEVICE,
+                  Value::CreateStringValue(channel));
     // TODO(dubroy): Once http://crosbug.com/17015 is implemented, we won't
     // have to pass the channel in here, only ping the update engine to tell
     // it to fetch the channel from the policy.
     chromeos::DBusThreadManager::Get()->GetUpdateEngineClient()
         ->SetReleaseTrack(channel);
   }
 
   if (policy.has_open_network_configuration() &&
       policy.open_network_configuration().has_open_network_configuration()) {
     std::string config(
         policy.open_network_configuration().open_network_configuration());
-    mandatory->Set(kPolicyDeviceOpenNetworkConfiguration,
-                   Value::CreateStringValue(config));
+    policies->Set(key::kDeviceOpenNetworkConfiguration,
+                  POLICY_LEVEL_MANDATORY,
+                  POLICY_SCOPE_DEVICE,
+                  Value::CreateStringValue(config));
   }
 }
 
 }  // namespace policy