Cleanup network type matching.

Before, both concrete network types (like Wimax) and type patterns (like Mobile) were represented as strings. In some cases, a variable could be both a concrete type or a pattern and was compared to another pattern.
This is hard to read and operands of the comparison can easily be swapped by mistake.
Implementing the comparison of patterns didn't scale.

This change adds a new class that encapsulates network type patterns and represents them internally as a more scalable bit vector.
It's now explicit which functions accept a type pattern as an argument.

This also adds support for Shill's network type kEthernetEap.

BUG=126870
(API change, used in chrome/browser/ui/webui/{chromeos,help})
TBR=xiyuan@chromium.org

Review URL: https://chromiumcodereview.appspot.com/23712002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@222620 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 135 insertions, 0 deletions

diff --git a/chromeos/network/shill_property_util.cc b/chromeos/network/shill_property_util.cc
index d471562..c97c152 100644
--- a/chromeos/network/shill_property_util.cc
+++ b/chromeos/network/shill_property_util.cc
@@ -236,4 +236,139 @@ bool CopyIdentifyingProperties(const base::DictionaryValue& service_properties,
 
 }  // namespace shill_property_util
 
+namespace {
+
+const char kPatternDefault[] = "PatternDefault";
+const char kPatternEthernet[] = "PatternEthernet";
+const char kPatternWireless[] = "PatternWireless";
+const char kPatternMobile[] = "PatternMobile";
+const char kPatternNonVirtual[] = "PatternNonVirtual";
+
+enum NetworkTypeBitFlag {
+  kNetworkTypeNone = 0,
+  kNetworkTypeEthernet = 1 << 0,
+  kNetworkTypeWifi = 1 << 1,
+  kNetworkTypeWimax = 1 << 2,
+  kNetworkTypeCellular = 1 << 3,
+  kNetworkTypeVPN = 1 << 4,
+  kNetworkTypeEthernetEap = 1 << 5
+};
+
+struct ShillToBitFlagEntry {
+  const char* shill_network_type;
+  NetworkTypeBitFlag bit_flag;
+} shill_type_to_flag[] = {
+  { flimflam::kTypeEthernet, kNetworkTypeEthernet },
+  { shill::kTypeEthernetEap, kNetworkTypeEthernetEap },
+  { flimflam::kTypeWifi, kNetworkTypeWifi },
+  { flimflam::kTypeWimax, kNetworkTypeWimax },
+  { flimflam::kTypeCellular, kNetworkTypeCellular },
+  { flimflam::kTypeVPN, kNetworkTypeVPN }
+};
+
+NetworkTypeBitFlag ShillNetworkTypeToFlag(const std::string& shill_type) {
+  for (size_t i = 0; i < arraysize(shill_type_to_flag); ++i) {
+    if (shill_type_to_flag[i].shill_network_type == shill_type)
+      return shill_type_to_flag[i].bit_flag;
+  }
+  NET_LOG_ERROR("ShillNetworkTypeToFlag", "Unknown type: " + shill_type);
+  return kNetworkTypeNone;
+}
+
+}  // namespace
+
+// static
+NetworkTypePattern NetworkTypePattern::Default() {
+  return NetworkTypePattern(~0);
+}
+
+// static
+NetworkTypePattern NetworkTypePattern::Wireless() {
+  return NetworkTypePattern(kNetworkTypeWifi | kNetworkTypeWimax |
+                            kNetworkTypeCellular);
+}
+
+// static
+NetworkTypePattern NetworkTypePattern::Mobile() {
+  return NetworkTypePattern(kNetworkTypeCellular | kNetworkTypeWimax);
+}
+
+// static
+NetworkTypePattern NetworkTypePattern::NonVirtual() {
+  return NetworkTypePattern(~kNetworkTypeVPN);
+}
+
+// static
+NetworkTypePattern NetworkTypePattern::Ethernet() {
+  return NetworkTypePattern(kNetworkTypeEthernet);
+}
+
+// static
+NetworkTypePattern NetworkTypePattern::WiFi() {
+  return NetworkTypePattern(kNetworkTypeWifi);
+}
+
+// static
+NetworkTypePattern NetworkTypePattern::Cellular() {
+  return NetworkTypePattern(kNetworkTypeCellular);
+}
+
+// static
+NetworkTypePattern NetworkTypePattern::VPN() {
+  return NetworkTypePattern(kNetworkTypeVPN);
+}
+
+// static
+NetworkTypePattern NetworkTypePattern::Wimax() {
+  return NetworkTypePattern(kNetworkTypeWimax);
+}
+
+// static
+NetworkTypePattern NetworkTypePattern::Primitive(
+    const std::string& shill_network_type) {
+  return NetworkTypePattern(ShillNetworkTypeToFlag(shill_network_type));
+}
+
+bool NetworkTypePattern::Equals(const NetworkTypePattern& other) const {
+  return pattern_ == other.pattern_;
+}
+
+bool NetworkTypePattern::MatchesType(
+    const std::string& shill_network_type) const {
+  return MatchesPattern(Primitive(shill_network_type));
+}
+
+bool NetworkTypePattern::MatchesPattern(
+    const NetworkTypePattern& other_pattern) const {
+  if (Equals(other_pattern))
+    return true;
+
+  return pattern_ & other_pattern.pattern_;
+}
+
+std::string NetworkTypePattern::ToDebugString() const {
+  if (Equals(Default()))
+    return kPatternDefault;
+  if (Equals(Ethernet()))
+    return kPatternEthernet;
+  if (Equals(Wireless()))
+    return kPatternWireless;
+  if (Equals(Mobile()))
+    return kPatternMobile;
+  if (Equals(NonVirtual()))
+    return kPatternNonVirtual;
+
+  std::string str;
+  for (size_t i = 0; i < arraysize(shill_type_to_flag); ++i) {
+    if (!(pattern_ & shill_type_to_flag[i].bit_flag))
+      continue;
+    if (!str.empty())
+      str += "|";
+    str += shill_type_to_flag[i].shill_network_type;
+  }
+  return str;
+}
+
+NetworkTypePattern::NetworkTypePattern(int pattern) : pattern_(pattern) {}
+
 }  // namespace chromeos