Renames route_id to render_view_id

Uses host instead of origin
(in preparation for http://codereview.chromium.org/650180).

Review URL: http://codereview.chromium.org/661273

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@40506 0039d316-1c4b-4281-b951-d872f2087c98

6 files changed, 115 insertions, 110 deletions

diff --git a/chrome/browser/geolocation/geolocation_dispatcher_host.cc b/chrome/browser/geolocation/geolocation_dispatcher_host.cc
index 4a5e0bc..72b9aa2 100644
--- a/chrome/browser/geolocation/geolocation_dispatcher_host.cc
+++ b/chrome/browser/geolocation/geolocation_dispatcher_host.cc
@@ -60,75 +60,84 @@ void GeolocationDispatcherHost::OnLocationUpdate(
        geo != geolocation_renderers_.end();
        ++geo) {
     IPC::Message* message;
-    if (geoposition.error_code == Geoposition::ERROR_CODE_NONE) {
+    if (geoposition.IsValidFix()) {
       message = new ViewMsg_Geolocation_PositionUpdated(
-          geo->route_id, geoposition);
+          geo->render_view_id, geoposition);
     } else {
+      DCHECK(geoposition.IsInitialized());
       message = new ViewMsg_Geolocation_Error(
-          geo->route_id, geoposition.error_code,
+          geo->render_view_id, geoposition.error_code,
           WideToUTF8(geoposition.error_message));
     }
     CallRenderViewHost(
-        geo->process_id, geo->route_id, &RenderViewHost::Send, message);
+        geo->process_id, geo->render_view_id,
+        &RenderViewHost::Send, message);
   }
 }
 
