Port the gears geolocation network provider to Chromium...

chrome/browser/geolocation/wifi_data_provider_win.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.
 
 // Windows Vista uses the Native Wifi (WLAN) API for accessing WiFi cards. See
 // http://msdn.microsoft.com/en-us/library/ms705945(VS.85).aspx. Windows XP
 // Service Pack 3 (and Windows XP Service Pack 2, if upgraded with a hot fix)
 // also support a limited version of the WLAN API. See
 // http://msdn.microsoft.com/en-us/library/bb204766.aspx. The WLAN API uses
 // wlanapi.h, which is not part of the SDK used by Gears, so is replicated
@@ skipping 12 matching lines @@
 
 #include "chrome/browser/geolocation/wifi_data_provider_win.h"
 
 #include <windows.h>
 #include <winioctl.h>
 #include <wlanapi.h>
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/geolocation/wifi_data_provider_common.h"
 #include "chrome/browser/geolocation/wifi_data_provider_common_win.h"
 
-#ifdef _MSC_VER
-#pragma warning(disable:4355)  // 'this' : used in base member initializer list
-#endif
-
 // Taken from ndis.h for WinCE.
 #define NDIS_STATUS_INVALID_LENGTH   ((NDIS_STATUS)0xC0010014L)
 #define NDIS_STATUS_BUFFER_TOO_SHORT ((NDIS_STATUS)0xC0010016L)
 
 namespace {
 // The limits on the size of the buffer used for the OID query.
 const int kInitialBufferSize = 2 << 12;  // Good for about 50 APs.
 const int kMaximumBufferSize = 2 << 20;  // 2MB
 
 // Length for generic string buffers passed to Win32 APIs.
@@ skipping 112 matching lines @@
 }  // namespace
 
 template<>
 WifiDataProviderImplBase *WifiDataProvider::DefaultFactoryFunction() {
   return new Win32WifiDataProvider();
 }
 
 Win32WifiDataProvider::Win32WifiDataProvider()
     : Thread(__FILE__),
       is_first_scan_complete_(false),
