If ethernet is not available (i.e. no wired nic), don't show ethernet in stat...

chrome/browser/chromeos/cros/network_library.cc

 // Copyright (c) 2010 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 "chrome/browser/chromeos/cros/network_library.h"
 
 #include <algorithm>
 
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
@@ skipping 387 matching lines @@
     WifiNetwork* wifi = GetPreferredNetwork();
     return wifi && wifi->connected();
   }
 
   bool PreferredNetworkFailed() {
     WifiNetwork* wifi = GetPreferredNetwork();
     return !wifi || wifi->failed();
   }
 
   void ConnectToWifiNetwork(WifiNetwork network,
-                                                const std::string& password,
-                                                const std::string& identity,
-                                                const std::string& certpath) {
+                            const std::string& password,
+                            const std::string& identity,
+                            const std::string& certpath) {
     if (CrosLibrary::Get()->EnsureLoaded()) {
       ConnectToNetworkWithCertInfo(network.service_path().c_str(),
                        password.empty() ? NULL : password.c_str(),
                        identity.empty() ? NULL : identity.c_str(),
                        certpath.empty() ? NULL : certpath.c_str());
     }
   }
 
   void ConnectToWifiNetwork(const std::string& ssid,
-                                                const std::string& password,
-                                                const std::string& identity,
-                                                const std::string& certpath,
-                                                bool auto_connect) {
+                            const std::string& password,
+                            const std::string& identity,
+                            const std::string& certpath,
+                            bool auto_connect) {
     if (CrosLibrary::Get()->EnsureLoaded()) {
       // First create a service from hidden network.
       ServiceInfo* service = GetWifiService(ssid.c_str(),
                                             SECURITY_UNKNOWN);
       if (service) {
         // Set auto-connect.
         SetAutoConnect(service->service_path, auto_connect);
         // Now connect to that service.
         ConnectToNetworkWithCertInfo(service->service_path,
                          password.empty() ? NULL : password.c_str(),
                          identity.empty() ? NULL : identity.c_str(),
                          certpath.empty() ? NULL : certpath.c_str());
 
         // Clean up ServiceInfo object.
         FreeServiceInfo(service);
       } else {
         LOG(WARNING) << "Cannot find hidden network: " << ssid;
         // TODO(chocobo): Show error message.
       }
     }
   }
 
   void ConnectToCellularNetwork(CellularNetwork network) {
     if (CrosLibrary::Get()->EnsureLoaded()) {
       ConnectToNetwork(network.service_path().c_str(), NULL);
     }
   }
 
