Cleanup network type matching.

chromeos/network/shill_property_util.cc

Index: chromeos/network/shill_property_util.cc
diff --git a/chromeos/network/shill_property_util.cc b/chromeos/network/shill_property_util.cc
index 9cbd2daed63ca337473f33daca7215bde980a473..6ec3758661fded0074a61ed0e6a959ab07564b14 100644
--- a/chromeos/network/shill_property_util.cc
+++ b/chromeos/network/shill_property_util.cc
@@ -219,4 +219,149 @@ 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,
+  kNetworkTypeBluetooth = 1 << 3,

[stevenjb, 2013/09/03 16:22:43]

We don't handle Bluetooth anywhere in the current Network UI code, and I don't
expect we will. Let's omit it at this point so that we don't make incorrect
assumptions (like whether or not Bluetooth would count as "Wireless").

[pneubeck (no reviews), 2013/09/04 12:57:29]

Done.

+  kNetworkTypeCellular = 1 << 4,
+  kNetworkTypeVPN = 1 << 5,
+  kNetworkTypeEthernetEap = 1 << 6
+};
+
+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::kTypeBluetooth, kNetworkTypeBluetooth },
+  { 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;
+  }
+  NOTREACHED();
+  return kNetworkTypeNone;
+}
+
+std::string FlagToShillNetworkType(const NetworkTypeBitFlag flag) {
+  for (size_t i = 0; i < arraysize(shill_type_to_flag); ++i) {
+    if (shill_type_to_flag[i].bit_flag == flag)
+      return shill_type_to_flag[i].shill_network_type;
+  }
+  NOTREACHED();
+  return std::string();
+}
+
+}  // namespace
+
+// static
+NetworkTypePattern NetworkTypePattern::Default() {
+  return NetworkTypePattern(~0);
+}
+
+// static
+NetworkTypePattern NetworkTypePattern::Wireless() {
+  return NetworkTypePattern(kNetworkTypeWifi | kNetworkTypeWimax |
+                            kNetworkTypeBluetooth | kNetworkTypeCellular);
+}
+
+// static
+NetworkTypePattern NetworkTypePattern::Mobile() {
+  return NetworkTypePattern(kNetworkTypeCellular | kNetworkTypeWimax);
+}
+
+// static
+NetworkTypePattern NetworkTypePattern::NonVirtual() {
+  return NetworkTypePattern(~kNetworkTypeVPN);
+}
+
+// static
+NetworkTypePattern NetworkTypePattern::Ethernet() {
+  return NetworkTypePattern(kNetworkTypeEthernet | kNetworkTypeEthernetEap);
+}
+
+// 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::Matches(const std::string& shill_network_type) const {
+  return ContainsPattern(Primitive(shill_network_type));
+}
+
+bool NetworkTypePattern::ContainsPattern(
+    const NetworkTypePattern& subpattern) const {
+  if (Equals(subpattern))
+    return true;
+
+  return (~pattern_ & subpattern.pattern_) == 0;

[stevenjb, 2013/09/03 16:22:43]

I don't think this is the behavior I would expect. I would expect
Cellular.Matches(Mobile) to be true in addition to Mobile.Matches(Cellular). Do
we have a use case for the (confusing to me) asymetric behavior where we
wouldn't just use Equals()? It seems like this function should be
MatchesPattern() and Matches() should be MatchesType(), and they should just
return (pattern_ & other.pattern_).

[pneubeck (no reviews), 2013/09/04 12:57:29]

Done.

+}
+
+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