Expose mock geofencing service via testRunner.

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"
+#include "content/browser/geofencing/mock_geofencing_service.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/storage_partition.h"
 #include "third_party/WebKit/public/platform/WebCircularGeofencingRegion.h"
 #include "third_party/WebKit/public/platform/WebGeofencingEventType.h"
 #include "url/gurl.h"
 
 namespace content {
 
@@ skipping 63 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   service_ = GeofencingServiceImpl::GetInstance();
 }
 
 void GeofencingManager::ShutdownOnIO() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // 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);
+  for (const auto& service_worker : registrations_) {
+    GeofencingService* service = ServiceForServiceWorker(service_worker.first);
+    for (const auto& registration : service_worker.second)
+      service->UnregisterRegion(registration.second.geofencing_registration_id);
   }
 }
 
 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;
     }
 
     service_worker_origin = service_worker_registration->pattern().GetOrigin();
   }
 
-  if (!service_->IsServiceAvailable()) {
+  GeofencingService* service =
+      ServiceForServiceWorker(service_worker_registration_id);
+  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));
+  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;
     }
   }
 
-  if (!service_->IsServiceAvailable()) {
+  GeofencingService* service =
+      ServiceForServiceWorker(service_worker_registration_id);
+  if (!service->IsServiceAvailable()) {
     callback.Run(GEOFENCING_STATUS_OPERATION_FAILED_SERVICE_NOT_AVAILABLE);
     return;
   }
 
   Registration* registration =
       FindRegistration(service_worker_registration_id, region_id);
   if (!registration) {
     // Not registered, return an error.
     callback.Run(GEOFENCING_STATUS_UNREGISTRATION_FAILED_NOT_REGISTERED);
     return;
   }
 
   if (!registration->is_active()) {
     // Started registration, but not completed yet, error.
     callback.Run(GEOFENCING_STATUS_UNREGISTRATION_FAILED_NOT_REGISTERED);
     return;
   }
 
-  service_->UnregisterRegion(registration->geofencing_registration_id);
+  service->UnregisterRegion(registration->geofencing_registration_id);
   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;
     }
   }
 
-  if (!service_->IsServiceAvailable()) {
+  GeofencingService* service =
+      ServiceForServiceWorker(service_worker_registration_id);
+  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);
   if (registrations == registrations_.end())
     return GEOFENCING_STATUS_OK;
   for (const auto& registration : registrations->second) {
     if (registration.second.is_active())
       (*result)[registration.first] = registration.second.region;
   }
   return GEOFENCING_STATUS_OK;
 }
 
+void GeofencingManager::SetMockProvider(int64 service_worker_registration_id,
+                                        GeofencingMockState mock_state) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  // First erase all current registration for this service worker.
+  CleanUpForServiceWorker(service_worker_registration_id);
+
+  // Then set or reset the mock service for the service worker.
+  if (mock_state == GeofencingMockState::NONE) {
+    mock_services_.erase(service_worker_registration_id);
+  } else {
+    mock_services_[service_worker_registration_id] =
+        make_linked_ptr(new MockGeofencingService(
+            mock_state != GeofencingMockState::SERVICE_UNAVAILABLE));
+  }
+}
+
+void GeofencingManager::SetMockPosition(int64 service_worker_registration_id,
+                                        double latitude,
+                                        double longitude) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  auto it = mock_services_.find(service_worker_registration_id);
+  if (it == mock_services_.end())
+    return;
+  it->second->SetMockPosition(latitude, longitude);
+}
+
 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.
   if (status != GEOFENCING_STATUS_OK)
     ClearRegistration(registration);
 }
 
 void GeofencingManager::RegionEntered(int64 geofencing_registration_id) {
   DispatchGeofencingEvent(blink::WebGeofencingEventTypeEnter,
                           geofencing_registration_id);
 }
 
 void GeofencingManager::RegionExited(int64 geofencing_registration_id) {
   DispatchGeofencingEvent(blink::WebGeofencingEventTypeLeave,
                           geofencing_registration_id);
 }
 
+GeofencingService* GeofencingManager::ServiceForServiceWorker(
+    int64 service_worker_registration_id) {
+  auto it = mock_services_.find(service_worker_registration_id);
+  if (it == mock_services_.end())
+    return service_;
+  return it->second.get();
+}
+
 GeofencingManager::Registration* GeofencingManager::FindRegistration(
     int64 service_worker_registration_id,
     const std::string& region_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   ServiceWorkerRegistrationsMap::iterator registrations_iterator =
       registrations_.find(service_worker_registration_id);
   if (registrations_iterator == registrations_.end())
     return nullptr;
   RegionIdRegistrationMap::iterator registration =
       registrations_iterator->second.find(region_id);
@@ skipping 39 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) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  ServiceWorkerRegistrationsMap::iterator registrations_iterator =
+      registrations_.find(service_worker_registration_id);
+  if (registrations_iterator == registrations_.end())
+    return;
+
+  GeofencingService* service =
+      ServiceForServiceWorker(service_worker_registration_id);
+  for (auto it = registrations_iterator->second.begin();
+       !registrations_iterator->second.empty();) {
+    int geofencing_registration_id = it->second.geofencing_registration_id;
+    service->UnregisterRegion(geofencing_registration_id);
+    registrations_by_id_.erase(geofencing_registration_id);
+    auto old_it = it;
+    ++it;
+    registrations_iterator->second.erase(old_it);
+  }
+}
+
 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