-void GeolocationDispatcherHost::OnRegisterDispatcher(int route_id) {
+void GeolocationDispatcherHost::OnRegisterDispatcher(int render_view_id) {
   // TODO(bulach): is this the right way to get the RendererViewHost process id
   // to be used by RenderViewHost::FromID?
-  RegisterDispatcher(resource_message_filter_process_id_, route_id);
+  RegisterDispatcher(
+      resource_message_filter_process_id_, render_view_id);
 }
 
-void GeolocationDispatcherHost::OnUnregisterDispatcher(int route_id) {
-  UnregisterDispatcher(resource_message_filter_process_id_, route_id);
+void GeolocationDispatcherHost::OnUnregisterDispatcher(int render_view_id) {
+  UnregisterDispatcher(
+      resource_message_filter_process_id_, render_view_id);
 }
 
 void GeolocationDispatcherHost::OnRequestPermission(
-    int route_id, int bridge_id, const GURL& origin) {
+    int render_view_id, int bridge_id, const std::string& host) {
   LOG(INFO) << "permission request";
   geolocation_permission_context_->RequestGeolocationPermission(
-      resource_message_filter_process_id_, route_id, bridge_id, origin);
+      resource_message_filter_process_id_, render_view_id, bridge_id,
+      host);
 }
 
 void GeolocationDispatcherHost::OnStartUpdating(
-    int route_id, int bridge_id, bool high_accuracy) {
-  LOG(INFO) << "start updating" << route_id;
+    int render_view_id, int bridge_id, bool high_accuracy) {
+  LOG(INFO) << "start updating" << render_view_id;
   if (!location_arbitrator_)
     location_arbitrator_ = GeolocationArbitrator::GetInstance();
   location_arbitrator_->AddObserver(
       this, GeolocationArbitrator::UpdateOptions(high_accuracy));
 }
 
-void GeolocationDispatcherHost::OnStopUpdating(int route_id, int bridge_id) {
-  LOG(INFO) << "stop updating" << route_id;
+void GeolocationDispatcherHost::OnStopUpdating(
+    int render_view_id, int bridge_id) {
+  LOG(INFO) << "stop updating" << render_view_id;
   if (location_arbitrator_)
     location_arbitrator_->RemoveObserver(this);
   location_arbitrator_ = NULL;
 }
 
-void GeolocationDispatcherHost::OnSuspend(int route_id, int bridge_id) {
-  LOG(INFO) << "suspend" << route_id;
+void GeolocationDispatcherHost::OnSuspend(
+    int render_view_id, int bridge_id) {
+  LOG(INFO) << "suspend" << render_view_id;
   // TODO(bulach): connect this with GeolocationServiceProvider.
 }
 
-void GeolocationDispatcherHost::OnResume(int route_id, int bridge_id) {
-  LOG(INFO) << "resume" << route_id;
+void GeolocationDispatcherHost::OnResume(
+    int render_view_id, int bridge_id) {
+  LOG(INFO) << "resume" << render_view_id;
   // TODO(bulach): connect this with GeolocationServiceProvider.
 }
 
 void GeolocationDispatcherHost::RegisterDispatcher(
-    int process_id, int route_id) {
+    int process_id, int render_view_id) {
   if (!ChromeThread::CurrentlyOn(ChromeThread::IO)) {
     ChromeThread::PostTask(
         ChromeThread::IO, FROM_HERE,
         NewRunnableMethod(
-            this, &GeolocationDispatcherHost::RegisterDispatcher, process_id,
-            route_id));
+            this, &GeolocationDispatcherHost::RegisterDispatcher,
+            process_id, render_view_id));
     return;
   }
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
 
-  GeolocationServiceRenderId geolocation_render_id(process_id, route_id);
+  GeolocationServiceRenderId geolocation_render_id(
+      process_id, render_view_id);
   std::set<GeolocationServiceRenderId>::const_iterator existing =
       geolocation_renderers_.find(geolocation_render_id);
   DCHECK(existing == geolocation_renderers_.end());
@@ -136,16 +145,19 @@ void GeolocationDispatcherHost::RegisterDispatcher(
 }
 
 void GeolocationDispatcherHost::UnregisterDispatcher(
-    int process_id, int route_id) {
+    int process_id, int render_view_id) {
   if (!ChromeThread::CurrentlyOn(ChromeThread::IO)) {
     ChromeThread::PostTask(
         ChromeThread::IO, FROM_HERE,
         NewRunnableMethod(
-            this, &GeolocationDispatcherHost::UnregisterDispatcher, process_id,
-            route_id));
+            this, &GeolocationDispatcherHost::UnregisterDispatcher,
+            process_id, render_view_id));
     return;
   }
-  GeolocationServiceRenderId geolocation_render_id(process_id, route_id);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
+
+  GeolocationServiceRenderId geolocation_render_id(
+      process_id, render_view_id);
   std::set<GeolocationServiceRenderId>::iterator existing =
       geolocation_renderers_.find(geolocation_render_id);
   DCHECK(existing != geolocation_renderers_.end());
diff --git a/chrome/browser/geolocation/geolocation_dispatcher_host.h b/chrome/browser/geolocation/geolocation_dispatcher_host.h
index 7b36ff9..3cb1dd9 100644
--- a/chrome/browser/geolocation/geolocation_dispatcher_host.h
+++ b/chrome/browser/geolocation/geolocation_dispatcher_host.h
@@ -40,35 +40,40 @@ class GeolocationDispatcherHost
   friend class base::RefCountedThreadSafe<GeolocationDispatcherHost>;
   virtual ~GeolocationDispatcherHost();
 
-  void OnRegisterDispatcher(int route_id);
-  void OnUnregisterDispatcher(int route_id);
-  void OnRequestPermission(int route_id, int bridge_id, const GURL& origin);
-  void OnStartUpdating(int route_id, int bridge_id, bool high_accuracy);
-  void OnStopUpdating(int route_id, int bridge_id);
-  void OnSuspend(int route_id, int bridge_id);
-  void OnResume(int route_id, int bridge_id);
+  void OnRegisterDispatcher(int render_view_id);
+  void OnUnregisterDispatcher(int render_view_id);
+  void OnRequestPermission(
+      int render_view_id, int bridge_id,
+      const std::string& host);
+  void OnStartUpdating(int render_view_id, int bridge_id, bool high_accuracy);
+  void OnStopUpdating(int render_view_id, int bridge_id);
+  void OnSuspend(int render_view_id, int bridge_id);
+  void OnResume(int render_view_id, int bridge_id);
 
   // Registers the bridge created in the renderer side. They'll delegate to the
   // UI thread if not already in there.
-  void RegisterDispatcher(int process_id, int route_id);
-  void UnregisterDispatcher(int process_id, int route_id);
+  void RegisterDispatcher(int process_id, int render_view_id);
+  void UnregisterDispatcher(int process_id, int render_view_id);
 
   int resource_message_filter_process_id_;
   scoped_refptr<GeolocationPermissionContext> geolocation_permission_context_;
 
   struct GeolocationServiceRenderId {
     int process_id;
-    int route_id;
-    GeolocationServiceRenderId(int process_id, int route_id)
-        : process_id(process_id), route_id(route_id) {
+    int render_view_id;
+    GeolocationServiceRenderId(
+        int process_id, int render_view_id)
+        : process_id(process_id),
+          render_view_id(render_view_id) {
     }
     bool operator==(const GeolocationServiceRenderId& rhs) const {
-      return process_id == rhs.route_id &&
-             route_id == rhs.route_id;
+      return process_id == rhs.process_id &&
+             render_view_id == rhs.render_view_id;
     }
     bool operator<(const GeolocationServiceRenderId& rhs) const {
-      return process_id < rhs.route_id &&
-             route_id < rhs.route_id;
+      if (process_id == rhs.process_id)
+        return render_view_id < rhs.render_view_id;
+      return process_id < rhs.process_id;
     }
   };
   // Only used on the IO thread.
diff --git a/chrome/browser/geolocation/geolocation_permission_context.cc b/chrome/browser/geolocation/geolocation_permission_context.cc
index 79e1e30..be84486 100644
--- a/chrome/browser/geolocation/geolocation_permission_context.cc
+++ b/chrome/browser/geolocation/geolocation_permission_context.cc
@@ -7,7 +7,6 @@
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/file_util.h"
-#include "googleurl/src/gurl.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/chrome_thread.h"
@@ -37,10 +36,10 @@ class GeolocationConfirmInfoBarDelegate : public ConfirmInfoBarDelegate {
   GeolocationConfirmInfoBarDelegate(
       TabContents* tab_contents, GeolocationPermissionContext* context,
       int render_process_id, int render_view_id, int bridge_id,
-      const GURL& origin)
+      const std::string& host)
     : ConfirmInfoBarDelegate(tab_contents), context_(context),
       render_process_id_(render_process_id), render_view_id_(render_view_id),
-      bridge_id_(bridge_id), origin_(origin) {
+      bridge_id_(bridge_id), host_(host) {
   }
 
   // ConfirmInfoBarDelegate
@@ -64,7 +63,7 @@ class GeolocationConfirmInfoBarDelegate : public ConfirmInfoBarDelegate {
 
   virtual std::wstring GetMessageText() const {
     return l10n_util::GetStringF(
-        IDS_GEOLOCATION_INFOBAR_QUESTION, UTF8ToWide(origin_.host()));
+        IDS_GEOLOCATION_INFOBAR_QUESTION, UTF8ToWide(host_));
   }
 
   virtual SkBitmap* GetIcon() const {
@@ -75,7 +74,7 @@ class GeolocationConfirmInfoBarDelegate : public ConfirmInfoBarDelegate {
  private:
   bool SetPermission(bool confirm) {
     context_->SetPermission(
-        render_process_id_, render_view_id_, bridge_id_, origin_, confirm);
+        render_process_id_, render_view_id_, bridge_id_, host_, confirm);
     return true;
   }
 
@@ -83,7 +82,7 @@ class GeolocationConfirmInfoBarDelegate : public ConfirmInfoBarDelegate {
   int render_process_id_;
   int render_view_id_;
   int bridge_id_;
-  GURL origin_;
+  std::string host_;
 };
 
 // TODO(bulach): use HostContentSettingsMap instead!
@@ -95,22 +94,17 @@ FilePath::StringType StdStringToFilePathString(const std::string& std_string) {
 #endif
 }
 
-std::string GURLToCacheKey(const GURL& gurl) {
-  return gurl.host();
-}
-
 // Returns true if permission was successfully read from file, and *allowed
 // be set accordingly.
 // Returns false otherwise.
 bool ReadPermissionFromFile(
-    const GURL& origin, const FilePath& permissions_path, bool* allowed) {
+    const std::string& host, const FilePath& permissions_path, bool* allowed) {
   DCHECK(allowed);
   *allowed = false;
   // TODO(bulach): this is probably wrong! is there any utility to convert a URL
   // to FilePath?
   FilePath permission_file(
-      permissions_path.Append(StdStringToFilePathString(
-          GURLToCacheKey(origin))));
+      permissions_path.Append(StdStringToFilePathString(host)));
   if (!file_util::PathExists(permission_file))
     return false;
   JSONFileValueSerializer serializer(permission_file);
@@ -123,7 +117,7 @@ bool ReadPermissionFromFile(
 }
 
 void SavePermissionToFile(
-    const GURL& origin, const FilePath& permissions_path, bool allowed) {
+    const std::string& host, const FilePath& permissions_path, bool allowed) {
 #if 0
   if (!file_util::DirectoryExists(permissions_path))
     file_util::CreateDirectory(permissions_path);
@@ -131,7 +125,7 @@ void SavePermissionToFile(
   // to FilePath?
   FilePath permission_file(
       permissions_path.Append(StdStringToFilePathString(
-          GURLToCacheKey(origin))));
+          host)));
   DictionaryValue dictionary;
   dictionary.SetBoolean(kAllowedDictionaryKey, allowed);
   std::string permission_data;
@@ -157,63 +151,63 @@ GeolocationPermissionContext::~GeolocationPermissionContext() {
 
 void GeolocationPermissionContext::RequestGeolocationPermission(
     int render_process_id, int render_view_id, int bridge_id,
-    const GURL& origin) {
+    const std::string& host) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   std::map<std::string, bool>::const_iterator permission =
-      permissions_.find(GURLToCacheKey(origin));
+      permissions_.find(host);
   if (permission != permissions_.end()) {
     NotifyPermissionSet(
         render_process_id, render_view_id, bridge_id, permission->second);
   } else {
     HandlePermissionMemoryCacheMiss(
-        render_process_id, render_view_id, bridge_id, origin);
+        render_process_id, render_view_id, bridge_id, host);
   }
 }
 
 void GeolocationPermissionContext::SetPermission(
     int render_process_id, int render_view_id, int bridge_id,
-    const GURL& origin, bool allowed) {
-  SetPermissionMemoryCacheOnIOThread(origin, allowed);
-  SetPermissionOnFileThread(origin, allowed);
+    const std::string& host, bool allowed) {
+  SetPermissionMemoryCacheOnIOThread(host, allowed);
+  SetPermissionOnFileThread(host, allowed);
   NotifyPermissionSet(render_process_id, render_view_id, bridge_id, allowed);
 }
 
 void GeolocationPermissionContext::HandlePermissionMemoryCacheMiss(
     int render_process_id, int render_view_id, int bridge_id,
-    const GURL& origin) {
+    const std::string& host) {
   if (!ChromeThread::CurrentlyOn(ChromeThread::FILE)) {
     ChromeThread::PostTask(
         ChromeThread::FILE, FROM_HERE,
         NewRunnableMethod(
             this,
             &GeolocationPermissionContext::HandlePermissionMemoryCacheMiss,
-            render_process_id, render_view_id, bridge_id, origin));
+            render_process_id, render_view_id, bridge_id, host));
     return;
   }
 
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
-  // TODO(bulach): should we save a file per origin or have some smarter
+  // TODO(bulach): should we save a file per host or have some smarter
   // storage? Use HostContentSettingsMap instead.
   bool allowed;
   if (is_off_the_record_ ||
-      !ReadPermissionFromFile(origin, permissions_path_, &allowed)) {
+      !ReadPermissionFromFile(host, permissions_path_, &allowed)) {
     RequestPermissionFromUI(
-        render_process_id, render_view_id, bridge_id, origin);
+        render_process_id, render_view_id, bridge_id, host);
   } else {
-    SetPermissionMemoryCacheOnIOThread(origin, allowed);
+    SetPermissionMemoryCacheOnIOThread(host, allowed);
     NotifyPermissionSet(render_process_id, render_view_id, bridge_id, allowed);
   }
 }
 
 void GeolocationPermissionContext::RequestPermissionFromUI(
     int render_process_id, int render_view_id, int bridge_id,
-    const GURL& origin) {
+    const std::string& host) {
   if (!ChromeThread::CurrentlyOn(ChromeThread::UI)) {
     ChromeThread::PostTask(
         ChromeThread::UI, FROM_HERE,
         NewRunnableMethod(
             this, &GeolocationPermissionContext::RequestPermissionFromUI,
-            render_process_id, render_view_id, bridge_id, origin));
+            render_process_id, render_view_id, bridge_id, host));
     return;
   }
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
@@ -224,7 +218,7 @@ void GeolocationPermissionContext::RequestPermissionFromUI(
   tab_contents->AddInfoBar(
       new GeolocationConfirmInfoBarDelegate(
           tab_contents, this, render_process_id, render_view_id,
-          bridge_id, origin));
+          bridge_id, host));
 }
 
 void GeolocationPermissionContext::NotifyPermissionSet(
@@ -247,23 +241,23 @@ void GeolocationPermissionContext::NotifyPermissionSet(
 }
 
 void GeolocationPermissionContext::SetPermissionMemoryCacheOnIOThread(
-    const GURL& origin, bool allowed) {
+    const std::string& host, bool allowed) {
   if (!ChromeThread::CurrentlyOn(ChromeThread::IO)) {
     ChromeThread::PostTask(
         ChromeThread::IO, FROM_HERE,
         NewRunnableMethod(
             this,
             &GeolocationPermissionContext::SetPermissionMemoryCacheOnIOThread,
-            origin, allowed));
+            host, allowed));
     return;
   }
 
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
-  permissions_[GURLToCacheKey(origin)] = allowed;
+  permissions_[host] = allowed;
 }
 
 void GeolocationPermissionContext::SetPermissionOnFileThread(
-    const GURL& origin, bool allowed) {
+    const std::string& host, bool allowed) {
   if (is_off_the_record_)
     return;
   if (!ChromeThread::CurrentlyOn(ChromeThread::FILE)) {
@@ -271,15 +265,15 @@ void GeolocationPermissionContext::SetPermissionOnFileThread(
         ChromeThread::FILE, FROM_HERE,
         NewRunnableMethod(
             this, &GeolocationPermissionContext::SetPermissionOnFileThread,
-            origin, allowed));
+            host, allowed));
     return;
   }
 
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
 
