Cleanup network type matching.

chromeos/network/shill_property_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/shill_property_util.h"
 
 #include "base/i18n/icu_encoding_detection.h"
 #include "base/i18n/icu_string_conversions.h"
 #include "base/json/json_writer.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 201 matching lines @@
     // Ethernet and EthernetEAP don't have any additional identifying
     // properties.
   } else {
     NOTREACHED() << "Unsupported network type " << type;
   }
   return true;
 }
 
 }  // 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