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:
+        NOTREACHED();
         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)
+    : ContextLifecycleObserver(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);
+    ContextLifecycleObserver::trace(visitor);
+    PageLifecycleObserver::trace(visitor);
 }
 
 Document* Geolocation::document() const
 {
     return toDocument(getExecutionContext());
 }
 
 LocalFrame* Geolocation::frame() const
 {
     return document() ? document()->frame() : 0;
 }
 
-void Geolocation::stop()
+void Geolocation::contextDestroyed()
 {
-    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.
-    m_geolocationPermission = PermissionUnknown;
     cancelAllRequests();
     stopUpdating();
+    m_geolocationPermission = PermissionDenied;
     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;
+    ContextLifecycleObserver::clearContext();
+    PageLifecycleObserver::clearContext();
 }
 
 void Geolocation::recordOriginTypeAccess() const
 {
     ASSERT(frame());
 
     Document* document = this->document();
     ASSERT(document);
 
     // It is required by isSecureContext() but isn't
@@ skipping 59 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;
+    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 (!getExecutionContext() || !page() || !page()->isPageVisible() || !m_updating) {
+        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