-  // TODO(bulach): should we save a file per origin or have some smarter
+  // TODO(bulach): should we save a file per host or have some smarter
   // storage? Use HostContentSettingsMap instead.
 #if 0
-  SavePermissionToFile(origin, permissions_path_, allowed);
+  SavePermissionToFile(host, permissions_path_, allowed);
 #endif
 }
diff --git a/chrome/browser/geolocation/geolocation_permission_context.h b/chrome/browser/geolocation/geolocation_permission_context.h
index fb39f66..6b79fd75 100644
--- a/chrome/browser/geolocation/geolocation_permission_context.h
+++ b/chrome/browser/geolocation/geolocation_permission_context.h
@@ -11,11 +11,10 @@
 #include "base/ref_counted.h"
 
 class GeolocationDispatcherHost;
-class GURL;
 class Profile;
 class RenderViewHost;
 
-// GeolocationPermissionContext manages Geolocation permissions per origin.
+// GeolocationPermissionContext manages Geolocation permissions per host.
 // It keeps an in-memory cache of permissions, and if not available, loads
 // from disk. If there's no data, it'll trigger the UI elements to ask the
 // user for permission.
@@ -31,14 +30,14 @@ class GeolocationPermissionContext
   // Must be called from the IO thread.
   void RequestGeolocationPermission(
       int render_process_id, int render_view_id, int bridge_id,
-      const GURL& origin);
+      const std::string& host);
 
   // Called once the user sets the geolocation permission.
   // It'll update the internal state on different threads via
   // SetPermissionMemoryCacheOnIOThread and SetPermissionOnFileThread.
   void SetPermission(
       int render_process_id, int render_view_id, int bridge_id,
-      const GURL& origin, bool allowed);
+      const std::string& host, bool allowed);
 
  private:
   friend class base::RefCountedThreadSafe<GeolocationPermissionContext>;
