Add an Ethernet EAP policy.

chromeos/network/policy_util.cc

 // Copyright 2013 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 "chromeos/network/policy_util.h"
 
 #include "base/logging.h"
 #include "chromeos/network/network_profile.h"
 #include "chromeos/network/network_ui_data.h"
 #include "chromeos/network/onc/onc_constants.h"
@@ skipping 54 matching lines @@
       }
       // Otherwise, the value is set and modified by the UI, thus we keep that
       // value to overwrite whatever is stored in Shill.
     }
   }
 }
 
 // Returns true if |policy| matches |actual_network|, which must be part of a
 // ONC NetworkConfiguration. This should be the only such matching function
 // within Chrome. Shill does such matching in several functions for network
 // identification. For compatibility, we currently should stick to Shill's

[bartfab (slow), 2013/09/17 08:45:54]

Just to make sure nothing is overlooked: I presume this updates is in sync with
Shill and Shill is able to match ONC for Ethernet as well now?

[pneubeck (no reviews), 2013/09/17 12:48:36]

This function isn't directly Shill related because Shill doesn't know anything
about policies.

I assume, you mean if Shill accepts Ethernet configurations. Yes, at least the
ethernet eap settings are correctly handled by Shill.
Other ethernet settings that would have to be written to Shill (like IP
addresses) don't exist yet.
Note: proxy settings are not sent to Shill anymore and work for both Ethernet
with or without EAP.

 // matching behavior.
 bool IsPolicyMatching(const base::DictionaryValue& policy,
                       const base::DictionaryValue& actual_network) {
   std::string policy_type;
   policy.GetStringWithoutPathExpansion(onc::network_config::kType,
                                        &policy_type);
-  std::string network_type;
+  std::string actual_network_type;
   actual_network.GetStringWithoutPathExpansion(onc::network_config::kType,
-                                               &network_type);
-  if (policy_type != network_type)
+                                               &actual_network_type);
+  if (policy_type != actual_network_type)
     return false;
 
-  if (network_type != onc::network_type::kWiFi)
-    return false;
+  if (actual_network_type == onc::network_type::kEthernet) {
+    const base::DictionaryValue* policy_ethernet = NULL;

[bartfab (slow), 2013/09/17 08:45:54]

Nit: #include "base/values.h"

[pneubeck (no reviews), 2013/09/17 12:48:36]

Done.

+    policy.GetDictionaryWithoutPathExpansion(onc::network_config::kEthernet,
+                                             &policy_ethernet);
+    const base::DictionaryValue* actual_ethernet = NULL;
+    actual_network.GetDictionaryWithoutPathExpansion(
+        onc::network_config::kEthernet, &actual_ethernet);
+    if (!policy_ethernet || !actual_ethernet)
+      return false;
 
-  const base::DictionaryValue* policy_wifi = NULL;
-  policy.GetDictionaryWithoutPathExpansion(onc::network_config::kWiFi,
-                                           &policy_wifi);
-  const base::DictionaryValue* actual_wifi = NULL;
-  actual_network.GetDictionaryWithoutPathExpansion(onc::network_config::kWiFi,
-                                                   &actual_wifi);
-  if (!policy_wifi || !actual_wifi)
-    return false;
+    std::string policy_auth;
+    policy_ethernet->GetStringWithoutPathExpansion(
+        onc::ethernet::kAuthentication, &policy_auth);
+    std::string actual_auth;
+    actual_ethernet->GetStringWithoutPathExpansion(
+        onc::ethernet::kAuthentication, &actual_auth);
+    return (policy_auth == actual_auth);

[bartfab (slow), 2013/09/17 08:45:54]

Nit: No need for brackets here.

[pneubeck (no reviews), 2013/09/17 12:48:36]

Done.

+  } else if (actual_network_type == onc::network_type::kWiFi) {
+    const base::DictionaryValue* policy_wifi = NULL;
+    policy.GetDictionaryWithoutPathExpansion(onc::network_config::kWiFi,
+                                             &policy_wifi);
+    const base::DictionaryValue* actual_wifi = NULL;
+    actual_network.GetDictionaryWithoutPathExpansion(onc::network_config::kWiFi,
+                                                     &actual_wifi);
+    if (!policy_wifi || !actual_wifi)
+      return false;
 
-  std::string policy_ssid;
-  policy_wifi->GetStringWithoutPathExpansion(onc::wifi::kSSID, &policy_ssid);
-  std::string actual_ssid;
-  actual_wifi->GetStringWithoutPathExpansion(onc::wifi::kSSID, &actual_ssid);
-  return (policy_ssid == actual_ssid);
+    std::string policy_ssid;
+    policy_wifi->GetStringWithoutPathExpansion(onc::wifi::kSSID, &policy_ssid);
+    std::string actual_ssid;
+    actual_wifi->GetStringWithoutPathExpansion(onc::wifi::kSSID, &actual_ssid);
+    return (policy_ssid == actual_ssid);
+  }
+  return false;
 }
 
 }  // namespace
 
 scoped_ptr<base::DictionaryValue> CreateShillConfiguration(
     const NetworkProfile& profile,
     const std::string& guid,
     const base::DictionaryValue* policy,
     const base::DictionaryValue* settings) {
   scoped_ptr<base::DictionaryValue> effective;
@@ skipping 77 matching lines @@
        it != policies.end(); ++it) {
     if (IsPolicyMatching(*it->second, actual_network))
       return it->second;
   }
   return NULL;
 }
 
 }  // namespace policy_util
 
 }  // namespace chromeos