Remove requesting_frame parameters from Geolocation stack

content/browser/geolocation/location_arbitrator.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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/location_arbitrator.h"
 
 #include <map>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "content/browser/geolocation/arbitrator_dependency_factory.h"
 #include "content/public/browser/access_token_store.h"
+#include "googleurl/src/gurl.h"
 
 using content::AccessTokenStore;
 
 namespace {
 
 const char* kDefaultNetworkProviderUrl = "https://maps.googleapis.com/maps/api/browserlocation/json";
 GeolocationArbitratorDependencyFactory* g_dependency_factory_for_test = NULL;
 
 }  // namespace
 
 // To avoid oscillations, set this to twice the expected update interval of a
 // a GPS-type location provider (in case it misses a beat) plus a little.
 const int64 GeolocationArbitrator::kFixStaleTimeoutMilliseconds =
     11 * base::Time::kMillisecondsPerSecond;
 
 GeolocationArbitrator::GeolocationArbitrator(
     GeolocationArbitratorDependencyFactory* dependency_factory,
     GeolocationObserver* observer)
     : dependency_factory_(dependency_factory),
       access_token_store_(dependency_factory->NewAccessTokenStore()),
       get_time_now_(dependency_factory->GetTimeFunction()),
       observer_(observer),
-      position_provider_(NULL) {
+      position_provider_(NULL),
+      is_permission_granted_(false) {
 
 }
 
 GeolocationArbitrator::~GeolocationArbitrator() {
 }
 
 GeolocationArbitrator* GeolocationArbitrator::Create(
     GeolocationObserver* observer) {
   GeolocationArbitratorDependencyFactory* dependency_factory =
       g_dependency_factory_for_test ?
       g_dependency_factory_for_test :
       new DefaultGeolocationArbitratorDependencyFactory;
   GeolocationArbitrator* arbitrator =
       new GeolocationArbitrator(dependency_factory, observer);
   g_dependency_factory_for_test = NULL;
   return arbitrator;
 }
 
-void GeolocationArbitrator::OnPermissionGranted(
-    const GURL& requesting_frame) {
-  most_recent_authorized_frame_ = requesting_frame;
+void GeolocationArbitrator::OnPermissionGranted() {
+  is_permission_granted_ = true;
   for (ScopedVector<LocationProviderBase>::iterator i = providers_.begin();
       i != providers_.end(); ++i) {
-    (*i)->OnPermissionGranted(requesting_frame);
+    (*i)->OnPermissionGranted();
   }
 }
 
 void GeolocationArbitrator::StartProviders(
     const GeolocationObserverOptions& options) {
   // Stash options as OnAccessTokenStoresLoaded has not yet been called.
   current_provider_options_ = options;
   if (providers_.empty()) {
     DCHECK(GURL(kDefaultNetworkProviderUrl).is_valid());
     access_token_store_->LoadAccessTokens(
@@ skipping 36 matching lines @@
   }
   RegisterProvider(dependency_factory_->NewSystemLocationProvider());
   DoStartProviders();
 }
 
 void GeolocationArbitrator::RegisterProvider(
     LocationProviderBase* provider) {
   if (!provider)
     return;
   provider->RegisterListener(this);
-  if (most_recent_authorized_frame_.is_valid())
-    provider->OnPermissionGranted(most_recent_authorized_frame_);
+  if (is_permission_granted_)
+    provider->OnPermissionGranted();
   providers_->push_back(provider);
 }
 
 void GeolocationArbitrator::LocationUpdateAvailable(
     LocationProviderBase* provider) {
   DCHECK(provider);
   Geoposition new_position;
   provider->GetPosition(&new_position);
   DCHECK(new_position.IsInitialized());
   if (!IsNewPositionBetter(position_, new_position,
@@ skipping 24 matching lines @@
     } else if ((get_time_now_() - old_position.timestamp).InMilliseconds() >
                kFixStaleTimeoutMilliseconds) {
       // Existing fix is stale.
       return true;
     }
   }
   return false;
 }
 
 bool GeolocationArbitrator::HasPermissionBeenGranted() const {
-  return most_recent_authorized_frame_.is_valid();
+  return is_permission_granted_;
 }
 
 void GeolocationArbitrator::SetDependencyFactoryForTest(
     GeolocationArbitratorDependencyFactory* dependency_factory) {
   g_dependency_factory_for_test = dependency_factory;
 }