Introduce a device setting controlling allowed connection types for AU.

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>
 
@@ skipping 11 matching lines @@
 #include "chrome/browser/policy/app_pack_updater.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 "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/update_engine_client.h"
 #include "policy/policy_constants.h"
+#include "third_party/cros_system_api/dbus/service_constants.h"
 
+using google::protobuf::RepeatedField;
 using google::protobuf::RepeatedPtrField;
 
 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:
@@ skipping 62 matching lines @@
   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;
   }
 
   return Value::CreateIntegerValue(static_cast<int>(value));
 }
 
+Value* DecodeConnectionType(int value) {
+  static const char* const kConnectionTypes[] = {
+    flimflam::kTypeEthernet,
+    flimflam::kTypeWifi,
+    flimflam::kTypeWimax,
+    flimflam::kTypeBluetooth,
+    flimflam::kTypeCellular,
+  };
+
+  if (value < 0 || value >= static_cast<int>(arraysize(kConnectionTypes)))
+    return NULL;
+
+  return Value::CreateStringValue(kConnectionTypes[value]);
+}
+
 }  // namespace
 
 namespace policy {
 
 DevicePolicyCache::DevicePolicyCache(
     CloudPolicyDataStore* data_store,
     EnterpriseInstallAttributes* install_attributes)
     : data_store_(data_store),
       install_attributes_(install_attributes),
       signed_settings_helper_(chromeos::SignedSettingsHelper::Get()),
@@ skipping 456 matching lines @@
     if (container.has_report_location()) {
       policies->Set(key::kReportDeviceLocation,
                     POLICY_LEVEL_MANDATORY,
                     POLICY_SCOPE_MACHINE,
                     Value::CreateBooleanValue(container.report_location()));
     }
   }
 }
 
 // static
-void DevicePolicyCache::DecodeGenericPolicies(
+void DevicePolicyCache::DecodeAutoUpdatePolicies(
     const em::ChromeDeviceSettingsProto& policy,
     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()) {
-      policies->Set(key::kDevicePolicyRefreshRate,
-                    POLICY_LEVEL_MANDATORY,
-                    POLICY_SCOPE_MACHINE,
-                    DecodeIntegerValue(container.device_policy_refresh_rate()));
-    }
-  }
-
-  if (policy.has_metrics_enabled()) {
-    const em::MetricsEnabledProto& container(policy.metrics_enabled());
-    if (container.has_metrics_enabled()) {
-      policies->Set(key::kDeviceMetricsReportingEnabled,
-                    POLICY_LEVEL_MANDATORY,
-                    POLICY_SCOPE_MACHINE,
-                    Value::CreateBooleanValue(container.metrics_enabled()));
-    }
-  }
-
   if (policy.has_release_channel()) {
     const em::ReleaseChannelProto& container(policy.release_channel());
     if (container.has_release_channel()) {
       std::string channel(container.release_channel());
       policies->Set(key::kChromeOsReleaseChannel,
                     POLICY_LEVEL_MANDATORY,
                     POLICY_SCOPE_MACHINE,
                     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
@@ skipping 19 matching lines @@
                     Value::CreateBooleanValue(container.update_disabled()));
     }
 
     if (container.has_target_version_prefix()) {
       policies->Set(key::kDeviceTargetVersionPrefix,
                     POLICY_LEVEL_MANDATORY,
                     POLICY_SCOPE_MACHINE,
                     Value::CreateStringValue(
                         container.target_version_prefix()));
     }
+
+    // target_version_display_name is not actually a policy, but a display
+    // string for target_version_prefix, so we ignore it.
+
+    if (container.has_scatter_factor_in_seconds()) {
+      policies->Set(key::kDeviceUpdateScatterFactor,
+                    POLICY_LEVEL_MANDATORY,
+                    POLICY_SCOPE_MACHINE,
+                    Value::CreateIntegerValue(
+                        container.scatter_factor_in_seconds()));
+    }
+
+    if (container.allowed_connection_types_size()) {
+      ListValue* allowed_connection_types = new ListValue();
+      RepeatedField<int>::const_iterator entry;
+      for (entry = container.allowed_connection_types().begin();
+           entry != container.allowed_connection_types().end();
+           ++entry) {
+        base::Value* value = DecodeConnectionType(*entry);
+        if (!value)
+          allowed_connection_types->Append(value);
+      }
+      policies->Set(key::kDeviceUpdateAllowedConnectionTypes,
+                    POLICY_LEVEL_MANDATORY,
+                    POLICY_SCOPE_MACHINE,
+                    allowed_connection_types);
+    }
+  }
+}
+
+// static
+void DevicePolicyCache::DecodeGenericPolicies(
+    const em::ChromeDeviceSettingsProto& policy,
+    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()) {
+      policies->Set(key::kDevicePolicyRefreshRate,
+                    POLICY_LEVEL_MANDATORY,
+                    POLICY_SCOPE_MACHINE,
+                    DecodeIntegerValue(container.device_policy_refresh_rate()));
+    }
+  }
+
+  if (policy.has_metrics_enabled()) {
+    const em::MetricsEnabledProto& container(policy.metrics_enabled());
+    if (container.has_metrics_enabled()) {
+      policies->Set(key::kDeviceMetricsReportingEnabled,
+                    POLICY_LEVEL_MANDATORY,
+                    POLICY_SCOPE_MACHINE,
+                    Value::CreateBooleanValue(container.metrics_enabled()));
+    }
   }
 
   if (policy.has_start_up_urls()) {
     const em::StartUpUrlsProto& container(policy.start_up_urls());
     if (container.start_up_urls_size()) {
       ListValue* urls = new ListValue();
       RepeatedPtrField<std::string>::const_iterator entry;
       for (entry = container.start_up_urls().begin();
            entry != container.start_up_urls().end();
            ++entry) {
         urls->Append(Value::CreateStringValue(*entry));
       }
       policies->Set(key::kDeviceStartUpUrls,
                     POLICY_LEVEL_MANDATORY,
                     POLICY_SCOPE_MACHINE,
                     urls);
     }
   }
 }
 
 }  // namespace policy