Geolocation code cleanup following switch to client-based Geolocation.

chrome/browser/geolocation/geolocation_dispatcher_host.cc

 // Copyright (c) 2010 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 "chrome/browser/geolocation/geolocation_dispatcher_host.h"
 
 #include <map>
 #include <set>
 #include <utility>
 
@@ skipping 17 matching lines @@
 
   // GeolocationDispatcherHost
   virtual bool OnMessageReceived(const IPC::Message& msg, bool* msg_was_ok);
 
   // GeolocationObserver
   virtual void OnLocationUpdate(const Geoposition& position);
 
  private:
   virtual ~GeolocationDispatcherHostImpl();
 
-  void OnRegisterDispatcher(int render_view_id);
-  void OnUnregisterDispatcher(int render_view_id);
   void OnRequestPermission(
       int render_view_id, int bridge_id, const GURL& requesting_frame);
   void OnCancelPermissionRequest(
       int render_view_id, int bridge_id, const GURL& requesting_frame);
   void OnStartUpdating(
-      int render_view_id, int bridge_id, const GURL& requesting_frame,
+      int render_view_id, const GURL& requesting_frame,
       bool enable_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);
+  void OnStopUpdating(int render_view_id);
 
   // Updates the |location_arbitrator_| with the currently required update
-  // options, based on |bridge_update_options_|.
+  // options, based on |renderer_update_options_|.
   void RefreshGeolocationObserverOptions();
 
   int render_process_id_;
   scoped_refptr<GeolocationPermissionContext> geolocation_permission_context_;
 
   // Iterated when sending location updates to renderer processes. The fan out
   // to individual bridge IDs happens renderer side, in order to minimize
   // context switches.
   // Only used on the IO thread.
   std::set<int> geolocation_renderer_ids_;
-  // Maps <renderer_id, bridge_id> to the location arbitrator update options
-  // that correspond to this particular bridge.
-  std::map<std::pair<int, int>, GeolocationObserverOptions>
-      bridge_update_options_;
+  // Maps renderer_id to the location arbitrator update options that correspond
+  // to this particular bridge.
+  std::map<int, GeolocationObserverOptions> renderer_update_options_;
   // Only set whilst we are registered with the arbitrator.
   GeolocationProvider* location_provider_;
 
   DISALLOW_COPY_AND_ASSIGN(GeolocationDispatcherHostImpl);
 };
 
 GeolocationDispatcherHostImpl::GeolocationDispatcherHostImpl(
     int render_process_id,
     GeolocationPermissionContext* geolocation_permission_context)
     : render_process_id_(render_process_id),
       geolocation_permission_context_(geolocation_permission_context),
       location_provider_(NULL) {
   // This is initialized by ResourceMessageFilter. Do not add any non-trivial
   // initialization here, defer to OnRegisterBridge which is triggered whenever
   // a javascript geolocation object is actually initialized.
 }
 
 GeolocationDispatcherHostImpl::~GeolocationDispatcherHostImpl() {
   if (location_provider_)
     location_provider_->RemoveObserver(this);
 }
 
 bool GeolocationDispatcherHostImpl::OnMessageReceived(
     const IPC::Message& msg, bool* msg_was_ok) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   *msg_was_ok = true;
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP_EX(GeolocationDispatcherHostImpl, msg, *msg_was_ok)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_Geolocation_RegisterDispatcher,
-                        OnRegisterDispatcher)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_Geolocation_UnregisterDispatcher,
-                        OnUnregisterDispatcher)
     IPC_MESSAGE_HANDLER(ViewHostMsg_Geolocation_CancelPermissionRequest,
                         OnCancelPermissionRequest)
     IPC_MESSAGE_HANDLER(ViewHostMsg_Geolocation_RequestPermission,
                         OnRequestPermission)
     IPC_MESSAGE_HANDLER(ViewHostMsg_Geolocation_StartUpdating,
                         OnStartUpdating)
     IPC_MESSAGE_HANDLER(ViewHostMsg_Geolocation_StopUpdating,
                         OnStopUpdating)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_Geolocation_Suspend,
-                        OnSuspend)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_Geolocation_Resume,
-                        OnResume)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void GeolocationDispatcherHostImpl::OnLocationUpdate(
     const Geoposition& geoposition) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   for (std::set<int>::iterator it = geolocation_renderer_ids_.begin();
        it != geolocation_renderer_ids_.end(); ++it) {
     IPC::Message* message =
         new ViewMsg_Geolocation_PositionUpdated(*it, geoposition);
     CallRenderViewHost(render_process_id_, *it,
                        &RenderViewHost::Send, message);
   }
 }
 
