Cleanup geofence registrations when a service worker is unregistered.

content/browser/geofencing/geofencing_manager.cc

 // Copyright 2014 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/geofencing/geofencing_manager.h"
 
 #include <algorithm>
 
 #include "base/callback.h"
 #include "content/browser/geofencing/geofencing_service.h"
@@ skipping 65 matching lines @@
 
 void GeofencingManager::Shutdown() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   BrowserThread::PostTask(BrowserThread::IO,
                           FROM_HERE,
                           base::Bind(&GeofencingManager::ShutdownOnIO, this));
 }
 
 void GeofencingManager::InitOnIO() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  service_ = GeofencingServiceImpl::GetInstance();
+  service_worker_context_->AddObserver(this);
+  if (!service_)
+    service_ = GeofencingServiceImpl::GetInstance();
 }
 
 void GeofencingManager::ShutdownOnIO() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  service_worker_context_->RemoveObserver(this);
   // Clean up all registrations with the |GeofencingService|.
   // TODO(mek): This will need to change to support geofence registrations that
   //     outlive the browser, although removing the references to this
   //     |GeofencingManager| from the |GeofencingService| will still be needed.
   for (const auto& registration : registrations_by_id_)
     service_->UnregisterRegion(registration.first);
 }
 
 void GeofencingManager::RegisterRegion(
     int64 service_worker_registration_id,
     const std::string& region_id,
     const blink::WebCircularGeofencingRegion& region,
     const StatusCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // TODO(mek): Validate region_id and region.
 
-  // Look up service worker. In unit tests |service_worker_context_| might not
-  // be set.
-  GURL service_worker_origin;
-  if (service_worker_context_.get()) {
-    ServiceWorkerRegistration* service_worker_registration =
-        service_worker_context_->context()->GetLiveRegistration(
-            service_worker_registration_id);
-    if (!service_worker_registration) {
-      callback.Run(GEOFENCING_STATUS_OPERATION_FAILED_NO_SERVICE_WORKER);
-      return;
-    }
+  // Look up service worker.
+  ServiceWorkerRegistration* service_worker_registration =
+      service_worker_context_->context()->GetLiveRegistration(
+          service_worker_registration_id);
+  if (!service_worker_registration) {
+    callback.Run(GEOFENCING_STATUS_OPERATION_FAILED_NO_SERVICE_WORKER);
+    return;
+  }
 
-    service_worker_origin = service_worker_registration->pattern().GetOrigin();
-  }
+  GURL service_worker_origin =
+      service_worker_registration->pattern().GetOrigin();
 
   if (!service_->IsServiceAvailable()) {
     callback.Run(GEOFENCING_STATUS_OPERATION_FAILED_SERVICE_NOT_AVAILABLE);
     return;
   }
 
   if (FindRegistration(service_worker_registration_id, region_id)) {
     // Already registered, return an error.
     // TODO(mek): Use a more specific error code.
     callback.Run(GEOFENCING_STATUS_ERROR);
     return;
   }
 
   AddRegistration(service_worker_registration_id, service_worker_origin,
                   region_id, region, callback,
                   service_->RegisterRegion(region, this));
 }
 
 void GeofencingManager::UnregisterRegion(int64 service_worker_registration_id,
                                          const std::string& region_id,
                                          const StatusCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // TODO(mek): Validate region_id.
 
-  // Look up service worker. In unit tests |service_worker_context_| might not
-  // be set.
-  if (service_worker_context_.get()) {
-    ServiceWorkerRegistration* service_worker_registration =
-        service_worker_context_->context()->GetLiveRegistration(
-            service_worker_registration_id);
-    if (!service_worker_registration) {
-      callback.Run(GEOFENCING_STATUS_OPERATION_FAILED_NO_SERVICE_WORKER);
-      return;
-    }
+  // Look up service worker.
+  ServiceWorkerRegistration* service_worker_registration =
+      service_worker_context_->context()->GetLiveRegistration(
+          service_worker_registration_id);
+  if (!service_worker_registration) {
+    callback.Run(GEOFENCING_STATUS_OPERATION_FAILED_NO_SERVICE_WORKER);
+    return;
   }
 
   if (!service_->IsServiceAvailable()) {
     callback.Run(GEOFENCING_STATUS_OPERATION_FAILED_SERVICE_NOT_AVAILABLE);
     return;
   }
 
   Registration* registration =
       FindRegistration(service_worker_registration_id, region_id);
   if (!registration) {
@@ skipping 12 matching lines @@
   ClearRegistration(registration);
   callback.Run(GEOFENCING_STATUS_OK);
 }
 
 GeofencingStatus GeofencingManager::GetRegisteredRegions(
     int64 service_worker_registration_id,
     std::map<std::string, blink::WebCircularGeofencingRegion>* result) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   CHECK(result);
 
-  // Look up service worker. In unit tests |service_worker_context_| might not
-  // be set.
-  if (service_worker_context_.get()) {
-    ServiceWorkerRegistration* service_worker_registration =
-        service_worker_context_->context()->GetLiveRegistration(
-            service_worker_registration_id);
-    if (!service_worker_registration) {
-      return GEOFENCING_STATUS_OPERATION_FAILED_NO_SERVICE_WORKER;
-    }
+  // Look up service worker.
+  ServiceWorkerRegistration* service_worker_registration =
+      service_worker_context_->context()->GetLiveRegistration(
+          service_worker_registration_id);
+  if (!service_worker_registration) {
+    return GEOFENCING_STATUS_OPERATION_FAILED_NO_SERVICE_WORKER;
   }
 
   if (!service_->IsServiceAvailable()) {
     return GEOFENCING_STATUS_OPERATION_FAILED_SERVICE_NOT_AVAILABLE;
   }
 
   // Populate result, filtering out inactive registrations.
   result->clear();
   ServiceWorkerRegistrationsMap::iterator registrations =
       registrations_.find(service_worker_registration_id);
@@ skipping 30 matching lines @@
   }
 }
 
 void GeofencingManager::SetMockPosition(double latitude, double longitude) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!mock_service_)
     return;
   mock_service_->SetMockPosition(latitude, longitude);
 }
 
