Do not send IPC message to cancel Geolocation permission.

content/browser/geolocation/geolocation_dispatcher_host.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/geolocation_dispatcher_host.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
@@ skipping 51 matching lines @@
   UMA_HISTOGRAM_ENUMERATION("Geolocation.LocationUpdate.ErrorCode",
                             code,
                             GEOPOSITION_ERROR_CODE_COUNT);
 }
 
 }  // namespace
 
 GeolocationDispatcherHost::PendingPermission::PendingPermission(
     int render_frame_id,
     int render_process_id,
-    int bridge_id)
+    int bridge_id,
+    const GURL& origin)
     : render_frame_id(render_frame_id),
       render_process_id(render_process_id),
-      bridge_id(bridge_id) {
+      bridge_id(bridge_id),
+      origin(origin) {
 }
 
 GeolocationDispatcherHost::PendingPermission::~PendingPermission() {
 }
 
 GeolocationDispatcherHost::GeolocationDispatcherHost(
     WebContents* web_contents)
     : WebContentsObserver(web_contents),
       paused_(false),
       weak_factory_(this) {
   // This is initialized by WebContentsImpl. Do not add any non-trivial
   // initialization here, defer to OnStartUpdating which is triggered whenever
   // a javascript geolocation object is actually initialized.
 }
 
 GeolocationDispatcherHost::~GeolocationDispatcherHost() {
 }
 
 void GeolocationDispatcherHost::RenderFrameDeleted(
     RenderFrameHost* render_frame_host) {
   OnStopUpdating(render_frame_host);
+
+  CancelPermissionRequestsForFrame(render_frame_host);
 }
 
 void GeolocationDispatcherHost::RenderViewHostChanged(
     RenderViewHost* old_host,
     RenderViewHost* new_host) {
   updating_frames_.clear();
   paused_ = false;
   geolocation_subscription_.reset();
 }
 
+void GeolocationDispatcherHost::DidNavigateAnyFrame(
+    RenderFrameHost* render_frame_host,
+    const LoadCommittedDetails& details,
+    const FrameNavigateParams& params) {
+  if (details.is_in_page)
+    return;
+
+  CancelPermissionRequestsForFrame(render_frame_host);
+}
+
 bool GeolocationDispatcherHost::OnMessageReceived(
     const IPC::Message& msg, RenderFrameHost* render_frame_host) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(GeolocationDispatcherHost, msg,
                                    render_frame_host)
     IPC_MESSAGE_HANDLER(GeolocationHostMsg_RequestPermission,
                         OnRequestPermission)
-    IPC_MESSAGE_HANDLER(GeolocationHostMsg_CancelPermissionRequest,
-                        OnCancelPermissionRequest)
     IPC_MESSAGE_HANDLER(GeolocationHostMsg_StartUpdating, OnStartUpdating)
     IPC_MESSAGE_HANDLER(GeolocationHostMsg_StopUpdating, OnStopUpdating)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void GeolocationDispatcherHost::OnLocationUpdate(
     const Geoposition& geoposition) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 14 matching lines @@
         top_frame->GetLastCommittedURL().GetOrigin());
 
     i->first->Send(new GeolocationMsg_PositionUpdated(
         i->first->GetRoutingID(), geoposition));
   }
 }
 
 void GeolocationDispatcherHost::OnRequestPermission(
     RenderFrameHost* render_frame_host,
     int bridge_id,
-    const GURL& requesting_frame,
+    const GURL& requesting_origin,
     bool user_gesture) {
   int render_process_id = render_frame_host->GetProcess()->GetID();
   int render_frame_id = render_frame_host->GetRoutingID();
 
   PendingPermission pending_permission(
-      render_frame_id, render_process_id, bridge_id);
+      render_frame_id, render_process_id, bridge_id, requesting_origin);
   pending_permissions_.push_back(pending_permission);
 
   GetContentClient()->browser()->RequestGeolocationPermission(
       web_contents(),
       bridge_id,
-      requesting_frame,
+      requesting_origin,
       user_gesture,
       base::Bind(&GeolocationDispatcherHost::SendGeolocationPermissionResponse,
                  weak_factory_.GetWeakPtr(),
                  render_process_id, render_frame_id, bridge_id));
 }
 
-void GeolocationDispatcherHost::OnCancelPermissionRequest(
-    RenderFrameHost* render_frame_host,
-    int bridge_id,
-    const GURL& requesting_frame) {
-  int render_process_id = render_frame_host->GetProcess()->GetID();
-  int render_frame_id = render_frame_host->GetRoutingID();
-  for (size_t i = 0; i < pending_permissions_.size(); ++i) {
-    if (pending_permissions_[i].render_process_id == render_process_id &&
-        pending_permissions_[i].render_frame_id == render_frame_id &&
-        pending_permissions_[i].bridge_id == bridge_id) {
-      GetContentClient()->browser()->CancelGeolocationPermissionRequest(
-            web_contents(), bridge_id, requesting_frame);
-
-      pending_permissions_.erase(pending_permissions_.begin() + i);
-      return;
-    }
-  }
-}
-
 void GeolocationDispatcherHost::OnStartUpdating(
     RenderFrameHost* render_frame_host,
-    const GURL& requesting_frame,
+    const GURL& requesting_origin,
     bool enable_high_accuracy) {
   // StartUpdating() can be invoked as a result of high-accuracy mode
   // being enabled / disabled. No need to record the dispatcher again.
   UMA_HISTOGRAM_BOOLEAN(
       "Geolocation.GeolocationDispatcherHostImpl.EnableHighAccuracy",
       enable_high_accuracy);
 
   updating_frames_[render_frame_host] = enable_high_accuracy;
   RefreshGeolocationOptions();
 }
@@ skipping 55 matching lines @@
       }
 
       pending_permissions_.erase(pending_permissions_.begin() + i);
       return;
     }
   }
 
   NOTREACHED();
 }
 
+void GeolocationDispatcherHost::CancelPermissionRequestsForFrame(
+    RenderFrameHost* render_frame_host) {
+  int render_process_id = render_frame_host->GetProcess()->GetID();
+  int render_frame_id = render_frame_host->GetRoutingID();
+
+  for (size_t i = 0; i < pending_permissions_.size(); ++i) {
+    if (pending_permissions_[i].render_process_id == render_process_id &&
+        pending_permissions_[i].render_frame_id == render_frame_id) {
+      GetContentClient()->browser()->CancelGeolocationPermissionRequest(
+          web_contents(),
+          pending_permissions_[i].bridge_id,
+          pending_permissions_[i].origin);
+      pending_permissions_.erase(pending_permissions_.begin() + i);
+    }
+  }
+}
+
 }  // namespace content