Refactor WifiDataProviderChromeOs to implement WifiDataProviderImplBase directly and delegate the

scan occur on the UI thread as currently required by
Chromium OS.

BUG=chromium-os:13049
TEST=Existing

Review URL: http://codereview.chromium.org/6696022

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@78540 0039d316-1c4b-4281-b951-d872f2087c98

5 files changed, 125 insertions, 6 deletions

diff --git a/content/browser/geolocation/device_data_provider.h b/content/browser/geolocation/device_data_provider.h
index 1d13151..e0b2771 100644
--- a/content/browser/geolocation/device_data_provider.h
+++ b/content/browser/geolocation/device_data_provider.h
@@ -230,6 +230,10 @@ class DeviceDataProviderImplBase : public DeviceDataProviderImplBaseHack {
     return MessageLoop::current() == this->client_loop_;
   }
 
+  MessageLoop* client_loop() const {
+    return client_loop_;
+  }
+
  private:
   void NotifyListenersInClientLoop() {
     DCHECK(CalledOnClientThread());
diff --git a/content/browser/geolocation/wifi_data_provider_chromeos.cc b/content/browser/geolocation/wifi_data_provider_chromeos.cc
index 555f7ae..541fc3b1 100644
--- a/content/browser/geolocation/wifi_data_provider_chromeos.cc
+++ b/content/browser/geolocation/wifi_data_provider_chromeos.cc
@@ -9,6 +9,7 @@
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros/network_library.h"
+#include "content/browser/browser_thread.h"
 
 namespace {
 // The time periods between successive polls of the wifi data.
@@ -72,12 +73,49 @@ WifiDataProviderImplBase* WifiDataProvider::DefaultFactoryFunction() {
   return new WifiDataProviderChromeOs();
 }
 
-WifiDataProviderChromeOs::WifiDataProviderChromeOs() {
+WifiDataProviderChromeOs::WifiDataProviderChromeOs() :
+    started_(false) {
 }
 
 WifiDataProviderChromeOs::~WifiDataProviderChromeOs() {
 }
 
+bool WifiDataProviderChromeOs::StartDataProvider() {
+  DCHECK(CalledOnClientThread());
+  DCHECK(!started_);
+  started_ = true;
+
+  wlan_api_.reset(NewWlanApi());
+  if (wlan_api_ == NULL) {
+    // Error! Can't do scans, so don't try and schedule one.
+    is_first_scan_complete_ = true;
+    return true;
+  }
+
+  DCHECK(polling_policy_ == NULL);
+  polling_policy_.reset(NewPollingPolicy());
+  DCHECK(polling_policy_ != NULL);
+
+  // Perform first scan ASAP regardless of the polling policy. If this scan
+  // fails we'll retry at a rate in line with the polling policy.
+  ScheduleNextScan(0);
+  return true;
+}
+
+void WifiDataProviderChromeOs::StopDataProvider() {
+  DCHECK(CalledOnClientThread());
+  started_ = false;
+  wlan_api_.reset();
+  polling_policy_.reset();
+}
+
+bool WifiDataProviderChromeOs::GetData(WifiData* data) {
+  DCHECK(CalledOnClientThread());
+  DCHECK(data);
+  *data = wifi_data_;
+  return is_first_scan_complete_;
+}
+
 WifiDataProviderCommon::WlanApiInterface*
     WifiDataProviderChromeOs::NewWlanApi(chromeos::NetworkLibrary* lib) {
   return new chromeos::NetworkLibraryWlanApi(lib);
@@ -98,3 +136,51 @@ PollingPolicyInterface* WifiDataProviderChromeOs::NewPollingPolicy() {
                                   kTwoNoChangePollingIntervalMilliseconds,
                                   kNoWifiPollingIntervalMilliseconds>;
 }
+
+void WifiDataProviderChromeOs::DoWifiScanTask() {
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  WifiData new_data;
+  if (!wlan_api_->GetAccessPointData(&new_data.access_point_data)) {
+    client_loop()->PostTask(FROM_HERE, NewRunnableMethod(
+        this, &WifiDataProviderChromeOs::DidWifiScanTaskNoResults));
+  }
+  else {
+    client_loop()->PostTask(FROM_HERE, NewRunnableMethod(
+        this, &WifiDataProviderChromeOs::DidWifiScanTask,
+        new_data));
+  }
+}
+
+void WifiDataProviderChromeOs::DidWifiScanTaskNoResults() {
+  DCHECK(CalledOnClientThread());
+  ScheduleNextScan(polling_policy_->NoWifiInterval());
+  MaybeNotifyListeners(false);
+}
+
+void WifiDataProviderChromeOs::DidWifiScanTask(const WifiData& new_data) {
+  DCHECK(CalledOnClientThread());
+  bool update_available = wifi_data_.DiffersSignificantly(new_data);
+  wifi_data_ = new_data;
+  polling_policy_->UpdatePollingInterval(update_available);
+  ScheduleNextScan(polling_policy_->PollingInterval());
+  MaybeNotifyListeners(update_available);
+}
+
+void WifiDataProviderChromeOs::MaybeNotifyListeners(bool update_available) {
+  if (update_available || !is_first_scan_complete_) {
+    is_first_scan_complete_ = true;
+    NotifyListeners();
+  }
+}
+
+void WifiDataProviderChromeOs::ScheduleNextScan(int interval) {
+  DCHECK(CalledOnClientThread());
+  if (started_) {
+    BrowserThread::PostDelayedTask(
+        BrowserThread::UI,
+        FROM_HERE,
+        NewRunnableMethod(this,
+                          &WifiDataProviderChromeOs::DoWifiScanTask),
+        interval);
+  }
+}
diff --git a/content/browser/geolocation/wifi_data_provider_chromeos.h b/content/browser/geolocation/wifi_data_provider_chromeos.h
index a3fbcf6..f350f01 100644
--- a/content/browser/geolocation/wifi_data_provider_chromeos.h
+++ b/content/browser/geolocation/wifi_data_provider_chromeos.h
@@ -12,20 +12,49 @@ namespace chromeos {
 class NetworkLibrary;
 }
 
-class WifiDataProviderChromeOs : public WifiDataProviderCommon {
+class WifiDataProviderChromeOs : public WifiDataProviderImplBase {
  public:
   WifiDataProviderChromeOs();
 
+  // WifiDataProviderImplBase
+  virtual bool StartDataProvider();
+  virtual void StopDataProvider();
+  virtual bool GetData(WifiData* data);
+
   // Allows injection of |lib| for testing.
-  static WlanApiInterface* NewWlanApi(chromeos::NetworkLibrary* lib);
+  static WifiDataProviderCommon::WlanApiInterface* NewWlanApi(
+      chromeos::NetworkLibrary* lib);
 
  private:
   virtual ~WifiDataProviderChromeOs();
 
+  // The polling task
+  void DoWifiScanTask();
+  void DidWifiScanTaskNoResults();
+  void DidWifiScanTask(const WifiData& new_data);
+  void MaybeNotifyListeners(bool update_available);
+
   // WifiDataProviderCommon
-  virtual WlanApiInterface* NewWlanApi();
+  virtual WifiDataProviderCommon::WlanApiInterface* NewWlanApi();
   virtual PollingPolicyInterface* NewPollingPolicy();
 
+  // Will schedule a scan; i.e. enqueue DoWifiScanTask deferred task.
+  void ScheduleNextScan(int interval);
+
+  // Underlying OS wifi API.
+  scoped_ptr<WifiDataProviderCommon::WlanApiInterface> wlan_api_;
+
+  // Controls the polling update interval.
+  scoped_ptr<PollingPolicyInterface> polling_policy_;
+
+  WifiData wifi_data_;
+
+  // Whether we have strated the data provider.
+  bool started_;
+
+  // Whether we've successfully completed a scan for WiFi data.
+  bool is_first_scan_complete_;
+
   DISALLOW_COPY_AND_ASSIGN(WifiDataProviderChromeOs);
 };
 
diff --git a/content/browser/geolocation/wifi_data_provider_common.cc b/content/browser/geolocation/wifi_data_provider_common.cc
index 1c9745f..5396095 100644
--- a/content/browser/geolocation/wifi_data_provider_common.cc
+++ b/content/browser/geolocation/wifi_data_provider_common.cc
@@ -39,7 +39,7 @@ void WifiDataProviderCommon::StopDataProvider() {
   Stop();
 }
 
-bool WifiDataProviderCommon::GetData(WifiData *data) {
+bool WifiDataProviderCommon::GetData(WifiData* data) {
   DCHECK(CalledOnClientThread());
   DCHECK(data);
   base::AutoLock lock(data_mutex_);
diff --git a/content/browser/geolocation/wifi_data_provider_common.h b/content/browser/geolocation/wifi_data_provider_common.h
index ac00b75..6952ce8 100644
--- a/content/browser/geolocation/wifi_data_provider_common.h
+++ b/content/browser/geolocation/wifi_data_provider_common.h
@@ -82,7 +82,7 @@ class WifiDataProviderCommon
   // WifiDataProviderImplBase implementation
   virtual bool StartDataProvider();
   virtual void StopDataProvider();
-  virtual bool GetData(WifiData *data);
+  virtual bool GetData(WifiData* data);
 
  protected:
   virtual ~WifiDataProviderCommon();