Remove requesting_frame parameters from Geolocation stack

content/browser/geolocation/geolocation_provider.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/geolocation_provider.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/singleton.h"
 #include "base/threading/thread_restrictions.h"
 #include "content/browser/geolocation/location_arbitrator.h"
@@ skipping 34 matching lines @@
   DCHECK(OnClientThread());
   base::Closure task;
   if (observers_.empty()) {
     DCHECK(IsRunning());
     task = base::Bind(&GeolocationProvider::StopProviders,
                       base::Unretained(this));
   } else {
     if (!IsRunning()) {
       Start();
       if (HasPermissionBeenGranted())
-        InformProvidersPermissionGranted(most_recent_authorized_frame_);
+        InformProvidersPermissionGranted();
     }
 
     // The high accuracy requirement may have changed.
     task = base::Bind(&GeolocationProvider::StartProviders,
                       base::Unretained(this),
                       GeolocationObserverOptions::Collapse(observers_));
   }
 
   message_loop()->PostTask(FROM_HERE, task);
 }
@@ skipping 17 matching lines @@
   DCHECK(arbitrator_);
   arbitrator_->StartProviders(options);
 }
 
 void GeolocationProvider::StopProviders() {
   DCHECK(OnGeolocationThread());
   DCHECK(arbitrator_);
   arbitrator_->StopProviders();
 }
 
-void GeolocationProvider::OnPermissionGranted(const GURL& requesting_frame) {
+void GeolocationProvider::OnPermissionGranted() {
   DCHECK(OnClientThread());
-  most_recent_authorized_frame_ = requesting_frame;
+  is_permission_granted_ = true;

[John Knottenbelt, 2012/04/20 09:40:37]

is_permission_granted_ needs to be initialised to false, probably in the
constructor.

[bartfab (slow), 2012/04/20 09:44:29]

Done.

   if (IsRunning())
-    InformProvidersPermissionGranted(requesting_frame);
+    InformProvidersPermissionGranted();
 }
 
-void GeolocationProvider::InformProvidersPermissionGranted(
-    const GURL& requesting_frame) {
+void GeolocationProvider::InformProvidersPermissionGranted() {
   DCHECK(IsRunning());
-  DCHECK(requesting_frame.is_valid());
   if (!OnGeolocationThread()) {
     message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&GeolocationProvider::InformProvidersPermissionGranted,
-                   base::Unretained(this), requesting_frame));
+                   base::Unretained(this)));
     return;
   }
   DCHECK(OnGeolocationThread());
   DCHECK(arbitrator_);
-  arbitrator_->OnPermissionGranted(requesting_frame);
+  arbitrator_->OnPermissionGranted();
 }
 
 void GeolocationProvider::Init() {
   DCHECK(OnGeolocationThread());
   DCHECK(!arbitrator_);
   arbitrator_ = GeolocationArbitrator::Create(this);
 }
 
 void GeolocationProvider::CleanUp() {
   DCHECK(OnGeolocationThread());
   delete arbitrator_;
   arbitrator_ = NULL;
 }
 
 void GeolocationProvider::OnLocationUpdate(const Geoposition& position) {
   DCHECK(OnGeolocationThread());
   client_loop_->PostTask(
       FROM_HERE,
       base::Bind(&GeolocationProvider::NotifyObservers,
                  base::Unretained(this), position));
 }
 
 bool GeolocationProvider::HasPermissionBeenGranted() const {
   DCHECK(OnClientThread());
-  return most_recent_authorized_frame_.is_valid();
+  return is_permission_granted_;
 }
 
 bool GeolocationProvider::OnClientThread() const {
   return client_loop_->BelongsToCurrentThread();
 }
 
 bool GeolocationProvider::OnGeolocationThread() const {
   return MessageLoop::current() == message_loop();
 }