-void GeolocationDispatcherHostImpl::OnRegisterDispatcher(
-    int render_view_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DCHECK_EQ(0u, geolocation_renderer_ids_.count(render_view_id));
-  geolocation_renderer_ids_.insert(render_view_id);
-}
-
-void GeolocationDispatcherHostImpl::OnUnregisterDispatcher(
-    int render_view_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DCHECK_EQ(1u, geolocation_renderer_ids_.count(render_view_id));
-  geolocation_renderer_ids_.erase(render_view_id);
-}
-
 void GeolocationDispatcherHostImpl::OnRequestPermission(
     int render_view_id,
     int bridge_id,
     const GURL& requesting_frame) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DVLOG(1) << __FUNCTION__ << " " << render_process_id_ << ":"
            << render_view_id << ":" << bridge_id;
   geolocation_permission_context_->RequestGeolocationPermission(
       render_process_id_, render_view_id, bridge_id,
       requesting_frame);
 }
 
 void GeolocationDispatcherHostImpl::OnCancelPermissionRequest(
     int render_view_id,
     int bridge_id,
     const GURL& requesting_frame) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DVLOG(1) << __FUNCTION__ << " " << render_process_id_ << ":"
            << render_view_id << ":" << bridge_id;
   geolocation_permission_context_->CancelGeolocationPermissionRequest(
       render_process_id_, render_view_id, bridge_id,
       requesting_frame);
 }
 
 void GeolocationDispatcherHostImpl::OnStartUpdating(
     int render_view_id,
-    int bridge_id,
     const GURL& requesting_frame,
     bool enable_high_accuracy) {
   // StartUpdating() can be invoked as a result of high-accuracy mode
-  // being enabled / disabled. No need to register the dispatcher again.
+  // being enabled / disabled. No need to record the dispatcher again.
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!geolocation_renderer_ids_.count(render_view_id))
-    OnRegisterDispatcher(render_view_id);
+    geolocation_renderer_ids_.insert(render_view_id);
+
   // WebKit sends the startupdating request before checking permissions, to
   // optimize the no-location-available case and reduce latency in the success
   // case (location lookup happens in parallel with the permission request).

[bulach, 2011/01/06 18:29:38]

nit: I think this whole comment is obsolete now? you can also remove the DCHECK
on 152 as it's now in 145..
you may want to move the DVLOG to 146 as well, so all DCHECKING / DVLOG are done
before the real code..

   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DVLOG(1) << __FUNCTION__ << " " << render_process_id_ << ":"
-           << render_view_id << ":" << bridge_id;
-  bridge_update_options_[std::make_pair(render_view_id, bridge_id)] =
+           << render_view_id;
+  renderer_update_options_[render_view_id] =
       GeolocationObserverOptions(enable_high_accuracy);
-  geolocation_permission_context_->StartUpdatingRequested(
-      render_process_id_, render_view_id, bridge_id,
-      requesting_frame);
   RefreshGeolocationObserverOptions();
 }
 
-void GeolocationDispatcherHostImpl::OnStopUpdating(int render_view_id,
-                                                      int bridge_id) {
+void GeolocationDispatcherHostImpl::OnStopUpdating(int render_view_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DVLOG(1) << __FUNCTION__ << " " << render_process_id_ << ":"
-           << render_view_id << ":" << bridge_id;
-  if (bridge_update_options_.erase(std::make_pair(render_view_id, bridge_id)))
+           << render_view_id;
+  if (renderer_update_options_.erase(render_view_id))
     RefreshGeolocationObserverOptions();
-  geolocation_permission_context_->StopUpdatingRequested(
-      render_process_id_, render_view_id, bridge_id);
-  OnUnregisterDispatcher(render_view_id);
-}
 
-void GeolocationDispatcherHostImpl::OnSuspend(int render_view_id,
-                                                 int bridge_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DVLOG(1) << __FUNCTION__ << " " << render_process_id_ << ":"
-           << render_view_id << ":" << bridge_id;
-  // TODO(bulach): connect this with GeolocationArbitrator.
-}
-
-void GeolocationDispatcherHostImpl::OnResume(int render_view_id,
-                                                int bridge_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DVLOG(1) << __FUNCTION__ << " " << render_process_id_ << ":"
-           << render_view_id << ":" << bridge_id;
-  // TODO(bulach): connect this with GeolocationArbitrator.
+  DCHECK_EQ(1u, geolocation_renderer_ids_.count(render_view_id));

[bulach, 2011/01/06 18:29:38]

nit: s/1u/1U/

+  geolocation_renderer_ids_.erase(render_view_id);
 }
 
 void GeolocationDispatcherHostImpl::RefreshGeolocationObserverOptions() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  if (bridge_update_options_.empty()) {
+  if (renderer_update_options_.empty()) {
     if (location_provider_) {
       location_provider_->RemoveObserver(this);
       location_provider_ = NULL;
     }
   } else {
     if (!location_provider_)
       location_provider_ = GeolocationProvider::GetInstance();
     // Re-add to re-establish our options, in case they changed.
     location_provider_->AddObserver(
         this,
-        GeolocationObserverOptions::Collapse(bridge_update_options_));
+        GeolocationObserverOptions::Collapse(renderer_update_options_));
   }
 }
 }  // namespace
 
 GeolocationDispatcherHost* GeolocationDispatcherHost::New(
     int render_process_id,
     GeolocationPermissionContext* geolocation_permission_context) {
   return new GeolocationDispatcherHostImpl(
       render_process_id,
       geolocation_permission_context);
 }