@@ -55,12 +54,12 @@ class GeolocationPermissionContext
   // - If not available, it'll delegate to RequestPermissionDataFromUI.
   void HandlePermissionMemoryCacheMiss(
       int render_process_id, int render_view_id, int bridge_id,
-      const GURL& origin);
+      const std::string& host);
 
   // Triggers the associated UI element to request permission.
   void RequestPermissionFromUI(
       int render_process_id, int render_view_id, int bridge_id,
-      const GURL& origin);
+      const std::string& host);
 
   // Notifies whether or not the corresponding render is allowed to use
   // geolocation.
@@ -69,9 +68,10 @@ class GeolocationPermissionContext
       bool allowed);
 
   // Sets permissions_ cache (if not on IO thread, will forward to it).
-  void SetPermissionMemoryCacheOnIOThread(const GURL& origin, bool allowed);
+  void SetPermissionMemoryCacheOnIOThread(
+      const std::string& host, bool allowed);
   // Sets permissions file data (if not on FILE thread, will forward to it).
-  void SetPermissionOnFileThread(const GURL& origin, bool allowed);
+  void SetPermissionOnFileThread(const std::string& host, bool allowed);
 
   // This should only be accessed from the UI thread.
   Profile* const profile_;
diff --git a/chrome/common/render_messages_internal.h b/chrome/common/render_messages_internal.h
index bc8aefe..e4a9b72 100644
--- a/chrome/common/render_messages_internal.h
+++ b/chrome/common/render_messages_internal.h
@@ -2209,57 +2209,51 @@ IPC_BEGIN_MESSAGES(ViewHost)
   // This is used to lazily initialize the host dispatchers and related
   // Geolocation infrastructure in the browser process.
   IPC_MESSAGE_CONTROL1(ViewHostMsg_Geolocation_RegisterDispatcher,
-                       int /* route_id */)
+                       int /* render_view_id */)
 
   // A GeolocationServiceBridgeImpl has been destroyed.
   // This is used to let the Geolocation infrastructure do its cleanup.
   IPC_MESSAGE_CONTROL1(ViewHostMsg_Geolocation_UnregisterDispatcher,
-                       int /* route_id */)
+                       int /* render_view_id */)
 
