Show hardware addresses for wifi and ethernet networks.

chrome/browser/chromeos/cros/network_library.cc

 // Copyright (c) 2011 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 <map>
 
 #include "base/i18n/time_formatting.h"
@@ skipping 2198 matching lines @@
 
   virtual const NetworkDevice* FindCellularDevice() const {
     for (NetworkDeviceMap::const_iterator iter = device_map_.begin();
          iter != device_map_.end(); ++iter) {
       if (iter->second->type() == TYPE_CELLULAR)
         return iter->second;
     }
     return NULL;
   }
 
+  virtual const NetworkDevice* FindEthernetDevice() const {
+    for (NetworkDeviceMap::const_iterator iter = device_map_.begin();
+         iter != device_map_.end(); ++iter) {
+      if (iter->second->type() == TYPE_ETHERNET)
+        return iter->second;
+    }
+    return NULL;
+  }
+
+  virtual const NetworkDevice* FindWifiDevice() const {
+    for (NetworkDeviceMap::const_iterator iter = device_map_.begin();
+         iter != device_map_.end(); ++iter) {
+      if (iter->second->type() == TYPE_WIFI)
+        return iter->second;
+    }
+    return NULL;
+  }
+
   virtual Network* FindNetworkByPath(const std::string& path) const {
     NetworkMap::const_iterator iter = network_map_.find(path);
     if (iter != network_map_.end())
       return iter->second;
     return NULL;
   }
 
   WirelessNetwork* FindWirelessNetworkByPath(const std::string& path) const {
     Network* network = FindNetworkByPath(path);
     if (network &&
@@ skipping 595 matching lines @@
       VLOG(1) << "Trying to disable offline mode when it's already disabled.";
       return;
     }
 
     if (SetOfflineMode(enable)) {
       offline_mode_ = enable;
     }
   }
 
   virtual NetworkIPConfigVector GetIPConfigs(const std::string& device_path,
-                                             std::string* hardware_address) {
+                                             std::string* hardware_address,
+                                             HardwareAddressFormat format) {
+    DCHECK(hardware_address);
     hardware_address->clear();
     NetworkIPConfigVector ipconfig_vector;
     if (EnsureCrosLoaded() && !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));
         }
         *hardware_address = ipconfig_status->hardware_address;
         FreeIPConfigStatus(ipconfig_status);
         // Sort the list of ip configs by type.
         std::sort(ipconfig_vector.begin(), ipconfig_vector.end());
       }
     }
+
+    for (size_t i = 0; i < hardware_address->size(); ++i)
+      (*hardware_address)[i] = toupper((*hardware_address)[i]);
+    if (format == FORMAT_COLON_SEPARATED_HEX) {
+      if (hardware_address->size() % 2 == 0) {
+        std::string output;
+        for (size_t i = 0; i < hardware_address->size(); ++i) {
+          if ((i != 0) && (i % 2 == 0))
+            output.push_back(':');
+          output.push_back((*hardware_address)[i]);
+        }
+        *hardware_address = output;
+      }
+    } else {
+      DCHECK(format == FORMAT_RAW_HEX);
+    }
     return ipconfig_vector;
   }
 
  private:
 
   typedef std::map<std::string, Network*> NetworkMap;
   typedef std::map<std::string, int> PriorityMap;
   typedef std::map<std::string, NetworkDevice*> NetworkDeviceMap;
   typedef std::map<std::string, CellularDataPlanVector*> CellularDataPlanMap;
 
@@ skipping 1332 matching lines @@
   virtual bool has_cellular_networks() const {
     return cellular_networks_.begin() != cellular_networks_.end();
   }
   /////////////////////////////////////////////////////////////////////////////
 
   virtual const NetworkDevice* FindNetworkDeviceByPath(
       const std::string& path) const { return NULL; }
   virtual const NetworkDevice* FindCellularDevice() const {
     return NULL;
   }
+  virtual const NetworkDevice* FindEthernetDevice() const {
+    return NULL;
+  }
+  virtual const NetworkDevice* FindWifiDevice() const {
+    return NULL;
+  }
   virtual Network* FindNetworkByPath(
       const std::string& path) const { return NULL; }
   virtual WifiNetwork* FindWifiNetworkByPath(
       const std::string& path) const { return NULL; }
   virtual CellularNetwork* FindCellularNetworkByPath(
       const std::string& path) const { return NULL; }
   virtual VirtualNetwork* FindVirtualNetworkByPath(
       const std::string& path) const { return NULL; }
   virtual Network* FindNetworkFromRemembered(
       const Network* remembered) const { return NULL; }
@@ skipping 51 matching lines @@
   virtual bool cellular_enabled() const { return false; }
   virtual bool wifi_scanning() const { return false; }
   virtual const Network* active_network() const { return NULL; }
   virtual const Network* connected_network() const { return NULL; }
   virtual bool offline_mode() const { return false; }
   virtual void EnableEthernetNetworkDevice(bool enable) {}
   virtual void EnableWifiNetworkDevice(bool enable) {}
   virtual void EnableCellularNetworkDevice(bool enable) {}
   virtual void EnableOfflineMode(bool enable) {}
   virtual NetworkIPConfigVector GetIPConfigs(const std::string& device_path,
-                                             std::string* hardware_address) {
+                                             std::string* hardware_address,
+                                             HardwareAddressFormat) {
     hardware_address->clear();
     return NetworkIPConfigVector();
   }
 
  private:
   std::string ip_address_;
   EthernetNetwork* ethernet_;
   WifiNetwork* active_wifi_;
   CellularNetwork* active_cellular_;
   VirtualNetwork* active_virtual_;
   WifiNetworkVector wifi_networks_;
   CellularNetworkVector cellular_networks_;
   VirtualNetworkVector virtual_networks_;
 };
 
 // static
 NetworkLibrary* NetworkLibrary::GetImpl(bool stub) {
   if (stub)
     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);