Move GeolocationDispatcher into blink.

third_party/WebKit/Source/modules/geolocation/testing/GeolocationClientMock.cpp

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  * Copyright (C) 2012 Apple Inc. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 14 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "GeolocationClientMock.h"
 
+#include "core/dom/Document.h"
 #include "modules/geolocation/GeolocationController.h"
 #include "modules/geolocation/GeolocationError.h"
 #include "modules/geolocation/GeolocationPosition.h"
 
 namespace blink {
 
-GeolocationClientMock::GeolocationClientMock()
-    : m_hasError(false)
-    , m_controllerTimer(this, &GeolocationClientMock::controllerTimerFired)
-    , m_permissionTimer(this, &GeolocationClientMock::permissionTimerFired)
-    , m_isActive(false)
-    , m_permissionState(PermissionStateUnset)
+GeolocationClientMock* GeolocationClientMock::from(Document* document)
 {
+    GeolocationClientMock* supplement = static_cast<GeolocationClientMock*>(WillBeHeapSupplement<Document>::from(*document, supplementName()));
+    if (!supplement) {
+        supplement = new GeolocationClientMock(document);
+        WillBeHeapSupplement<Document>::provideTo(*document, supplementName(), adoptPtrWillBeNoop(supplement));
+        document->setServiceProvider(supplement);

[Marijn Kruisselbrink, 2015/09/30 19:56:55]

The constructor of GeolocationClientMock would have already called this; pick
which code should be responsible for calling it...

[Sam McNally, 2015/10/01 01:54:50]

Done.

+    }
+    return supplement;
+}
+
+GeolocationClientMock::GeolocationClientMock(ExecutionContext* context)
+    : m_context(context)
+    , m_permissionState(permission::STATUS_ASK)
+    , m_geolocationBinding(this)
+    , m_permissionBinding(this)
+{
+    m_context->setServiceProvider(this);
 }
 
 GeolocationClientMock::~GeolocationClientMock()
 {
-    ASSERT(!m_isActive);
+    if (m_context->serviceProvider() == this)
+        m_context->setServiceProvider(nullptr);
 }
 
 void GeolocationClientMock::setPosition(GeolocationPosition* position)
 {
-    m_lastPosition = position;
-    clearError();
-    asyncUpdateController();
+    m_lastPosition = geolocation::Geoposition::New();
+    m_lastPosition->latitude = position->latitude();
+    m_lastPosition->longitude = position->longitude();
+    m_lastPosition->altitude = position->canProvideAltitude() ? position->altitude() : -10000.;
+    m_lastPosition->accuracy = position->accuracy();
+    m_lastPosition->altitude_accuracy = position->canProvideAltitudeAccuracy() ? position->altitudeAccuracy() : -1;
+    m_lastPosition->heading = position->canProvideHeading() ? position->heading() : -1;
+    m_lastPosition->speed = position->canProvideSpeed() ? position->speed() : -1;
+    m_lastPosition->timestamp = position->timestamp();
+    m_lastPosition->error_message = "";
+    m_lastPosition->valid = true;
+    runGeolocationCallbacks();
 }
 
 void GeolocationClientMock::setPositionUnavailableError(const String& errorMessage)
 {
-    m_hasError = true;
-    m_errorMessage = errorMessage;
-    m_lastPosition = nullptr;
-    asyncUpdateController();
+    m_lastPosition = geolocation::Geoposition::New();
+    m_lastPosition->error_code = geolocation::Geoposition::ERROR_CODE_POSITION_UNAVAILABLE;
+    m_lastPosition->error_message = errorMessage.utf8().data();
+    runGeolocationCallbacks();
 }
 
 void GeolocationClientMock::setPermission(bool allowed)
 {
-    m_permissionState = allowed ? PermissionStateAllowed : PermissionStateDenied;
-    asyncUpdatePermission();
+    m_permissionState = allowed ? permission::STATUS_GRANTED : permission::STATUS_DENIED;
+    runPermissionCallbacks();
 }
 
 int GeolocationClientMock::numberOfPendingPermissionRequests() const
 {
     return m_pendingPermissions.size();
 }
 
-void GeolocationClientMock::requestPermission(Geolocation* geolocation)
-{
-    m_pendingPermissions.add(geolocation);
-    if (m_permissionState != PermissionStateUnset)
-        asyncUpdatePermission();
-}
-
-void GeolocationClientMock::cancelPermissionRequest(Geolocation* geolocation)
-{
-    // Called from Geolocation::disconnectFrame() in response to LocalFrame destruction.
-    m_pendingPermissions.remove(geolocation);
-    if (m_pendingPermissions.isEmpty() && m_permissionTimer.isActive())
-        m_permissionTimer.stop();
-}
-
-void GeolocationClientMock::controllerForTestAdded(GeolocationController* controller)
-{
-    m_controllers.add(controller);
-}
-
-void GeolocationClientMock::controllerForTestRemoved(GeolocationController* controller)
-{
-    m_controllers.remove(controller);
-}
-
-void GeolocationClientMock::asyncUpdatePermission()
-{
-    ASSERT(m_permissionState != PermissionStateUnset);
-    if (!m_permissionTimer.isActive())
-        m_permissionTimer.startOneShot(0, FROM_HERE);
-}
-
-void GeolocationClientMock::permissionTimerFired(Timer<GeolocationClientMock>* timer)
-{
-    ASSERT_UNUSED(timer, timer == &m_permissionTimer);
-    ASSERT(m_permissionState != PermissionStateUnset);
-    bool allowed = m_permissionState == PermissionStateAllowed;
-    GeolocationSet::iterator end = m_pendingPermissions.end();
-
-    // Once permission has been set (or denied) on a Geolocation object, there can be
-    // no further requests for permission to the mock. Consequently the callbacks
-    // which fire synchronously from Geolocation::setIsAllowed() cannot reentrantly modify
-    // m_pendingPermissions.
-    for (GeolocationSet::iterator it = m_pendingPermissions.begin(); it != end; ++it)
-        (*it)->setIsAllowed(allowed);
-    m_pendingPermissions.clear();
-}
-
-void GeolocationClientMock::startUpdating()
-{
-    ASSERT(!m_isActive);
-    m_isActive = true;
-    asyncUpdateController();
-}
-
-void GeolocationClientMock::stopUpdating()
-{
-    ASSERT(m_isActive);
-    m_isActive = false;
-    m_controllerTimer.stop();
-}
-
-void GeolocationClientMock::setEnableHighAccuracy(bool)
+void GeolocationClientMock::SetHighAccuracy(bool highAccuracy)
 {
     // FIXME: We need to add some tests regarding "high accuracy" mode.
     // See https://bugs.webkit.org/show_bug.cgi?id=49438
 }
 
-GeolocationPosition* GeolocationClientMock::lastPosition()
+void GeolocationClientMock::QueryNextPosition(const QueryNextPositionCallback& callback)
 {
-    return m_lastPosition.get();
+    m_pendingGeolocations.append(callback);
+    runGeolocationCallbacks();
 }
 
-void GeolocationClientMock::asyncUpdateController()
+void GeolocationClientMock::HasPermission(permission::Name permission,
+    const mojo::String& origin,
+    const HasPermissionCallback& callback)
 {
-    if (m_isActive && !m_controllerTimer.isActive())
-        m_controllerTimer.startOneShot(0, FROM_HERE);
+    callback.Run(permission::STATUS_ASK);
 }
 
-void GeolocationClientMock::controllerTimerFired(Timer<GeolocationClientMock>* timer)
+void GeolocationClientMock::RequestPermission(permission::Name permission,
+    const mojo::String& origin,
+    bool userGesture,
+    const RequestPermissionCallback& callback)
 {
-    ASSERT_UNUSED(timer, timer == &m_controllerTimer);
-
-    // Make a copy of the set of controllers since it might be modified while iterating.
-    GeolocationControllers controllers = m_controllers;
-    if (m_lastPosition.get()) {
-        ASSERT(!m_hasError);
-        for (GeolocationControllers::iterator it = controllers.begin(); it != controllers.end(); ++it)
-            (*it)->positionChanged(m_lastPosition.get());
-    } else if (m_hasError) {
-        for (GeolocationControllers::iterator it = controllers.begin(); it != controllers.end(); ++it)
-            (*it)->errorOccurred(GeolocationError::create(GeolocationError::PositionUnavailable, m_errorMessage));
-    }
+    m_pendingPermissions.append(callback);
+    runPermissionCallbacks();
 }
 
-void GeolocationClientMock::clearError()
+void GeolocationClientMock::RequestPermissions(mojo::Array<permission::Name> permissions,
+    const mojo::String& origin,
+    bool userGesture,
+    const RequestPermissionsCallback& callback)
 {
-    m_hasError = false;
-    m_errorMessage = String();
+}
+
+void GeolocationClientMock::RevokePermission(permission::Name permission,
+    const mojo::String& origin,
+    const RevokePermissionCallback& callback)
+{
+}
+
+void GeolocationClientMock::GetNextPermissionChange(
+    permission::Name permission,
+    const mojo::String& origin,
+    permission::Status lastKnownStatus,
+    const GetNextPermissionChangeCallback& callback)
+{
+}
+
+void GeolocationClientMock::ConnectToService(const mojo::String& interfaceName, mojo::ScopedMessagePipeHandle pipe)
+{

[Marijn Kruisselbrink, 2015/09/30 19:56:55]

While there is only one feature that uses mojo from blink just overwriting the
existing service provider completely works of course, but as soon as other code
starts relying on mojo as well it seems like any mock service provider should
only intercept requests for some services, and pass through connections to other
services to whatever service provider was in place already. And ideally mock
service providers could be created and destroyed in different orders, while
still keeping things working...

Having multiple features that all want to intercept the permission service for
their own feature of course gets even more complicated, not sure what the best
thing to do for that would be...

[Sam McNally, 2015/10/01 01:54:50]

This is a bit of a quick and nasty ServiceProvider mock. I think in the longer
term we'd use a common mock ServiceProvider that tests for any mojo-backed API
would use. That would forward any unhandled requests to the normal
ServiceProvider.
Tests that use multiple mojo-backed APIs that share a backend could implement
custom-tailored mocks that can deal with both. In particular, when we get to
converting the Permission API, perhaps a general(ish)-purpose permission service
mock could be written that the geolocation tests could also use.

+    if (interfaceName == geolocation::GeolocationService::Name_)
+        m_geolocationBinding.Bind(pipe.Pass());
+    else if (interfaceName == permission::PermissionService::Name_)
+        m_permissionBinding.Bind(pipe.Pass());
+}
+
+void GeolocationClientMock::runGeolocationCallbacks()
+{
+    if (m_pendingGeolocations.isEmpty() || !m_lastPosition)
+        return;
+
+    for (const auto& callback : m_pendingGeolocations)
+        callback.Run(m_lastPosition.Clone());
+    m_pendingGeolocations.clear();
+    m_lastPosition = nullptr;
+}
+
+void GeolocationClientMock::runPermissionCallbacks()
+{
+    if (m_pendingPermissions.isEmpty() || m_permissionState == permission::STATUS_ASK)
+        return;
+
+    for (const auto& pendingPermission : m_pendingPermissions)
+        pendingPermission.Run(m_permissionState);
+    m_permissionState = permission::STATUS_ASK;
+    m_pendingPermissions.clear();
 }
 
 DEFINE_TRACE(GeolocationClientMock)
 {
-#if ENABLE(OILPAN)
-    visitor->trace(m_controllers);
-#endif
-    visitor->trace(m_lastPosition);
+    WillBeHeapSupplement<Document>::trace(visitor);
     visitor->trace(m_pendingPermissions);
-    GeolocationClient::trace(visitor);
+    visitor->trace(m_pendingGeolocations);
 }
 
 } // namespace blink