Introduce GeolocationPermissionRequestID, a wrapper struct to contain the (render process ID, rende…

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 <map>
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "content/browser/geolocation/geolocation_provider.h"
 #include "content/browser/renderer_host/render_message_filter.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/public/browser/geolocation_permission_context.h"
 #include "content/public/common/geoposition.h"
 #include "content/common/geolocation_messages.h"
 
-using content::BrowserThread;
-using content::GeolocationPermissionContext;
-using content::Geoposition;
-using content::RenderViewHostImpl;
+namespace content {
 
 namespace {
 
 void NotifyArbitratorPermissionGranted() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   GeolocationProvider::GetInstance()->OnPermissionGranted();
 }
 
-void SendGeolocationPermissionResponse(int render_process_id,
-                                       int render_view_id,
-                                       int bridge_id,
+void SendGeolocationPermissionResponse(const GeolocationPermissionRequestID& id,
                                        bool allowed) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   RenderViewHostImpl* r = RenderViewHostImpl::FromID(
-      render_process_id, render_view_id);
+      id.render_process_id, id.render_view_id);
   if (!r)
     return;
-  r->Send(new GeolocationMsg_PermissionSet(render_view_id, bridge_id, allowed));
+  r->Send(new GeolocationMsg_PermissionSet(id.render_view_id, id.bridge_id,
+                                           allowed));
 
   if (allowed) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&NotifyArbitratorPermissionGranted));
   }
 }
 
 class GeolocationDispatcherHostImpl : public GeolocationDispatcherHost,
                                       public GeolocationObserver {
  public:
   GeolocationDispatcherHostImpl(
       int render_process_id,
       GeolocationPermissionContext* geolocation_permission_context);
 
   // GeolocationDispatcherHost
   virtual bool OnMessageReceived(const IPC::Message& msg, bool* msg_was_ok);
 
   // GeolocationObserver
   virtual void OnLocationUpdate(const Geoposition& position);
 
  private:
   virtual ~GeolocationDispatcherHostImpl();
 
-  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, const GURL& requesting_frame,
-      bool enable_high_accuracy);
+  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,
+                       const GURL& requesting_frame,
+                       bool enable_high_accuracy);
   void OnStopUpdating(int render_view_id);
 
   // Updates the |location_arbitrator_| with the currently required update
   // 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
@@ skipping 50 matching lines @@
        it != geolocation_renderer_ids_.end(); ++it) {
     Send(new GeolocationMsg_PositionUpdated(*it, geoposition));
   }
 }
 
 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;
+  const GeolocationPermissionRequestID id(render_process_id_, render_view_id,
+                                          bridge_id);
+  DVLOG(1) << __FUNCTION__ << " " << id.ToString();
   if (geolocation_permission_context_) {
     geolocation_permission_context_->RequestGeolocationPermission(
-        render_process_id_, render_view_id, bridge_id,
-        requesting_frame,
-        base::Bind(
-            &SendGeolocationPermissionResponse,
-            render_process_id_, render_view_id, bridge_id));
+        id, requesting_frame, base::Bind(&SendGeolocationPermissionResponse,
+                                         id));
   } else {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
-        base::Bind(
-            &SendGeolocationPermissionResponse,
-            render_process_id_, render_view_id, bridge_id, true));
+        base::Bind(&SendGeolocationPermissionResponse, id, true));
   }
 }
 
 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;
-  if (!geolocation_permission_context_)
-    return;
-  geolocation_permission_context_->CancelGeolocationPermissionRequest(
-      render_process_id_, render_view_id, bridge_id,
-      requesting_frame);
+  const GeolocationPermissionRequestID id(render_process_id_, render_view_id,
+                                          bridge_id);
+  DVLOG(1) << __FUNCTION__ << " " << id.ToString();
+  if (geolocation_permission_context_) {
+    geolocation_permission_context_->CancelGeolocationPermissionRequest(
+        id, requesting_frame);
+  }
 }
 
 void GeolocationDispatcherHostImpl::OnStartUpdating(
     int render_view_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 record the dispatcher again.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DVLOG(1) << __FUNCTION__ << " " << render_process_id_ << ":"
@@ skipping 28 matching lines @@
     if (!location_provider_)
       location_provider_ = GeolocationProvider::GetInstance();
     // Re-add to re-establish our options, in case they changed.
     location_provider_->AddObserver(
         this,
         GeolocationObserverOptions::Collapse(renderer_update_options_));
   }
 }
 }  // namespace
 
+
+// GeolocationDispatcherHost --------------------------------------------------
+
+// static
 GeolocationDispatcherHost* GeolocationDispatcherHost::New(
     int render_process_id,
     GeolocationPermissionContext* geolocation_permission_context) {
   return new GeolocationDispatcherHostImpl(
       render_process_id,
       geolocation_permission_context);
 }
+
+GeolocationDispatcherHost::GeolocationDispatcherHost() {
+}
+
+GeolocationDispatcherHost::~GeolocationDispatcherHost() {
+}
+
+}  // namespace content