-  void DisconnectFromWirelessNetwork(
-      const WirelessNetwork& network) {
+  void DisconnectFromWirelessNetwork(const WirelessNetwork& network) {
     if (CrosLibrary::Get()->EnsureLoaded()) {
       DisconnectFromNetwork(network.service_path().c_str());
     }
   }
 
   void SaveCellularNetwork(const CellularNetwork& network) {
     // Update the wifi network in the local cache.
     CellularNetwork* cellular = GetWirelessNetworkByPath(
         cellular_networks_,
         network.service_path());
@@ skipping 16 matching lines @@
     // Update the wifi network with libcros.
     if (CrosLibrary::Get()->EnsureLoaded()) {
       SetPassphrase(
           network.service_path().c_str(), network.passphrase().c_str());
       SetIdentity(network.service_path().c_str(), network.identity().c_str());
       SetCertPath(network.service_path().c_str(), network.cert_path().c_str());
       SetAutoConnect(network.service_path().c_str(), network.auto_connect());
     }
   }
 
-  void ForgetWirelessNetwork(
-      const std::string& service_path) {
+  void ForgetWirelessNetwork(const std::string& service_path) {
     if (CrosLibrary::Get()->EnsureLoaded()) {
       DeleteRememberedService(service_path.c_str());
     }
   }
 
   virtual bool ethernet_available() const {
-      return available_devices_ & (1 << TYPE_ETHERNET);
+    return available_devices_ & (1 << TYPE_ETHERNET);
   }
   virtual bool wifi_available() const {
-      return available_devices_ & (1 << TYPE_WIFI);
+    return available_devices_ & (1 << TYPE_WIFI);
   }
   virtual bool cellular_available() const {
-      return available_devices_ & (1 << TYPE_CELLULAR);
+    return available_devices_ & (1 << TYPE_CELLULAR);
   }
 
   virtual bool ethernet_enabled() const {
-      return enabled_devices_ & (1 << TYPE_ETHERNET);
+    return enabled_devices_ & (1 << TYPE_ETHERNET);
   }
   virtual bool wifi_enabled() const {
-      return enabled_devices_ & (1 << TYPE_WIFI);
+    return enabled_devices_ & (1 << TYPE_WIFI);
   }
   virtual bool cellular_enabled() const {
-      return enabled_devices_ & (1 << TYPE_CELLULAR);
+    return enabled_devices_ & (1 << TYPE_CELLULAR);
   }
 
   virtual bool offline_mode() const { return offline_mode_; }
 
   void EnableEthernetNetworkDevice(bool enable) {
     EnableNetworkDeviceType(TYPE_ETHERNET, enable);
   }
 
   void EnableWifiNetworkDevice(bool enable) {
     EnableNetworkDeviceType(TYPE_WIFI, enable);
@@ skipping 16 matching lines @@
       LOG(INFO) <<
           "Trying to disable offline mode when it's already disabled. ";
       return;
     }
 
     if (SetOfflineMode(enable)) {
       offline_mode_ = enable;
     }
   }
 
-  NetworkIPConfigVector GetIPConfigs(
-      const std::string& device_path) {
+  NetworkIPConfigVector GetIPConfigs(const std::string& device_path) {
     NetworkIPConfigVector ipconfig_vector;
     if (!device_path.empty()) {
       IPConfigStatus* ipconfig_status = ListIPConfigs(device_path.c_str());
       if (ipconfig_status) {
         for (int i = 0; i < ipconfig_status->size; i++) {
           IPConfig ipconfig = ipconfig_status->ips[i];
           ipconfig_vector.push_back(
               NetworkIPConfig(device_path, ipconfig.type, ipconfig.address,
                               ipconfig.netmask, ipconfig.gateway,
                               ipconfig.name_servers));
@@ skipping 14 matching lines @@
           base::IntToString(refresh) + "\"/>");
     output.append("</head><body>");
     if (refresh > 0) {
       output.append("(Auto-refreshing page every " +
                     base::IntToString(refresh) + "s)");
     } else {
       output.append("(To auto-refresh this page: about:network/&lt;secs&gt;)");
     }
 
     output.append("<h3>Ethernet:</h3><table border=1>");
-    output.append("<tr>" + ToHtmlTableHeader(&ethernet_) + "</tr>");
-    output.append("<tr>" + ToHtmlTableRow(&ethernet_) + "</tr>");
+    if (ethernet_enabled()) {
+      output.append("<tr>" + ToHtmlTableHeader(&ethernet_) + "</tr>");
+      output.append("<tr>" + ToHtmlTableRow(&ethernet_) + "</tr>");
+    }
 
     output.append("</table><h3>Wifi:</h3><table border=1>");
     for (size_t i = 0; i < wifi_networks_.size(); ++i) {
       if (i == 0)
         output.append("<tr>" + ToHtmlTableHeader(&wifi_networks_[i]) + "</tr>");
       output.append("<tr>" + ToHtmlTableRow(&wifi_networks_[i]) + "</tr>");
     }
 
     output.append("</table><h3>Cellular:</h3><table border=1>");
     for (size_t i = 0; i < cellular_networks_.size(); ++i) {
@@ skipping 212 matching lines @@
 
   // const version
   template<typename T> const T* GetWirelessNetworkByPath(
       const std::vector<T>& networks, const std::string& path) const {
     typedef typename std::vector<T>::const_iterator iter_t;
     iter_t iter = std::find_if(networks.begin(), networks.end(),
                                WirelessNetwork::ServicePathEq(path));
     return (iter != networks.end()) ? &(*iter) : NULL;
   }
 
-  void EnableNetworkDeviceType(ConnectionType device,
-                                                   bool enable) {
+  void EnableNetworkDeviceType(ConnectionType device, bool enable) {
     if (!CrosLibrary::Get()->EnsureLoaded())
       return;
 
     // If network device is already enabled/disabled, then don't do anything.
     if (enable && (enabled_devices_ & (1 << device))) {
       LOG(WARNING) << "Trying to enable a device that's already enabled: "
                    << device;
       return;
     }
     if (!enable && !(enabled_devices_ & (1 << device))) {
@@ skipping 182 matching lines @@
     return new NetworkLibraryStubImpl();
   else
     return new NetworkLibraryImpl();
 }
 
 }  // namespace chromeos
 
 // Allows InvokeLater without adding refcounting. This class is a Singleton and
 // won't be deleted until it's last InvokeLater is run.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(chromeos::NetworkLibraryImpl);