Refactor the state-machine & threading out of the windows wifi provider into ...

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 61 matching lines @@
 
 // WlanFreeMemory
 typedef VOID (WINAPI *WlanFreeMemoryFunction)(PVOID pMemory);
 
 // WlanCloseHandle
 typedef DWORD (WINAPI *WlanCloseHandleFunction)(HANDLE hClientHandle,
                                                 PVOID pReserved);
 
 
 // Local classes and functions
-class WindowsWlanApi : public Win32WifiDataProvider::WlanApiInterface {
+class WindowsWlanApi : public WifiDataProviderCommon::WlanApiInterface {
  public:
   ~WindowsWlanApi();
   // Factory function. Will return NULL if this API is unavailable.
   static WindowsWlanApi* Create();
 
   // WlanApiInterface
   virtual bool GetAccessPointData(WifiData::AccessPointDataSet *data);
 
  private:
   // Takes ownership of the library handle.
   explicit WindowsWlanApi(HINSTANCE library);
 
   // Loads the required functions from the DLL.
   void GetWLANFunctions(HINSTANCE wlan_library);
   int GetInterfaceDataWLAN(HANDLE wlan_handle,
                            const GUID &interface_id,
                            WifiData::AccessPointDataSet *data);
 
   // Handle to the wlanapi.dll library.
   HINSTANCE library_;
 
   // Function pointers for WLAN
   WlanOpenHandleFunction WlanOpenHandle_function_;
   WlanEnumInterfacesFunction WlanEnumInterfaces_function_;
   WlanGetNetworkBssListFunction WlanGetNetworkBssList_function_;
   WlanFreeMemoryFunction WlanFreeMemory_function_;
   WlanCloseHandleFunction WlanCloseHandle_function_;
 };
 
-class WindowsNdisApi : public Win32WifiDataProvider::WlanApiInterface {
+class WindowsNdisApi : public WifiDataProviderCommon::WlanApiInterface {
  public:
   ~WindowsNdisApi();
   static WindowsNdisApi* Create();
 
   // WlanApiInterface
   virtual bool GetAccessPointData(WifiData::AccessPointDataSet *data);
 
  private:
   static bool GetInterfacesNDIS(
       std::vector<string16>* interface_service_names_out);
@@ skipping 29 matching lines @@
 // Gets the system directory and appends a trailing slash if not already
 // present.
 bool GetSystemDirectory(string16 *path);
 }  // namespace
 
 template<>
 WifiDataProviderImplBase* WifiDataProvider::DefaultFactoryFunction() {
   return new Win32WifiDataProvider();
 }
 
-Win32WifiDataProvider::Win32WifiDataProvider()
-    : Thread(__FILE__),
-      is_first_scan_complete_(false),
-      ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)) {
+Win32WifiDataProvider::Win32WifiDataProvider() {
 }
 
 Win32WifiDataProvider::~Win32WifiDataProvider() {
-  // Thread must be stopped before entering destructor chain to avoid race
-  // conditions; see comment in DeviceDataProvider::Unregister.
-  DCHECK(!IsRunning()) << "Must call StopDataProvider before destroying me";
 }
 
-void Win32WifiDataProvider::inject_mock_wlan_api(WlanApiInterface* wlan_api) {
-  DCHECK(wlan_api_ == NULL);
-  DCHECK(wlan_api);
-  wlan_api_.reset(wlan_api);
+WifiDataProviderCommon::WlanApiInterface* Win32WifiDataProvider::NewWlanApi() {
+  // Use the WLAN interface if we're on Vista and if it's available. Otherwise,
+  // use NDIS.
+  WlanApiInterface* api = WindowsWlanApi::Create();
+  if (api) {
+    return api;
+  }
+  return WindowsNdisApi::Create();
 }
 
-void Win32WifiDataProvider::inject_mock_polling_policy(
-    PollingPolicyInterface* policy) {
-  DCHECK(polling_policy_ == NULL);
-  DCHECK(policy);
-  polling_policy_.reset(policy);
-}
-
-bool Win32WifiDataProvider::StartDataProvider() {
-  DCHECK(CalledOnClientThread());
-  return Start();
-}
-
-void Win32WifiDataProvider::StopDataProvider() {
-  DCHECK(CalledOnClientThread());
-  Stop();
-}
-
-bool Win32WifiDataProvider::GetData(WifiData *data) {
-  DCHECK(CalledOnClientThread());
-  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>);
-  }
-  DCHECK(polling_policy_ != NULL);
-
-  ScheduleNextScan();
-}
-
-void Win32WifiDataProvider::CleanUp() {
-  // Destroy the wlan api instance in the thread in which it was created.
-  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 || !is_first_scan_complete_) {
-      is_first_scan_complete_ = true;
-      NotifyListeners();
-    }
-  }
-  ScheduleNextScan();
-}
-
-void Win32WifiDataProvider::ScheduleNextScan() {
-  message_loop()->PostDelayedTask(FROM_HERE,
-      task_factory_.NewRunnableMethod(&Win32WifiDataProvider::DoWifiScanTask),
-      polling_policy_->PollingInterval());
+PollingPolicyInterface* Win32WifiDataProvider::NewPolicyPolicy() {
+  return new GenericPollingPolicy<kDefaultPollingInterval,
+                                  kNoChangePollingInterval,
+                                  kTwoNoChangePollingInterval>;
 }
 
 // Local classes and functions
 namespace {
 
 // WindowsWlanApi
 WindowsWlanApi::WindowsWlanApi(HINSTANCE library)
     : library_(library) {
   GetWLANFunctions(library_);
 }
@@ skipping 361 matching lines @@
                        buffer,
                        buffer_size,
                        bytes_out,
                        NULL)) {
     return GetLastError();
   }
   return ERROR_SUCCESS;
 }
 
 bool ResizeBuffer(int requested_size, scoped_ptr_malloc<BYTE>* buffer) {
-  DCHECK(requested_size > 0);
+  DCHECK_GT(requested_size, 0);
   DCHECK(buffer);
   if (requested_size > kMaximumBufferSize) {
     buffer->reset();
     return false;
   }
 
   buffer->reset(reinterpret_cast<BYTE*>(
       realloc(buffer->release(), requested_size)));
   return buffer != NULL;
 }
@@ skipping 16 matching lines @@
 
   path->assign(buffer);
   delete[] buffer;
 
   if (path->at(path->length() - 1) != L'\\') {
     path->append(L"\\");
   }
   return true;
 }
 }  // namespace