Cleanup network type matching.

chromeos/network/network_state_handler.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 "chromeos/network/network_state_handler.h"
 
 #include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/location.h"
 #include "base/metrics/histogram.h"
@@ skipping 24 matching lines @@
                              const std::string& match_type) {
   const std::string& type = managed->type();
   if (match_type == NetworkStateHandler::kMatchTypeDefault)
     return true;
   if (match_type == type)
     return true;
   if (match_type == NetworkStateHandler::kMatchTypeNonVirtual &&
       type != flimflam::kTypeVPN) {
     return true;
   }
+  if (match_type == NetworkStateHandler::kMatchTypeWired &&
+      (type == flimflam::kTypeEthernet || type == shill::kTypeEthernetEap)) {
+    return true;
+  }
   if (match_type == NetworkStateHandler::kMatchTypeWireless &&
-      type != flimflam::kTypeEthernet && type != flimflam::kTypeVPN) {
+      type != flimflam::kTypeEthernet && type != shill::kTypeEthernetEap &&
+      type != flimflam::kTypeVPN) {
     return true;
   }
   if (match_type == NetworkStateHandler::kMatchTypeMobile &&
       (type == flimflam::kTypeCellular || type == flimflam::kTypeWimax)) {
     return true;
   }
   return false;
 }
 
 bool ConnectionStateChanged(NetworkState* network,
@@ skipping 19 matching lines @@
 std::string GetManagedStateLogName(const ManagedState* state) {
   if (!state)
     return "None";
   return base::StringPrintf("%s (%s)", state->name().c_str(),
                             state->path().c_str());
 }
 
 }  // namespace
 
 const char NetworkStateHandler::kMatchTypeDefault[] = "default";
+const char NetworkStateHandler::kMatchTypeWired[] = "wired";
 const char NetworkStateHandler::kMatchTypeWireless[] = "wireless";
 const char NetworkStateHandler::kMatchTypeMobile[] = "mobile";
 const char NetworkStateHandler::kMatchTypeNonVirtual[] = "non-virtual";
 const char NetworkStateHandler::kDefaultCheckPortalList[] =
     "ethernet,wifi,cellular";
 
 NetworkStateHandler::NetworkStateHandler() {
 }
 
 NetworkStateHandler::~NetworkStateHandler() {
@@ skipping 624 matching lines @@
   ScanCallbackList& callback_list = scan_complete_callbacks_[type];
   for (ScanCallbackList::iterator iter = callback_list.begin();
        iter != callback_list.end(); ++iter) {
     (*iter).Run();
   }
   scan_complete_callbacks_.erase(type);
 }
 
 std::string NetworkStateHandler::GetTechnologyForType(
     const std::string& type) const {
+  if (type == kMatchTypeWired || type == shill::kTypeEthernetEap)

[stevenjb, 2013/08/28 15:51:30]

Another place where IsTypeWired(type) would be helpful.

[pneubeck (no reviews), 2013/09/02 20:41:21]

Since the old |type| argument could be a pattern/MatchType itself and I want to
avoid that we mistakenly swap the order in match ('supertype contains subtype'
vs. 'subtype contains supertype'), I introduced this NetworkTypePattern.

This class makes the matches more explicit and the usage of MatchTypes in method
arguments type-safe (compared to everything being a string).

+    return flimflam::kTypeEthernet;
+
   if (type == kMatchTypeMobile) {
     if (shill_property_handler_->IsTechnologyAvailable(flimflam::kTypeWimax))
       return flimflam::kTypeWimax;
     else
       return flimflam::kTypeCellular;
   }
   if (type == kMatchTypeDefault || type == kMatchTypeNonVirtual ||
       type == kMatchTypeWireless) {
     NOTREACHED();
     return flimflam::kTypeWifi;
   }
   return type;
 }
 
 }  // namespace chromeos