Add a function to get Wifi SSID to net_util.

net/base/net_util_unittest.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 "net/base/net_util.h"
 
 #include <string.h>
 
 #include <ostream>
 
@@ skipping 47 matching lines @@
 
 namespace net {
 
 namespace {
 
 struct HeaderCase {
   const char* const header_name;
   const char* const expected;
 };
 
+#if defined(OS_LINUX)
+const char kWiFiSSID[] = "TestWiFi";
+const char kInterfaceWithNoSSID[] = "wlan999";
+
+std::string TestGetInterfaceSSID(const std::string& ifname) {
+  return (ifname == kInterfaceWithNoSSID) ? "" : kWiFiSSID;

[pauljensen, 2015/02/09 12:28:05]

Instead of "", can this return something different from kWiFiSSID?  "" is just
confusing because this is what these functions return if things don't match up.

[meacer, 2015/02/10 04:42:50]

Done.

+}
+#endif
+
 // Fills in sockaddr for the given 32-bit address (IPv4.)
 // |bytes| should be an array of length 4.
 void MakeIPv4Address(const uint8* bytes, int port, SockaddrStorage* storage) {
   memset(&storage->addr_storage, 0, sizeof(storage->addr_storage));
   storage->addr_len = sizeof(struct sockaddr_in);
   struct sockaddr_in* addr4 = reinterpret_cast<sockaddr_in*>(storage->addr);
   addr4->sin_port = base::HostToNet16(port);
   addr4->sin_family = AF_INET;
   memcpy(&addr4->sin_addr, bytes, 4);
 }
@@ skipping 1221 matching lines @@
   EXPECT_EQ(results[0].friendly_name, "FriendlyInterfaceName");
   EXPECT_EQ(results[0].name, ifname_em1);
   EXPECT_EQ(results[0].prefix_length, 1ul);
   EXPECT_EQ(results[0].address, ipv6_address);
   EXPECT_EQ(results[0].ip_address_attributes, IP_ADDRESS_ATTRIBUTE_DEPRECATED);
   results.clear();
 }
 
 #endif  // !OS_MACOSX && !OS_WIN && !OS_NACL
 
+#if defined(OS_LINUX)
+TEST(NetUtilTest, GetWifiSSID) {
+  NetworkInterfaceList list;
+  EXPECT_EQ(std::string(), net::internal::GetWifiSSIDFromInterfaceListInternal(
+                               list, TestGetInterfaceSSID));
+
+  NetworkInterface interface1;
+  interface1.name = "wlan0";
+  interface1.type = NetworkChangeNotifier::CONNECTION_WIFI;
+  list.push_back(interface1);
+  ASSERT_EQ(1u, list.size());
+  EXPECT_EQ(std::string(kWiFiSSID),
+            net::internal::GetWifiSSIDFromInterfaceListInternal(
+                list, TestGetInterfaceSSID));
+
+  NetworkInterface interface2;
+  interface2.name = "wlan1";
+  interface2.type = NetworkChangeNotifier::CONNECTION_WIFI;
+  list.push_back(interface2);
+  ASSERT_EQ(2u, list.size());
+  EXPECT_EQ(std::string(kWiFiSSID),
+            net::internal::GetWifiSSIDFromInterfaceListInternal(
+                list, TestGetInterfaceSSID));
+
+  NetworkInterface interface3;
+  interface3.name = kInterfaceWithNoSSID;
+  interface3.type = NetworkChangeNotifier::CONNECTION_WIFI;
+  list.push_back(interface3);
+  ASSERT_EQ(3u, list.size());
+  EXPECT_EQ(std::string(), net::internal::GetWifiSSIDFromInterfaceListInternal(
+                               list, TestGetInterfaceSSID));
+
+  list.pop_back();
+  NetworkInterface interface4;
+  interface4.name = "eth0";
+  interface4.type = NetworkChangeNotifier::CONNECTION_ETHERNET;
+  list.push_back(interface4);
+  ASSERT_EQ(3u, list.size());
+  EXPECT_EQ(std::string(), net::internal::GetWifiSSIDFromInterfaceListInternal(
+                               list, TestGetInterfaceSSID));
+}

[pauljensen, 2015/02/09 12:28:05]

Can we add a test for calling net::GetWiFiSSID() to test that it at least
doesn't crash?

[meacer, 2015/02/10 04:42:50]

Renamed the above test and added GetWifiSSID.

+#endif  // OS_LINUX
+
 namespace {
 
 #if defined(OS_WIN)
 bool read_int_or_bool(DWORD data_size,
                       PVOID data) {
   switch (data_size) {
     case 1:
       return !!*reinterpret_cast<uint8*>(data);
     case 4:
       return !!*reinterpret_cast<uint32*>(data);
@@ skipping 170 matching lines @@
 TEST_P(NetUtilNonUniqueNameTest, IsHostnameNonUnique) {
   const NonUniqueNameTestData& test_data = GetParam();
 
   EXPECT_EQ(test_data.is_unique, IsUnique(test_data.hostname));
 }
 
 INSTANTIATE_TEST_CASE_P(, NetUtilNonUniqueNameTest,
                         testing::ValuesIn(kNonUniqueNameTestData));
 
 }  // namespace net