Cast: Allow extension to control wifi options on windows

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>
 
 #include "base/files/file_path.h"
 #include "base/format_macros.h"
 #include "base/scoped_native_library.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_byteorder.h"
 #include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 #if defined(OS_WIN)
 #include <iphlpapi.h>
 #include <objbase.h>
 #include "base/win/windows_version.h"
+#include "net/base/net_util_win.h"
 #elif !defined(OS_ANDROID)
 #include <net/if.h>
 #endif  // OS_WIN
 
 using base::ASCIIToUTF16;
 using base::WideToUTF16;
 
+using namespace net::internal;

[pauljensen, 2014/09/23 17:59:03]

"using namespace" is strictly forbidden in the style guide.

[hubbe, 2014/09/23 18:06:16]

Done.

+
 namespace net {
 
 namespace {
 
 struct HeaderCase {
   const char* header_name;
   const char* expected;
 };
 
 struct CompliantHostCase {
@@ skipping 739 matching lines @@
       EXPECT_NE(WIFI_PHY_LAYER_PROTOCOL_NONE, GetWifiPHYLayerProtocol());
     }
 #elif !defined(OS_ANDROID)
     char name[IF_NAMESIZE];
     EXPECT_TRUE(if_indextoname(it->interface_index, name));
     EXPECT_STREQ(it->name.c_str(), name);
 #endif
   }
 }
 
+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);
+    default:
+      LOG(FATAL) << "That is not a type I know!";
+      return false;
+  }
+}
+
+int GetWifiOptions() {
+  const WlanApi& wlanapi = WlanApi::GetInstance();
+  if (!wlanapi.initialized)
+    return -1;
+
+  WlanHandle client;
+  DWORD cur_version = 0;
+  const DWORD kMaxClientVersion = 2;
+  DWORD result = wlanapi.OpenHandle(
+      kMaxClientVersion, &cur_version, &client);
+  if (result != ERROR_SUCCESS)
+    return -1;
+
+  WLAN_INTERFACE_INFO_LIST* interface_list_ptr = NULL;
+  result = wlanapi.enum_interfaces_func(client, NULL, &interface_list_ptr);
+  if (result != ERROR_SUCCESS)
+    return -1;
+  scoped_ptr<WLAN_INTERFACE_INFO_LIST, WlanApiDeleter> interface_list(
+      interface_list_ptr);
+
+  for (unsigned i = 0; i < interface_list->dwNumberOfItems; ++i) {
+    WLAN_INTERFACE_INFO* info = &interface_list->InterfaceInfo[i];
+    DWORD data_size;
+    PVOID data;
+    int options = 0;
+    result = wlanapi.query_interface_func(
+        client,
+        &info->InterfaceGuid,
+        wlan_intf_opcode_background_scan_enabled,
+        NULL,
+        &data_size,
+        &data,
+        NULL);
+    if (result != ERROR_SUCCESS)
+      continue;
+    if (!read_int_or_bool(data_size, data)) {
+      options |= WIFI_OPTIONS_DISABLE_SCAN;
+    }
+    WlanApi::GetInstance().free_memory_func(data);
+
+    result = wlanapi.query_interface_func(
+        client,
+        &info->InterfaceGuid,
+        wlan_intf_opcode_media_streaming_mode,
+        NULL,
+        &data_size,
+        &data,
+        NULL);
+    if (result != ERROR_SUCCESS)
+      continue;
+    if (read_int_or_bool(data_size, data)) {
+      options |= WIFI_OPTIONS_MEDIA_STREAMING_MODE;
+    }
+    WlanApi::GetInstance().free_memory_func(data);
+
+    // Just the the options from the first succesful
+    // interface.
+    return options;
+  }
+
+  // No wifi interface found.
+  return -1;
+}
+
+#else  // OS_WIN
+
+int GetWifiOptions() {
+  // Not supported.
+  return -1;
+}
+
+#endif  // OS_WIN
+
+void TryChangeWifiOptions(int options) {
+  int previous_options = GetWifiOptions();
+  scoped_ptr<ScopedWifiOptions> scoped_options = SetWifiOptions(options);
+  EXPECT_EQ(previous_options | options, GetWifiOptions());
+  scoped_options.reset();
+  EXPECT_EQ(previous_options, GetWifiOptions());
+}
+
+};  // namespace
+
+// Test SetWifiOptions().
+TEST(NetUtilTest, SetWifiOptionsTest) {
+  TryChangeWifiOptions(0);
+  TryChangeWifiOptions(WIFI_OPTIONS_DISABLE_SCAN);
+  TryChangeWifiOptions(WIFI_OPTIONS_MEDIA_STREAMING_MODE);
+  TryChangeWifiOptions(WIFI_OPTIONS_DISABLE_SCAN |
+                       WIFI_OPTIONS_MEDIA_STREAMING_MODE);
+}
+
 struct NonUniqueNameTestData {
   bool is_unique;
   const char* hostname;
 };
 
 // Google Test pretty-printer.
 void PrintTo(const NonUniqueNameTestData& data, std::ostream* os) {
   ASSERT_TRUE(data.hostname);
   *os << " hostname: " << testing::PrintToString(data.hostname)
       << "; is_unique: " << testing::PrintToString(data.is_unique);
@@ skipping 61 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