-  // The |route_id| and |bridge_id| representing |URL| is requesting permission
-  // to access geolocation position.
+  // The |render_view_id| and |bridge_id| representing |host| is requesting
+  // permission to access geolocation position.
   // This will be replied by ViewMsg_Geolocation_PermissionSet.
   IPC_MESSAGE_CONTROL3(ViewHostMsg_Geolocation_RequestPermission,
-                       int /* route_id */,
+                       int /* render_view_id */,
                        int /* bridge_id */,
-                       GURL /* URL of the page*/)
+                       std::string /* host of the page*/)
 
-  // The |route_id| and |bridge_id| requests Geolocation service to start
+  // The |render_view_id| and |bridge_id| requests Geolocation service to start
   // updating.
   // This is an asynchronous call, and the browser process may eventually reply
   // with the updated geoposition, or an error (access denied, location
   // unavailable, etc.)
   IPC_MESSAGE_CONTROL3(ViewHostMsg_Geolocation_StartUpdating,
-                       int /* route_id */,
+                       int /* render_view_id */,
                        int /* bridge_id */,
                        bool /* high_accuracy */)
 
-  // The |route_id| and |bridge_id| requests Geolocation service to stop
+  // The |render_view_id| and |bridge_id| requests Geolocation service to stop
   // updating.
   // Note that the geolocation service may continue to fetch geolocation data
   // for other origins.
   IPC_MESSAGE_CONTROL2(ViewHostMsg_Geolocation_StopUpdating,
-                       int /* route_id */,
+                       int /* render_view_id */,
                        int /* bridge_id */)
 