+void GeofencingManager::OnRegistrationDeleted(
+    int64 service_worker_registration_id,
+    const GURL& pattern) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  CleanUpForServiceWorker(service_worker_registration_id);
+}
+
 void GeofencingManager::RegistrationFinished(int64 geofencing_registration_id,
                                              GeofencingStatus status) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   Registration* registration = FindRegistrationById(geofencing_registration_id);
   DCHECK(registration);
   DCHECK(!registration->is_active());
   registration->registration_callback.Run(status);
   registration->registration_callback.Reset();
 
   // If the registration wasn't succesful, remove it from our storage.
@@ skipping 63 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   registrations_by_id_.erase(registration->geofencing_registration_id);
   ServiceWorkerRegistrationsMap::iterator registrations_iterator =
       registrations_.find(registration->service_worker_registration_id);
   DCHECK(registrations_iterator != registrations_.end());
   registrations_iterator->second.erase(registration->region_id);
   if (registrations_iterator->second.empty())
     registrations_.erase(registrations_iterator);
 }
 
+void GeofencingManager::CleanUpForServiceWorker(
+    int64 service_worker_registration_id) {

[michaeln, 2015/01/09 22:58:41]

id here can be 'invalid', not sure if you want to test for that specifically and
return early?

[Marijn Kruisselbrink, 2015/01/09 23:13:15]

I'm not sure if that's worth the extra code. It would save one map lookup, but
nothing bad happens when it is invalid anyway.

+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  ServiceWorkerRegistrationsMap::iterator registrations_iterator =
+      registrations_.find(service_worker_registration_id);
+  if (registrations_iterator == registrations_.end())
+    return;
+
+  for (const auto& registration : registrations_iterator->second) {
+    int geofencing_registration_id =
+        registration.second.geofencing_registration_id;
+    service_->UnregisterRegion(geofencing_registration_id);
+    registrations_by_id_.erase(geofencing_registration_id);
+  }
+  registrations_.erase(service_worker_registration_id);
+}
+
 void GeofencingManager::DispatchGeofencingEvent(
     blink::WebGeofencingEventType event_type,
     int64 geofencing_registration_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   Registration* registration = FindRegistrationById(geofencing_registration_id);
   if (!registration ||
       registration->service_worker_registration_id ==
           kInvalidServiceWorkerRegistrationId) {
     // TODO(mek): Log/track these failures.
     return;
@@ skipping 49 matching lines @@
 }
 
 void GeofencingManager::DeliverGeofencingEventEnd(
     const scoped_refptr<ServiceWorkerRegistration>& service_worker_registration,
     ServiceWorkerStatusCode service_worker_status) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // TODO(mek): log/check result.
 }
 
 }  // namespace content