Remove requesting_frame parameters from Geolocation stack

content/browser/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 "content/browser/geolocation/network_location_provider.h"
 
 #include "base/bind.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "content/public/browser/access_token_store.h"
@@ skipping 98 matching lines @@
     AccessTokenStore* access_token_store,
     net::URLRequestContextGetter* url_context_getter,
     const GURL& url,
     const string16& access_token)
     : access_token_store_(access_token_store),
       radio_data_provider_(NULL),
       wifi_data_provider_(NULL),
       is_radio_data_complete_(false),
       is_wifi_data_complete_(false),
       access_token_(access_token),
+      is_permission_granted_(false),
       is_new_data_available_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   // Create the position cache.
   position_cache_.reset(new PositionCache());
 
   request_.reset(new NetworkLocationRequest(url_context_getter, url, this));
 }
 
 NetworkLocationProvider::~NetworkLocationProvider() {
   StopProvider();
 }
 
 // LocationProviderBase implementation
 void NetworkLocationProvider::GetPosition(Geoposition *position) {
   DCHECK(position);
   *position = position_;
 }
 
 void NetworkLocationProvider::UpdatePosition() {
   // TODO(joth): When called via the public (base class) interface, this should
   // poke each data provider to get them to expedite their next scan.
   // Whilst in the delayed start, only send request if all data is ready.
   if (!weak_factory_.HasWeakPtrs() ||
       (is_radio_data_complete_ && is_wifi_data_complete_)) {
     RequestPosition();
   }
 }
 
-void NetworkLocationProvider::OnPermissionGranted(
-    const GURL& requesting_frame) {
-  const bool host_was_empty = most_recent_authorized_host_.empty();
-  most_recent_authorized_host_ = requesting_frame.host();
-  if (host_was_empty && !most_recent_authorized_host_.empty()
-      && IsStarted()) {
+void NetworkLocationProvider::OnPermissionGranted() {
+  const bool was_permission_granted = is_permission_granted_;
+  is_permission_granted_ = true;
+  if (!was_permission_granted && IsStarted()) {
     UpdatePosition();
   }
 }
 
 // DeviceDataProviderInterface::ListenerInterface implementation.
 void NetworkLocationProvider::DeviceDataUpdateAvailable(
     RadioDataProvider* provider) {
   DCHECK(provider == radio_data_provider_);
   is_radio_data_complete_ = radio_data_provider_->GetData(&radio_data_);
   OnDeviceDataUpdated();
@@ skipping 87 matching lines @@
     // The timestamp of a position fix is determined by the timestamp
     // of the source data update. (The value of position_.timestamp from
     // the cache could be from weeks ago!)
     position_.timestamp = device_data_updated_timestamp_;
     is_new_data_available_ = false;
     // Let listeners know that we now have a position available.
     UpdateListeners();
     return;
   }
   // Don't send network requests until authorized. http://crbug.com/39171
-  if (most_recent_authorized_host_.empty())
+  if (!is_permission_granted_)
     return;
 
   weak_factory_.InvalidateWeakPtrs();
   is_new_data_available_ = false;
 
   // TODO(joth): Rather than cancel pending requests, we should create a new
   // NetworkLocationRequest for each and hold a set of pending requests.
   if (request_->is_request_pending()) {
     DVLOG(1) << "NetworkLocationProvider - pre-empting pending network request "
                 "with new data. Wifi APs: "
              << wifi_data_.access_point_data.size();
   }
-  // The hostname sent in the request is just to give a first-order
-  // approximation of usage. We do not need to guarantee that this network
-  // request was triggered by an API call from this specific host.
-  request_->MakeRequest(most_recent_authorized_host_, access_token_,
+  request_->MakeRequest(access_token_,
                         radio_data_, wifi_data_,
                         device_data_updated_timestamp_);
 }
 
 void NetworkLocationProvider::OnDeviceDataUpdated() {
   DCHECK(CalledOnValidThread());
   device_data_updated_timestamp_ = base::Time::Now();
 
   is_new_data_available_ = is_radio_data_complete_ || is_wifi_data_complete_;
   UpdatePosition();
 }
 
 bool NetworkLocationProvider::IsStarted() const {
   DCHECK_EQ(!!radio_data_provider_, !!wifi_data_provider_);
   return wifi_data_provider_ != NULL;
 }