-  // The |route_id| and |bridge_id| requests Geolocation service to suspend.
+  // The |render_view_id| and |bridge_id| requests Geolocation service to
+  // suspend.
   // Note that the geolocation service may continue to fetch geolocation data
   // for other origins.
   IPC_MESSAGE_CONTROL2(ViewHostMsg_Geolocation_Suspend,
-                       int /* route_id */,
+                       int /* render_view_id */,
                        int /* bridge_id */)
 
-  // The |route_id| and |bridge_id| requests Geolocation service to resume.
+  // The |render_view_id| and |bridge_id| requests Geolocation service to
+  // resume.
   IPC_MESSAGE_CONTROL2(ViewHostMsg_Geolocation_Resume,
-                       int /* route_id */,
+                       int /* render_view_id */,
                        int /* bridge_id */)
 
-  // Sent to indicate whether this particular GeolocationServiceBridgeImpl
-  // (identified by |route_id| and |bridge_id|) is allowed to use geolocation
-  // services.
-  IPC_MESSAGE_CONTROL3(ViewHostMsg_Geolocation_PermissionSet,
-                       int /* route_id */,
-                       int /* bridge_id */,
-                       bool /* is_allowed */)
-
 IPC_END_MESSAGES(ViewHost)
diff --git a/chrome/renderer/geolocation_dispatcher.cc b/chrome/renderer/geolocation_dispatcher.cc
index c698317..b810799 100644
--- a/chrome/renderer/geolocation_dispatcher.cc
+++ b/chrome/renderer/geolocation_dispatcher.cc
@@ -39,7 +39,7 @@ bool GeolocationDispatcher::OnMessageReceived(const IPC::Message& message) {
 void GeolocationDispatcher::requestPermissionForFrame(
     int bridge_id, const WebKit::WebURL& url) {
   render_view_->Send(new ViewHostMsg_Geolocation_RequestPermission(
-      render_view_->routing_id(), bridge_id, GURL(url).GetOrigin()));
+      render_view_->routing_id(), bridge_id, GURL(url).host()));
 }
 
 void GeolocationDispatcher::startUpdating(int bridge_id, bool hasHighAccuracy) {