-      task_factory_(this) {
+      ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)) {
 }
 
 Win32WifiDataProvider::~Win32WifiDataProvider() {
   // Base class auto-stops the thread, however we need to do it here so our
   // override of CleanUp still exists whilst the thread is shutting down.
   Stop();
 }
 
 void Win32WifiDataProvider::inject_mock_wlan_api(WlanApiInterface* wlan_api) {
-  assert(wlan_api_ == NULL);
-  assert(wlan_api);
+  DCHECK(wlan_api_ == NULL);
+  DCHECK(wlan_api);
   wlan_api_.reset(wlan_api);
 }
 
 void Win32WifiDataProvider::inject_mock_polling_policy(
     PollingPolicyInterface* policy) {
-  assert(polling_policy_ == NULL);
-  assert(policy);
+  DCHECK(polling_policy_ == NULL);
+  DCHECK(policy);
   polling_policy_.reset(policy);
 }
 
 bool Win32WifiDataProvider::StartDataProvider() {
   return base::Thread::Start();
 }
 
 bool Win32WifiDataProvider::GetData(WifiData *data) {
-  assert(data);
+  DCHECK(data);
   AutoLock lock(data_mutex_);
   *data = wifi_data_;
   // If we've successfully completed a scan, indicate that we have all of the
   // data we can get.
   return is_first_scan_complete_;
 }
 
 // Thread implementation
 void Win32WifiDataProvider::Init() {
   // Use the WLAN interface if we're on Vista and if it's available. Otherwise,
   // use NDIS.
   if (wlan_api_ == NULL) {
     wlan_api_.reset(WindowsWlanApi::Create());
   }
   if (wlan_api_ == NULL) {
     wlan_api_.reset(WindowsNdisApi::Create());
   }
   if (wlan_api_ == NULL) {
     // Error! Can't do scans, so don't try and schedule one.
     is_first_scan_complete_ = true;
     return;
   }
 
   if (polling_policy_ == NULL) {
     polling_policy_.reset(
         new GenericPollingPolicy<kDefaultPollingInterval,
                                  kNoChangePollingInterval,
                                  kTwoNoChangePollingInterval>);
   }
-  assert(polling_policy_ != NULL);
+  DCHECK(polling_policy_ != NULL);
 
   ScheduleNextScan();
 }
 
 void Win32WifiDataProvider::CleanUp() {
   // Destroy the wlan api instance in the thread in which it was created.
-  wlan_api_.reset(NULL);
+  wlan_api_.reset();
 }
 
 void Win32WifiDataProvider::DoWifiScanTask() {
+  // TODO(joth): Almost all of this is shareable across platforms.
   WifiData new_data;
   if (wlan_api_->GetAccessPointData(&new_data.access_point_data)) {
     bool update_available;
     data_mutex_.Acquire();
     update_available = wifi_data_.DiffersSignificantly(new_data);
     wifi_data_ = new_data;
     data_mutex_.Release();
     polling_policy_->UpdatePollingInterval(update_available);
-    if (update_available) {
+    if (update_available || !is_first_scan_complete_) {
       is_first_scan_complete_ = true;
       NotifyListeners();
     }
   }
   ScheduleNextScan();
 }
 
 void Win32WifiDataProvider::ScheduleNextScan() {
   message_loop()->PostDelayedTask(FROM_HERE,
       task_factory_.NewRunnableMethod(&Win32WifiDataProvider::DoWifiScanTask),
@@ skipping 15 matching lines @@
 
 WindowsWlanApi* WindowsWlanApi::Create() {
   // We use an absolute path to load the DLL to avoid DLL preloading attacks.
   string16 system_directory;
   if (!IsRunningOnVistaOrNewer()) {
     return NULL;
   }
   if (!GetSystemDirectory(&system_directory)) {
     return NULL;
   }
-  assert(!system_directory.empty());
+  DCHECK(!system_directory.empty());
   string16 dll_path = system_directory + L"wlanapi.dll";
   HINSTANCE library = LoadLibraryEx(dll_path.c_str(),
                                     NULL,
                                     LOAD_WITH_ALTERED_SEARCH_PATH);
   if (!library) {
     return NULL;
   }
   return new WindowsWlanApi(library);
 }
 
 void WindowsWlanApi::GetWLANFunctions(HINSTANCE wlan_library) {
-  assert(wlan_library);
+  DCHECK(wlan_library);
   WlanOpenHandle_function_ = reinterpret_cast<WlanOpenHandleFunction>(
       GetProcAddress(wlan_library, "WlanOpenHandle"));
   WlanEnumInterfaces_function_ = reinterpret_cast<WlanEnumInterfacesFunction>(
       GetProcAddress(wlan_library, "WlanEnumInterfaces"));
   WlanGetNetworkBssList_function_ =
       reinterpret_cast<WlanGetNetworkBssListFunction>(
       GetProcAddress(wlan_library, "WlanGetNetworkBssList"));
   WlanFreeMemory_function_ = reinterpret_cast<WlanFreeMemoryFunction>(
       GetProcAddress(wlan_library, "WlanFreeMemory"));
   WlanCloseHandle_function_ = reinterpret_cast<WlanCloseHandleFunction>(
       GetProcAddress(wlan_library, "WlanCloseHandle"));
-  assert(WlanOpenHandle_function_ &&
+  DCHECK(WlanOpenHandle_function_ &&
          WlanEnumInterfaces_function_ &&
          WlanGetNetworkBssList_function_ &&
          WlanFreeMemory_function_ &&
          WlanCloseHandle_function_);
 }
 
 bool WindowsWlanApi::GetAccessPointData(
     WifiData::AccessPointDataSet *data) {
-  assert(data);
+  DCHECK(data);
 
   // Get the handle to the WLAN API.
   DWORD negotiated_version;
   HANDLE wlan_handle = NULL;
   // We could be executing on either Windows XP or Windows Vista, so use the
   // lower version of the client WLAN API. It seems that the negotiated version
   // is the Vista version irrespective of what we pass!
   static const int kXpWlanClientVersion = 1;
   if ((*WlanOpenHandle_function_)(kXpWlanClientVersion,
                                   NULL,
                                   &negotiated_version,
                                   &wlan_handle) != ERROR_SUCCESS) {
     return false;
   }
-  assert(wlan_handle);
+  DCHECK(wlan_handle);
 
   // Get the list of interfaces. WlanEnumInterfaces allocates interface_list.
   WLAN_INTERFACE_INFO_LIST *interface_list = NULL;
   if ((*WlanEnumInterfaces_function_)(wlan_handle, NULL, &interface_list) !=
       ERROR_SUCCESS) {
     return false;
   }
-  assert(interface_list);
+  DCHECK(interface_list);
 
   // Go through the list of interfaces and get the data for each.
   for (int i = 0; i < static_cast<int>(interface_list->dwNumberOfItems); ++i) {
     GetInterfaceDataWLAN(wlan_handle,
                          interface_list->InterfaceInfo[i].InterfaceGuid,
                          data);
   }
 
   // Free interface_list.
   (*WlanFreeMemory_function_)(interface_list);
 
   // Close the handle.
   if ((*WlanCloseHandle_function_)(wlan_handle, NULL) != ERROR_SUCCESS) {
     return false;
   }
 
   return true;
 }
 
 // Appends the data for a single interface to the data vector. Returns the
 // number of access points found, or -1 on error.
 int WindowsWlanApi::GetInterfaceDataWLAN(
     const HANDLE wlan_handle,
     const GUID &interface_id,
     WifiData::AccessPointDataSet *data) {
-  assert(data);
+  DCHECK(data);
   // WlanGetNetworkBssList allocates bss_list.
   WLAN_BSS_LIST *bss_list;
   if ((*WlanGetNetworkBssList_function_)(wlan_handle,
                                          &interface_id,
                                          NULL,   // Use all SSIDs.
                                          dot11_BSS_type_any,
                                          false,  // bSecurityEnabled - unused
                                          NULL,   // reserved
                                          &bss_list) != ERROR_SUCCESS) {
     return -1;
@@ skipping 10 matching lines @@
 
   (*WlanFreeMemory_function_)(bss_list);
 
   return found;
 }
 
 // WindowsNdisApi
 WindowsNdisApi::WindowsNdisApi(
     std::vector<string16>* interface_service_names)
     : oid_buffer_size_(kInitialBufferSize) {
-  assert(!interface_service_names->empty());
+  DCHECK(!interface_service_names->empty());
   interface_service_names_.swap(*interface_service_names);
 }
 
 WindowsNdisApi::~WindowsNdisApi() {
 }
 
 WindowsNdisApi* WindowsNdisApi::Create() {
   std::vector<string16> interface_service_names;
   if (GetInterfacesNDIS(&interface_service_names)) {
     return new WindowsNdisApi(&interface_service_names);
   }
   return NULL;
 }
 
 bool WindowsNdisApi::GetAccessPointData(WifiData::AccessPointDataSet *data) {
-  assert(data);
+  DCHECK(data);
   int interfaces_failed = 0;
   int interfaces_succeeded = 0;
 
   for (int i = 0; i < static_cast<int>(interface_service_names_.size()); ++i) {
     // First, check that we have a DOS device for this adapter.
     if (!DefineDosDeviceIfNotExists(interface_service_names_[i])) {
       continue;
     }
 
     // Get the handle to the device. This will fail if the named device is not
@@ skipping 24 matching lines @@
     std::vector<string16>* interface_service_names_out) {
   HKEY network_cards_key = NULL;
   if (RegOpenKeyEx(
       HKEY_LOCAL_MACHINE,
       L"Software\\Microsoft\\Windows NT\\CurrentVersion\\NetworkCards",
       0,
       KEY_READ,
       &network_cards_key) != ERROR_SUCCESS) {
     return false;
   }
-  assert(network_cards_key);
+  DCHECK(network_cards_key);
 
   for (int i = 0; ; ++i) {
     TCHAR name[kStringLength];
     DWORD name_size = kStringLength;
     FILETIME time;
     if (RegEnumKeyEx(network_cards_key,
                      i,
                      name,
                      &name_size,
                      NULL,
                      NULL,
                      NULL,
                      &time) != ERROR_SUCCESS) {
       break;
     }
     HKEY hardware_key = NULL;
     if (RegOpenKeyEx(network_cards_key, name, 0, KEY_READ, &hardware_key) !=
         ERROR_SUCCESS) {
       break;
     }
-    assert(hardware_key);
+    DCHECK(hardware_key);
 
     TCHAR service_name[kStringLength];
     DWORD service_name_size = kStringLength;
     DWORD type = 0;
     if (RegQueryValueEx(hardware_key,
                         L"ServiceName",
                         NULL,
                         &type,
                         reinterpret_cast<LPBYTE>(service_name),
                         &service_name_size) == ERROR_SUCCESS) {
       interface_service_names_out->push_back(service_name);
     }
     RegCloseKey(hardware_key);
   }
 
   RegCloseKey(network_cards_key);
   return true;
 }
 
 
 bool WindowsNdisApi::GetInterfaceDataNDIS(HANDLE adapter_handle,
                                           WifiData::AccessPointDataSet *data) {
-  assert(data);
+  DCHECK(data);
 
   scoped_ptr_malloc<BYTE> buffer(
       reinterpret_cast<BYTE*>(malloc(oid_buffer_size_)));
   if (buffer == NULL) {
     return false;
   }
 
   DWORD bytes_out;
   int result;
 
@@ skipping 15 matching lines @@
       }
       if (!ResizeBuffer(oid_buffer_size_, &buffer)) {
         oid_buffer_size_ = kInitialBufferSize;  // Reset for next time.
         return false;
       }
     } else {
       // The buffer is not too small.
       break;
     }
   }
-  assert(buffer.get());
+  DCHECK(buffer.get());
 
   if (result == ERROR_SUCCESS) {
     NDIS_802_11_BSSID_LIST* bssid_list =
         reinterpret_cast<NDIS_802_11_BSSID_LIST*>(buffer.get());
     GetDataFromBssIdList(*bssid_list, oid_buffer_size_, data);
   }
 
   return true;
 }
 
 bool IsRunningOnVistaOrNewer() {
   OSVERSIONINFO info = {0};
   info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
   GetVersionEx(&info);
   return (info.dwMajorVersion >=6);
 }
 
 bool GetNetworkData(const WLAN_BSS_ENTRY &bss_entry,
                            AccessPointData *access_point_data) {
   // Currently we get only MAC address, signal strength and SSID.
-  assert(access_point_data);
+  DCHECK(access_point_data);
   access_point_data->mac_address = MacAddressAsString16(bss_entry.dot11Bssid);
   access_point_data->radio_signal_strength = bss_entry.lRssi;
   // bss_entry.dot11Ssid.ucSSID is not null-terminated.
   UTF8ToUTF16(reinterpret_cast<const char*>(bss_entry.dot11Ssid.ucSSID),
               static_cast<ULONG>(bss_entry.dot11Ssid.uSSIDLength),
               &access_point_data->ssid);
   // TODO(steveblock): Is it possible to get the following?
   // access_point_data->signal_to_noise
   // access_point_data->age
   // access_point_data->channel
@@ skipping 61 matching lines @@
                        buffer,
                        buffer_size,
                        bytes_out,
                        NULL)) {
     return GetLastError();
   }
   return ERROR_SUCCESS;
 }
 
 bool ResizeBuffer(int requested_size, scoped_ptr_malloc<BYTE>* buffer) {
-  assert(requested_size > 0);
-  assert(buffer);
+  DCHECK(requested_size > 0);
+  DCHECK(buffer);
   if (requested_size > kMaximumBufferSize) {
-    buffer->reset(NULL);
+    buffer->reset();
     return false;
   }
 
   buffer->reset(reinterpret_cast<BYTE*>(
       realloc(buffer->release(), requested_size)));
   return buffer != NULL;
 }
 
 bool GetSystemDirectory(string16 *path) {
-  assert(path);
+  DCHECK(path);
   // Return value includes terminating NULL.
   int buffer_size = ::GetSystemDirectory(NULL, 0);
   if (buffer_size == 0) {
     return false;
   }
   char16 *buffer = new char16[buffer_size];
 
   // Return value excludes terminating NULL.
   int characters_written = ::GetSystemDirectory(buffer, buffer_size);
   if (characters_written == 0) {
     return false;
   }
-  assert(characters_written == buffer_size - 1);
+  DCHECK(characters_written == buffer_size - 1);
 
   path->assign(buffer);
   delete[] buffer;
 
   if (path->at(path->length() - 1) != L'\\') {
     path->append(L"\\");
   }
   return true;
 }
 }  // namespace