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_) {
+  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.
@@ skipping 18 matching lines @@
     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,
+  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.
 
@@ skipping 60 matching lines @@
       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(GeofencingMockState mock_state) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  // TODO(mek): It would be nice if enabling the mock geofencing service
+  // wouldn't completely delete all existing registrations but instead just
+  // somehow keep them around but inactive.
+  // For now mocking is only used in layout tests, so just clearing all
+  // registrations works good enough.
+  for (const auto& registration : registrations_by_id_)
+    service_->UnregisterRegion(registration.first);
+  registrations_by_id_.clear();
+  registrations_.clear();
+
+  // Then set or reset the mock service for the service worker.
+  if (mock_state == GeofencingMockState::NONE) {
+    service_ = GeofencingServiceImpl::GetInstance();
+    mock_service_.reset();
+  } else {
+    mock_service_.reset(new MockGeofencingService(
+        mock_state != GeofencingMockState::SERVICE_UNAVAILABLE));
+    service_ = mock_service_.get();
+  }
+}
+
+void GeofencingManager::SetMockPosition(double latitude, double longitude) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (!mock_service_)
+    return;
+  mock_service_->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.
@@ skipping 132 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