Move GeolocationDispatcher into blink.

third_party/WebKit/Source/modules/geolocation/Geolocation.cpp

 /*
  * Copyright (C) 2008, 2009, 2010, 2011 Apple Inc. All Rights Reserved.
  * Copyright (C) 2009 Torch Mobile, Inc.
  * Copyright 2010, The Android Open Source Project
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 14 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "modules/geolocation/Geolocation.h"
 
 #include "core/dom/Document.h"
 #include "core/frame/Deprecation.h"
 #include "core/frame/OriginsUsingFeatures.h"
 #include "core/frame/Settings.h"
 #include "modules/geolocation/Coordinates.h"
-#include "modules/geolocation/GeolocationController.h"
 #include "modules/geolocation/GeolocationError.h"
-#include "modules/geolocation/GeolocationPosition.h"
-#include "platform/weborigin/SecurityOrigin.h"
+#include "platform/mojo/MojoHelper.h"
+#include "public/platform/ServiceRegistry.h"
 #include "wtf/CurrentTime.h"
 
 namespace blink {
+namespace {
 
 static const char permissionDeniedErrorMessage[] = "User denied Geolocation";
 static const char failedToStartServiceErrorMessage[] = "Failed to start Geolocation service";
 static const char framelessDocumentErrorMessage[] = "Geolocation cannot be used in frameless documents";
 
-static Geoposition* createGeoposition(GeolocationPosition* position)
+static Geoposition* createGeoposition(const mojom::blink::Geoposition& position)
 {
-    if (!position)
-        return nullptr;
-
     Coordinates* coordinates = Coordinates::create(
-        position->latitude(),
-        position->longitude(),
-        position->canProvideAltitude(),
-        position->altitude(),
-        position->accuracy(),
-        position->canProvideAltitudeAccuracy(),
-        position->altitudeAccuracy(),
-        position->canProvideHeading(),
-        position->heading(),
-        position->canProvideSpeed(),
-        position->speed());
-    return Geoposition::create(coordinates, convertSecondsToDOMTimeStamp(position->timestamp()));
+        position.latitude,
+        position.longitude,
+        position.altitude > -10000.,
+        position.altitude,
+        position.accuracy,
+        position.altitude_accuracy >= 0.,
+        position.altitude_accuracy,
+        position.heading >= 0. && position.heading <= 360.,
+        position.heading,
+        position.speed >= 0.,
+        position.speed);
+    return Geoposition::create(coordinates, convertSecondsToDOMTimeStamp(position.timestamp));
 }
 
-static PositionError* createPositionError(GeolocationError* error)
+static PositionError* createPositionError(mojom::blink::Geoposition::ErrorCode mojomErrorCode, const String& error)
 {
-    PositionError::ErrorCode code = PositionError::POSITION_UNAVAILABLE;
-    switch (error->code()) {
-    case GeolocationError::PermissionDenied:
-        code = PositionError::PERMISSION_DENIED;
+    PositionError::ErrorCode errorCode = PositionError::POSITION_UNAVAILABLE;
+    switch (mojomErrorCode) {
+    case mojom::blink::Geoposition::ErrorCode::PERMISSION_DENIED:
+        errorCode = PositionError::PERMISSION_DENIED;
         break;
-    case GeolocationError::PositionUnavailable:
-        code = PositionError::POSITION_UNAVAILABLE;
+    case mojom::blink::Geoposition::ErrorCode::POSITION_UNAVAILABLE:
+        errorCode = PositionError::POSITION_UNAVAILABLE;
+        break;
+    case mojom::blink::Geoposition::ErrorCode::NONE:
+    case mojom::blink::Geoposition::ErrorCode::TIMEOUT:
+        ASSERT_NOT_REACHED();

[Marijn Kruisselbrink, 2016/05/06 20:12:15]

ASSERT_NOT_REACHED() is deprecated in favor of NOTREACHED()

[Sam McNally, 2016/05/10 10:06:08]

Done.

         break;
     }
+    return PositionError::create(errorCode, error);
+}
 
-    return PositionError::create(code, error->message());
-}
+} // namespace
 
 Geolocation* Geolocation::create(ExecutionContext* context)
 {
     Geolocation* geolocation = new Geolocation(context);
     geolocation->suspendIfNeeded();
     return geolocation;
 }
 
 Geolocation::Geolocation(ExecutionContext* context)
     : ActiveDOMObject(context)
+    , PageLifecycleObserver(document()->page())
     , m_geolocationPermission(PermissionUnknown)
 {
+    ThreadState::current()->registerPreFinalizer(this);
 }
 
 Geolocation::~Geolocation()
 {
     ASSERT(m_geolocationPermission != PermissionRequested);
 }
 
 DEFINE_TRACE(Geolocation)
 {
     visitor->trace(m_oneShots);
     visitor->trace(m_watchers);
     visitor->trace(m_pendingForPermissionNotifiers);
     visitor->trace(m_lastPosition);
-    visitor->trace(m_requestsAwaitingCachedPosition);
     ActiveDOMObject::trace(visitor);
+    PageLifecycleObserver::trace(visitor);
 }
 
 Document* Geolocation::document() const
 {
     return toDocument(getExecutionContext());
 }
 
 LocalFrame* Geolocation::frame() const
 {
     return document() ? document()->frame() : 0;
 }
 
 void Geolocation::stop()

[Michael van Ouwerkerk, 2016/05/09 17:22:31]

I think this should also stop observing Page:
"PageLifecycleObserver::clearContext();"

While PageLifecycleObserver only holds a WeakMember, it will happily continue
calling pageVisibilityChanged until it's really destroyed by the GC.

[Sam McNally, 2016/05/10 10:06:08]

Done.

[dcheng, 2016/05/10 23:55:29]

I don't think a swept Page should be doing any visibility changes, that would be
pretty broken.

[Michael van Ouwerkerk, 2016/05/11 12:38:30]

The issue seems to be that while ContextLifecycleObserver might notify
contextDestroyed, Page outlives it. So if Geolocation is still observing Page,
it may continue to receive calls to pageVisibilityChanged until the GC gets
around to actually destroying Geolocation.

 {
-    LocalFrame* frame = this->frame();
-    if (frame && m_geolocationPermission == PermissionRequested)
-        GeolocationController::from(frame)->cancelPermissionRequest(this);
+    if (m_permissionService)
+        m_permissionService.reset();
 
-    // The frame may be moving to a new page and we want to get the permissions from the new page's client.
+    // The frame may be moving to a new page and we want to get the permissions from the new page's permission service.

[Michael van Ouwerkerk, 2016/05/09 17:22:31]

I think there's more that has changed than just GeolocationClient being deleted.
The GeolocationController was a supplement of LocalFrame, which could load sites
of different origins. And in the past, the GeolocationController was a
supplement of Page, with lived even longer. The controller is gone in this CL.
The remaining supplement is NavigatorGeolocation which should not be reused
across navigations, so this entire comment no longer makes sense. Do you think
we even need to reset m_geolocationPermission anymore? Under what circumstances
would any method of this class be called after stop is called? It is garbage
collected, so it might stay alive for a while after stop is called.

We should probably call ActiveDOMObject::clearContext() here, as it is not
currently automatically cleared. See:
https://docs.google.com/document/d/1ji_010aI_OCQon08VATF_0dthK_GCHfPZ8CHblkao...

[dcheng, 2016/05/09 18:22:29]

I don't understand this comment. What does it mean 'frame might be moving to a
new Page'?

[Sam McNally, 2016/05/10 10:06:08]

I didn't think that Geolocation objects would be reused, but I don't have a
great understanding of lifetimes in blink. It does appear to be necessary to
change the permission from requested as there is an assert in the destructor.
I've changed it to denied.
Done.

     m_geolocationPermission = PermissionUnknown;
     cancelAllRequests();
     stopUpdating();
     m_pendingForPermissionNotifiers.clear();
-}
-
-Geoposition* Geolocation::lastPosition()
-{
-    LocalFrame* frame = this->frame();
-    if (!frame)
-        return 0;
-
-    m_lastPosition = createGeoposition(GeolocationController::from(frame)->lastPosition());
-
-    return m_lastPosition;
+    m_lastPosition = nullptr;
 }
 
 void Geolocation::recordOriginTypeAccess() const
 {
     ASSERT(frame());
 
     Document* document = this->document();
     ASSERT(document);
 
     // It is required by isSecureContext() but isn't
@@ skipping 51 matching lines @@
     if (isDenied())
         notifier->setFatalError(PositionError::create(PositionError::PERMISSION_DENIED, permissionDeniedErrorMessage));
     else if (haveSuitableCachedPosition(notifier->options()))
         notifier->setUseCachedPosition();
     else if (!notifier->options().timeout())
         notifier->startTimer();
     else if (!isAllowed()) {
         // if we don't yet have permission, request for permission before calling startUpdating()
         m_pendingForPermissionNotifiers.add(notifier);
         requestPermission();
-    } else if (startUpdating(notifier))
+    } else {
+        startUpdating(notifier);
         notifier->startTimer();
-    else
-        notifier->setFatalError(PositionError::create(PositionError::POSITION_UNAVAILABLE, failedToStartServiceErrorMessage));
+    }
 }
 
 void Geolocation::fatalErrorOccurred(GeoNotifier* notifier)
 {
     // This request has failed fatally. Remove it from our lists.
     m_oneShots.remove(notifier);
     m_watchers.remove(notifier);
 
     if (!hasListeners())
         stopUpdating();
 }
 
 void Geolocation::requestUsesCachedPosition(GeoNotifier* notifier)
 {
-    // This is called asynchronously, so the permissions could have been denied
-    // since we last checked in startRequest.
-    if (isDenied()) {
-        notifier->setFatalError(PositionError::create(PositionError::PERMISSION_DENIED, permissionDeniedErrorMessage));
-        return;
+    DCHECK(isAllowed());
+
+    notifier->runSuccessCallback(m_lastPosition);
+
+    // If this is a one-shot request, stop it. Otherwise, if the watch still
+    // exists, start the service to get updates.
+    if (m_oneShots.contains(notifier)) {
+        m_oneShots.remove(notifier);
+    } else if (m_watchers.contains(notifier)) {
+        if (notifier->options().timeout())
+            startUpdating(notifier);
+        notifier->startTimer();
     }
 
-    m_requestsAwaitingCachedPosition.add(notifier);
-
-    // If permissions are allowed, make the callback
-    if (isAllowed()) {
-        makeCachedPositionCallbacks();
-        return;
-    }
-
-    // Request permissions, which may be synchronous or asynchronous.
-    requestPermission();
-}
-
-void Geolocation::makeCachedPositionCallbacks()
-{
-    // All modifications to m_requestsAwaitingCachedPosition are done
-    // asynchronously, so we don't need to worry about it being modified from
-    // the callbacks.
-    for (GeoNotifier* notifier : m_requestsAwaitingCachedPosition) {
-        notifier->runSuccessCallback(lastPosition());
-
-        // If this is a one-shot request, stop it. Otherwise, if the watch still
-        // exists, start the service to get updates.
-        if (m_oneShots.contains(notifier))
-            m_oneShots.remove(notifier);
-        else if (m_watchers.contains(notifier)) {
-            if (!notifier->options().timeout() || startUpdating(notifier))
-                notifier->startTimer();
-            else
-                notifier->setFatalError(PositionError::create(PositionError::POSITION_UNAVAILABLE, failedToStartServiceErrorMessage));
-        }
-    }
-
-    m_requestsAwaitingCachedPosition.clear();
-
     if (!hasListeners())
         stopUpdating();
 }
 
 void Geolocation::requestTimedOut(GeoNotifier* notifier)
 {
     // If this is a one-shot request, stop it.
     m_oneShots.remove(notifier);
 
     if (!hasListeners())
         stopUpdating();
 }
 
 bool Geolocation::haveSuitableCachedPosition(const PositionOptions& options)
 {
-    Geoposition* cachedPosition = lastPosition();
-    if (!cachedPosition)
+    if (!m_lastPosition)
         return false;
+    DCHECK(isAllowed());
     if (!options.maximumAge())
         return false;
     DOMTimeStamp currentTimeMillis = convertSecondsToDOMTimeStamp(currentTime());
-    return cachedPosition->timestamp() > currentTimeMillis - options.maximumAge();
+    return m_lastPosition->timestamp() > currentTimeMillis - options.maximumAge();
 }
 
 void Geolocation::clearWatch(int watchID)
 {
     if (watchID <= 0)
         return;
 
     if (GeoNotifier* notifier = m_watchers.find(watchID))
         m_pendingForPermissionNotifiers.remove(notifier);
     m_watchers.remove(watchID);
 
     if (!hasListeners())
         stopUpdating();
 }
 
-void Geolocation::setIsAllowed(bool allowed)
+void Geolocation::onGeolocationPermissionUpdated(mojom::blink::PermissionStatus status)
 {
     // This may be due to either a new position from the service, or a cached position.
-    m_geolocationPermission = allowed ? PermissionAllowed : PermissionDenied;
+    m_geolocationPermission = status == mojom::blink::PermissionStatus::GRANTED ? PermissionAllowed : PermissionDenied;
+    m_permissionService.reset();
 
-    // Permission request was made during the startRequest process
-    if (!m_pendingForPermissionNotifiers.isEmpty()) {
-        handlePendingPermissionNotifiers();
-        m_pendingForPermissionNotifiers.clear();
-        return;
+    // While we iterate through the list, we need not worry about the list being modified as the permission
+    // is already set to Yes/No and no new listeners will be added to the pending list.
+    for (GeoNotifier* notifier : m_pendingForPermissionNotifiers) {
+        if (isAllowed()) {
+            // Start all pending notification requests as permission granted.
+            // The notifier is always ref'ed by m_oneShots or m_watchers.
+            startUpdating(notifier);
+            notifier->startTimer();
+        } else {
+            notifier->setFatalError(PositionError::create(PositionError::PERMISSION_DENIED, permissionDeniedErrorMessage));
+        }
     }
-
-    if (!isAllowed()) {
-        PositionError* error = PositionError::create(PositionError::PERMISSION_DENIED, permissionDeniedErrorMessage);
-        error->setIsFatal(true);
-        handleError(error);
-        m_requestsAwaitingCachedPosition.clear();
-        return;
-    }
-
-    // If the service has a last position, use it to call back for all requests.
-    // If any of the requests are waiting for permission for a cached position,
-    // the position from the service will be at least as fresh.
-    if (lastPosition())
-        makeSuccessCallbacks();
-    else
-        makeCachedPositionCallbacks();
+    m_pendingForPermissionNotifiers.clear();
 }
 
 void Geolocation::sendError(GeoNotifierVector& notifiers, PositionError* error)
 {
     for (GeoNotifier* notifier : notifiers)
         notifier->runErrorCallback(error);
 }
 
 void Geolocation::sendPosition(GeoNotifierVector& notifiers, Geoposition* position)
 {
@@ skipping 102 matching lines @@
 void Geolocation::requestPermission()
 {
     if (m_geolocationPermission != PermissionUnknown)
         return;
 
     LocalFrame* frame = this->frame();
     if (!frame)
         return;
 
     m_geolocationPermission = PermissionRequested;
+    frame->serviceRegistry()->connectToRemoteService(
+        mojo::GetProxy(&m_permissionService));
+    m_permissionService.set_connection_error_handler(sameThreadBindForMojo(&Geolocation::onPermissionConnectionError, this));
 
     // Ask the embedder: it maintains the geolocation challenge policy itself.
-    GeolocationController::from(frame)->requestPermission(this);
+    m_permissionService->RequestPermission(
+        mojom::blink::PermissionName::GEOLOCATION,
+        getExecutionContext()->getSecurityOrigin()->toString(),
+        sameThreadBindForMojo(&Geolocation::onGeolocationPermissionUpdated, this));
 }
 
 void Geolocation::makeSuccessCallbacks()
 {
-    ASSERT(lastPosition());
+    ASSERT(m_lastPosition);
     ASSERT(isAllowed());
 
     GeoNotifierVector oneShotsCopy;
     copyToVector(m_oneShots, oneShotsCopy);
 
     GeoNotifierVector watchersCopy;
     m_watchers.getNotifiersVector(watchersCopy);
 
     // Clear the lists before we make the callbacks, to avoid clearing notifiers
     // added by calls to Geolocation methods from the callbacks, and to prevent
     // further callbacks to these notifiers.
     m_oneShots.clear();
 
-    // Also clear the set of notifiers waiting for a cached position. All the
-    // oneshots and watchers will receive a position now, and if they happen to
-    // be lingering in that set, avoid this bug: http://crbug.com/311876 .
-    m_requestsAwaitingCachedPosition.clear();
-
-    sendPosition(oneShotsCopy, lastPosition());
-    sendPosition(watchersCopy, lastPosition());
+    sendPosition(oneShotsCopy, m_lastPosition);
+    sendPosition(watchersCopy, m_lastPosition);
 
     if (!hasListeners())
         stopUpdating();
 }
 
 void Geolocation::positionChanged()
 {
     ASSERT(isAllowed());
 
     // Stop all currently running timers.
     stopTimers();
 
     makeSuccessCallbacks();
 }
 
-void Geolocation::setError(GeolocationError* error)
+void Geolocation::startUpdating(GeoNotifier* notifier)
 {
-    handleError(createPositionError(error));
-}
-
-bool Geolocation::startUpdating(GeoNotifier* notifier)
-{
-    LocalFrame* frame = this->frame();
-    if (!frame)
-        return false;
-
-    GeolocationController::from(frame)->addObserver(this, notifier->options().enableHighAccuracy());
-    return true;
+    // This may be called multiple times, though stopUpdating() is called only

[Michael van Ouwerkerk, 2016/05/09 17:22:31]

There are many calls to stopUpdating(). What did you mean to express here?

[Sam McNally, 2016/05/10 10:06:08]

It was copy-pasted from GeolocationController and changed slightly. I don't
think it's useful anymore.

+    // once.
+    m_updating = true;
+    if (notifier->options().enableHighAccuracy() && !m_enableHighAccuracy) {
+        m_enableHighAccuracy = true;
+        if (m_geolocationService)
+            m_geolocationService->SetHighAccuracy(true);
+    }
+    updateGeolocationServiceConnection();
 }
 
 void Geolocation::stopUpdating()
 {
-    LocalFrame* frame = this->frame();
-    if (!frame)
+    m_updating = false;
+    updateGeolocationServiceConnection();
+    m_enableHighAccuracy = false;
+}
+
+void Geolocation::updateGeolocationServiceConnection()
+{
+    if (!page() || !page()->isPageVisible() || !m_updating) {

[Michael van Ouwerkerk, 2016/05/09 17:22:31]

This should also check that getExecutionContext() does not return null.

[Sam McNally, 2016/05/10 10:06:08]

Done.

+        m_geolocationService.reset();
+        m_disconnectedGeolocationService = true;
+        return;
+    }
+    if (m_geolocationService)
         return;
 
-    GeolocationController::from(frame)->removeObserver(this);
+    frame()->serviceRegistry()->connectToRemoteService(mojo::GetProxy(&m_geolocationService));
+    m_geolocationService.set_connection_error_handler(sameThreadBindForMojo(&Geolocation::onGeolocationConnectionError, this));
+    if (m_enableHighAccuracy)
+        m_geolocationService->SetHighAccuracy(true);
+    queryNextPosition();
 }
 
-void Geolocation::handlePendingPermissionNotifiers()
+void Geolocation::queryNextPosition()
 {
-    // While we iterate through the list, we need not worry about list being modified as the permission
-    // is already set to Yes/No and no new listeners will be added to the pending list.
-    for (GeoNotifier* notifier : m_pendingForPermissionNotifiers) {
-        if (isAllowed()) {
-            // start all pending notification requests as permission granted.
-            // The notifier is always ref'ed by m_oneShots or m_watchers.
-            if (startUpdating(notifier))
-                notifier->startTimer();
-            else
-                notifier->setFatalError(PositionError::create(PositionError::POSITION_UNAVAILABLE, failedToStartServiceErrorMessage));
-        } else {
-            notifier->setFatalError(PositionError::create(PositionError::PERMISSION_DENIED, permissionDeniedErrorMessage));
-        }
+    m_geolocationService->QueryNextPosition(
+        sameThreadBindForMojo(&Geolocation::onPositionUpdated, this));
+}
+
+void Geolocation::onPositionUpdated(mojom::blink::GeopositionPtr position)
+{
+    m_disconnectedGeolocationService = false;
+    if (position->valid) {
+        m_lastPosition = createGeoposition(*position);
+        positionChanged();
+    } else {
+        handleError(createPositionError(position->error_code, position->error_message));
     }
+    if (!m_disconnectedGeolocationService)
+        queryNextPosition();
+}
+
+void Geolocation::pageVisibilityChanged()
+{
+    updateGeolocationServiceConnection();
+}
+
+void Geolocation::onGeolocationConnectionError()
+{
+    PositionError* error = PositionError::create(PositionError::POSITION_UNAVAILABLE, failedToStartServiceErrorMessage);
+    error->setIsFatal(true);
+    handleError(error);
+}
+
+void Geolocation::onPermissionConnectionError()
+{
+    onGeolocationPermissionUpdated(mojom::blink::PermissionStatus::DENIED);
 }
 
 } // namespace blink