Prevent NetworkLocationProvider from sending wifi data if started low accuracy

device/geolocation/network_location_provider.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 "device/geolocation/network_location_provider.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 132 matching lines @@
 void NetworkLocationProvider::OnPermissionGranted() {
   const bool was_permission_granted = is_permission_granted_;
   is_permission_granted_ = true;
   if (!was_permission_granted && IsStarted())
     RequestPosition();
 }
 
 void NetworkLocationProvider::OnWifiDataUpdate() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(IsStarted());
+
+  if (!high_accuracy_enabled_) {
+    // This should never be called if this provider was started with low
+    // accuracy.
+    NOTREACHED();
+    wifi_data_.access_point_data.clear();
+    return;
+  }
+
   is_wifi_data_complete_ = wifi_data_provider_manager_->GetData(&wifi_data_);
   if (!is_wifi_data_complete_)
     return;
 
   wifi_timestamp_ = base::Time::Now();
   is_new_data_available_ = true;
   RequestPosition();
 }
 
 void NetworkLocationProvider::OnLocationResponse(
@@ skipping 13 matching lines @@
     access_token_store_->SaveAccessToken(request_->url(), access_token);
   }
 
   // Let listeners know that we now have a position available.
   if (!location_provider_update_callback_.is_null())
     location_provider_update_callback_.Run(this, position_);
 }
 
 bool NetworkLocationProvider::StartProvider(bool high_accuracy) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (IsStarted())

[blundell, 2017/05/31 14:49:35]

Here you're never changing the accuracy once the NetworkLocationProvider is
first started. So if a second client came along and wanted Wifi data they
wouldn't get it.

     return true;
   if (!request_->url().is_valid())
     return false;
 
+  is_started_ = true;
+  high_accuracy_enabled_ = high_accuracy;
+
+  if (!high_accuracy_enabled_) {
+    RequestPosition();
+    return true;
+  }
+
   // Registers a callback with the data provider. The first call to Register()
   // will create a singleton data provider that will be deleted on Unregister().
   wifi_data_provider_manager_ =
       WifiDataProviderManager::Register(&wifi_data_update_callback_);
 
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&NetworkLocationProvider::RequestPosition,
                             weak_factory_.GetWeakPtr()),
       base::TimeDelta::FromSeconds(kDataCompleteWaitSeconds));
 
   OnWifiDataUpdate();
   return true;
 }
 
 void NetworkLocationProvider::StopProvider() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(IsStarted());
-  wifi_data_provider_manager_->Unregister(&wifi_data_update_callback_);
-  wifi_data_provider_manager_ = nullptr;
+  if (high_accuracy_enabled_) {
+    wifi_data_provider_manager_->Unregister(&wifi_data_update_callback_);
+    wifi_data_provider_manager_ = nullptr;
+  }
   weak_factory_.InvalidateWeakPtrs();
+  is_started_ = false;
 }
 
 const Geoposition& NetworkLocationProvider::GetPosition() {
   return position_;
 }
 
 void NetworkLocationProvider::RequestPosition() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  if (!is_new_data_available_ || !is_wifi_data_complete_)
-    return;
-  DCHECK(!wifi_timestamp_.is_null())
-      << "|wifi_timestamp_| must be set before looking up position";
+  if (high_accuracy_enabled_) {
+    if (!is_new_data_available_ || !is_wifi_data_complete_)
+      return;
+
+    DCHECK(!wifi_timestamp_.is_null())
+        << "|wifi_timestamp_| must be set before looking up position";
+  } else {
+    wifi_timestamp_ = base::Time::Now();
+    wifi_data_.access_point_data.clear();
+  }
 
   const Geoposition* cached_position =
       position_cache_->FindPosition(wifi_data_);
   if (cached_position) {
     DCHECK(cached_position->Validate());
     // Record the position and update its timestamp.
     position_ = *cached_position;
 
     // The timestamp of a position fix is determined by the timestamp
     // of the source data update. (The value of position_.timestamp from
@@ skipping 16 matching lines @@
   // NetworkLocationRequest for each and hold a set of pending requests.
   DLOG_IF(WARNING, request_->is_request_pending())
       << "NetworkLocationProvider - pre-empting pending network request "
          "with new data. Wifi APs: "
       << wifi_data_.access_point_data.size();
 
   request_->MakeRequest(access_token_, wifi_data_, wifi_timestamp_);
 }
 
 bool NetworkLocationProvider::IsStarted() const {
-  return wifi_data_provider_manager_ != nullptr;
+  return is_started_;
 }
 
 }  // namespace device