third_party/WebKit/Source/modules/geolocation/Geolocation.cpp - chromium/src - Git at Google

 /*
  * 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.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 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 "modules/geolocation/Geolocation.h"

 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/frame/OriginsUsingFeatures.h"
 #include "core/frame/Settings.h"
 #include "core/frame/UseCounter.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "modules/geolocation/Coordinates.h"
 #include "modules/geolocation/GeolocationController.h"
 #include "modules/geolocation/GeolocationError.h"
 #include "modules/geolocation/GeolocationPosition.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "wtf/CurrentTime.h"

 namespace blink {

 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)
 {
     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()));
 }

 static PositionError* createPositionError(GeolocationError* error)
 {
     PositionError::ErrorCode code = PositionError::POSITION_UNAVAILABLE;
     switch (error->code()) {
     case GeolocationError::PermissionDenied:
         code = PositionError::PERMISSION_DENIED;
         break;
     case GeolocationError::PositionUnavailable:
         code = PositionError::POSITION_UNAVAILABLE;
         break;
     }

     return PositionError::create(code, error->message());
 }

 Geolocation* Geolocation::create(ExecutionContext* context)
 {
     Geolocation* geolocation = new Geolocation(context);
     geolocation->suspendIfNeeded();
     return geolocation;
 }

 Geolocation::Geolocation(ExecutionContext* context)
     : ActiveDOMObject(context)
     , m_geolocationPermission(PermissionUnknown)
 {
 }

 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);
 }

 Document* Geolocation::document() const
 {
     return toDocument(executionContext());
 }

 LocalFrame* Geolocation::frame() const
 {
     return document() ? document()->frame() : 0;
 }

 void Geolocation::stop()
 {
     LocalFrame* frame = this->frame();
     if (frame && m_geolocationPermission == PermissionRequested)
         GeolocationController::from(frame)->cancelPermissionRequest(this);

     // 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_pendingForPermissionNotifiers.clear();
 }

 Geoposition* Geolocation::lastPosition()
 {
     LocalFrame* frame = this->frame();
     if (!frame)
         return 0;

     m_lastPosition = createGeoposition(GeolocationController::from(frame)->lastPosition());

     return m_lastPosition.get();
 }

 void Geolocation::recordOriginTypeAccess() const
 {
     ASSERT(frame());

     Document* document = this->document();
     ASSERT(document);

     // It is required by isSecureContext() but isn't
     // actually used. This could be used later if a warning is shown in the
     // developer console.
     String insecureOriginMsg;
     if (document->isSecureContext(insecureOriginMsg)) {
         UseCounter::count(document, UseCounter::GeolocationSecureOrigin);
     } else {
         UseCounter::countDeprecation(document, UseCounter::GeolocationInsecureOrigin);
         OriginsUsingFeatures::countAnyWorld(*document, OriginsUsingFeatures::Feature::GeolocationInsecureOrigin);
     }
 }

 void Geolocation::getCurrentPosition(PositionCallback* successCallback, PositionErrorCallback* errorCallback, const PositionOptions& options)
 {
     if (!frame())
         return;

     recordOriginTypeAccess();

     GeoNotifier* notifier = GeoNotifier::create(this, successCallback, errorCallback, options);
     startRequest(notifier);

     m_oneShots.add(notifier);
 }

 int Geolocation::watchPosition(PositionCallback* successCallback, PositionErrorCallback* errorCallback, const PositionOptions& options)
 {
     if (!frame())
         return 0;

     recordOriginTypeAccess();

     GeoNotifier* notifier = GeoNotifier::create(this, successCallback, errorCallback, options);
     startRequest(notifier);

     int watchID;
     // Keep asking for the next id until we're given one that we don't already have.
     do {
         watchID = executionContext()->circularSequentialID();
     } while (!m_watchers.add(watchID, notifier));
     return watchID;
 }

 void Geolocation::startRequest(GeoNotifier *notifier)
 {
     if (frame()->settings()->strictPowerfulFeatureRestrictions()) {
         String errorMessage;
         if (!executionContext()->isSecureContext(errorMessage)) {
             notifier->setFatalError(PositionError::create(PositionError::POSITION_UNAVAILABLE, errorMessage));
             return;
         }
     }

     if (RuntimeEnabledFeatures::restrictIFramePermissionsEnabled()) {
         // TODO(keenanb): kill the request if the parent is blocking the requester
         Element* owner = document()->ownerElement();
         if (owner && owner->hasAttribute(HTMLNames::permissionsAttr)) {
             String errorMessage = "A cross-origin iframe needs its permissions attribute properly set in order to use the geolocation API.";
             notifier->setFatalError(PositionError::create(PositionError::POSITION_UNAVAILABLE, errorMessage));
             return;
         }
     }

     // Check whether permissions have already been denied. Note that if this is the case,
     // the permission state can not change again in the lifetime of this page.
     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))
         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;
     }

     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)
         return false;
     if (!options.maximumAge())
         return false;
     DOMTimeStamp currentTimeMillis = convertSecondsToDOMTimeStamp(currentTime());
     return cachedPosition->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)
 {
     // This may be due to either a new position from the service, or a cached position.
     m_geolocationPermission = allowed ? PermissionAllowed : PermissionDenied;

     // Permission request was made during the startRequest process
     if (!m_pendingForPermissionNotifiers.isEmpty()) {
         handlePendingPermissionNotifiers();
         m_pendingForPermissionNotifiers.clear();
         return;
     }

     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();
 }

 void Geolocation::sendError(GeoNotifierVector& notifiers, PositionError* error)
 {
     for (GeoNotifier* notifier : notifiers)
         notifier->runErrorCallback(error);
 }

 void Geolocation::sendPosition(GeoNotifierVector& notifiers, Geoposition* position)
 {
     for (GeoNotifier* notifier : notifiers)
         notifier->runSuccessCallback(position);
 }

 void Geolocation::stopTimer(GeoNotifierVector& notifiers)
 {
     for (GeoNotifier* notifier : notifiers)
         notifier->stopTimer();
 }

 void Geolocation::stopTimersForOneShots()
 {
     GeoNotifierVector copy;
     copyToVector(m_oneShots, copy);

     stopTimer(copy);
 }

 void Geolocation::stopTimersForWatchers()
 {
     GeoNotifierVector copy;
     m_watchers.getNotifiersVector(copy);

     stopTimer(copy);
 }

 void Geolocation::stopTimers()
 {
     stopTimersForOneShots();
     stopTimersForWatchers();
 }

 void Geolocation::cancelRequests(GeoNotifierVector& notifiers)
 {
     for (GeoNotifier* notifier : notifiers)
         notifier->setFatalError(PositionError::create(PositionError::POSITION_UNAVAILABLE, framelessDocumentErrorMessage));
 }

 void Geolocation::cancelAllRequests()
 {
     GeoNotifierVector copy;
     copyToVector(m_oneShots, copy);
     cancelRequests(copy);
     m_watchers.getNotifiersVector(copy);
     cancelRequests(copy);
 }

 void Geolocation::extractNotifiersWithCachedPosition(GeoNotifierVector& notifiers, GeoNotifierVector* cached)
 {
     GeoNotifierVector nonCached;
     for (GeoNotifier* notifier : notifiers) {
         if (notifier->useCachedPosition()) {
             if (cached)
                 cached->append(notifier);
         } else
             nonCached.append(notifier);
     }
     notifiers.swap(nonCached);
 }

 void Geolocation::copyToSet(const GeoNotifierVector& src, GeoNotifierSet& dest)
 {
     for (GeoNotifier* notifier : src)
          dest.add(notifier);
 }

 void Geolocation::handleError(PositionError* error)
 {
     ASSERT(error);

     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.
     GeoNotifierVector oneShotsWithCachedPosition;
     m_oneShots.clear();
     if (error->isFatal())
         m_watchers.clear();
     else {
         // Don't send non-fatal errors to notifiers due to receive a cached position.
         extractNotifiersWithCachedPosition(oneShotsCopy, &oneShotsWithCachedPosition);
         extractNotifiersWithCachedPosition(watchersCopy, 0);
     }

     sendError(oneShotsCopy, error);
     sendError(watchersCopy, error);

     // hasListeners() doesn't distinguish between notifiers due to receive a
     // cached position and those requiring a fresh position. Perform the check
     // before restoring the notifiers below.
     if (!hasListeners())
         stopUpdating();

     // Maintain a reference to the cached notifiers until their timer fires.
     copyToSet(oneShotsWithCachedPosition, m_oneShots);
 }

 void Geolocation::requestPermission()
 {
     if (m_geolocationPermission != PermissionUnknown)
         return;

     LocalFrame* frame = this->frame();
     if (!frame)
         return;

     m_geolocationPermission = PermissionRequested;

     // Ask the embedder: it maintains the geolocation challenge policy itself.
     GeolocationController::from(frame)->requestPermission(this);
 }

 void Geolocation::makeSuccessCallbacks()
 {
     ASSERT(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());

     if (!hasListeners())
         stopUpdating();
 }

 void Geolocation::positionChanged()
 {
     ASSERT(isAllowed());

     // Stop all currently running timers.
     stopTimers();

     makeSuccessCallbacks();
 }

 void Geolocation::setError(GeolocationError* error)
 {
     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;
 }

 void Geolocation::stopUpdating()
 {
     LocalFrame* frame = this->frame();
     if (!frame)
         return;

     GeolocationController::from(frame)->removeObserver(this);
 }

 void Geolocation::handlePendingPermissionNotifiers()
 {
     // 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));
         }
     }
 }

 } // namespace blink
	/*
	* 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.
	* 2. Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution.
	*
	* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 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 "modules/geolocation/Geolocation.h"

	#include "core/dom/Document.h"
	#include "core/dom/Element.h"
	#include "core/frame/OriginsUsingFeatures.h"
	#include "core/frame/Settings.h"
	#include "core/frame/UseCounter.h"
	#include "core/html/HTMLFrameOwnerElement.h"
	#include "modules/geolocation/Coordinates.h"
	#include "modules/geolocation/GeolocationController.h"
	#include "modules/geolocation/GeolocationError.h"
	#include "modules/geolocation/GeolocationPosition.h"
	#include "platform/RuntimeEnabledFeatures.h"
	#include "platform/weborigin/SecurityOrigin.h"
	#include "wtf/CurrentTime.h"

	namespace blink {

	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)
	{
	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()));
	}

	static PositionError* createPositionError(GeolocationError* error)
	{
	PositionError::ErrorCode code = PositionError::POSITION_UNAVAILABLE;
	switch (error->code()) {
	case GeolocationError::PermissionDenied:
	code = PositionError::PERMISSION_DENIED;
	break;
	case GeolocationError::PositionUnavailable:
	code = PositionError::POSITION_UNAVAILABLE;
	break;
	}

	return PositionError::create(code, error->message());
	}

	Geolocation* Geolocation::create(ExecutionContext* context)
	{
	Geolocation* geolocation = new Geolocation(context);
	geolocation->suspendIfNeeded();
	return geolocation;
	}

	Geolocation::Geolocation(ExecutionContext* context)
	: ActiveDOMObject(context)
	, m_geolocationPermission(PermissionUnknown)
	{
	}

	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);
	}

	Document* Geolocation::document() const
	{
	return toDocument(executionContext());
	}

	LocalFrame* Geolocation::frame() const
	{
	return document() ? document()->frame() : 0;
	}

	void Geolocation::stop()
	{
	LocalFrame* frame = this->frame();
	if (frame && m_geolocationPermission == PermissionRequested)
	GeolocationController::from(frame)->cancelPermissionRequest(this);

	// 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_pendingForPermissionNotifiers.clear();
	}

	Geoposition* Geolocation::lastPosition()
	{
	LocalFrame* frame = this->frame();
	if (!frame)
	return 0;

	m_lastPosition = createGeoposition(GeolocationController::from(frame)->lastPosition());

	return m_lastPosition.get();
	}

	void Geolocation::recordOriginTypeAccess() const
	{
	ASSERT(frame());

	Document* document = this->document();
	ASSERT(document);

	// It is required by isSecureContext() but isn't
	// actually used. This could be used later if a warning is shown in the
	// developer console.
	String insecureOriginMsg;
	if (document->isSecureContext(insecureOriginMsg)) {
	UseCounter::count(document, UseCounter::GeolocationSecureOrigin);
	} else {
	UseCounter::countDeprecation(document, UseCounter::GeolocationInsecureOrigin);
	OriginsUsingFeatures::countAnyWorld(*document, OriginsUsingFeatures::Feature::GeolocationInsecureOrigin);
	}
	}

	void Geolocation::getCurrentPosition(PositionCallback* successCallback, PositionErrorCallback* errorCallback, const PositionOptions& options)
	{
	if (!frame())
	return;

	recordOriginTypeAccess();

	GeoNotifier* notifier = GeoNotifier::create(this, successCallback, errorCallback, options);
	startRequest(notifier);

	m_oneShots.add(notifier);
	}

	int Geolocation::watchPosition(PositionCallback* successCallback, PositionErrorCallback* errorCallback, const PositionOptions& options)
	{
	if (!frame())
	return 0;

	recordOriginTypeAccess();

	GeoNotifier* notifier = GeoNotifier::create(this, successCallback, errorCallback, options);
	startRequest(notifier);

	int watchID;
	// Keep asking for the next id until we're given one that we don't already have.
	do {
	watchID = executionContext()->circularSequentialID();
	} while (!m_watchers.add(watchID, notifier));
	return watchID;
	}

	void Geolocation::startRequest(GeoNotifier *notifier)
	{
	if (frame()->settings()->strictPowerfulFeatureRestrictions()) {
	String errorMessage;
	if (!executionContext()->isSecureContext(errorMessage)) {
	notifier->setFatalError(PositionError::create(PositionError::POSITION_UNAVAILABLE, errorMessage));
	return;
	}
	}

	if (RuntimeEnabledFeatures::restrictIFramePermissionsEnabled()) {
	// TODO(keenanb): kill the request if the parent is blocking the requester
	Element* owner = document()->ownerElement();
	if (owner && owner->hasAttribute(HTMLNames::permissionsAttr)) {
	String errorMessage = "A cross-origin iframe needs its permissions attribute properly set in order to use the geolocation API.";
	notifier->setFatalError(PositionError::create(PositionError::POSITION_UNAVAILABLE, errorMessage));
	return;
	}
	}

	// Check whether permissions have already been denied. Note that if this is the case,
	// the permission state can not change again in the lifetime of this page.
	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))
	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;
	}

	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)
	return false;
	if (!options.maximumAge())
	return false;
	DOMTimeStamp currentTimeMillis = convertSecondsToDOMTimeStamp(currentTime());
	return cachedPosition->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)
	{
	// This may be due to either a new position from the service, or a cached position.
	m_geolocationPermission = allowed ? PermissionAllowed : PermissionDenied;

	// Permission request was made during the startRequest process
	if (!m_pendingForPermissionNotifiers.isEmpty()) {
	handlePendingPermissionNotifiers();
	m_pendingForPermissionNotifiers.clear();
	return;
	}

	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();
	}

	void Geolocation::sendError(GeoNotifierVector& notifiers, PositionError* error)
	{
	for (GeoNotifier* notifier : notifiers)
	notifier->runErrorCallback(error);
	}

	void Geolocation::sendPosition(GeoNotifierVector& notifiers, Geoposition* position)
	{
	for (GeoNotifier* notifier : notifiers)
	notifier->runSuccessCallback(position);
	}

	void Geolocation::stopTimer(GeoNotifierVector& notifiers)
	{
	for (GeoNotifier* notifier : notifiers)
	notifier->stopTimer();
	}

	void Geolocation::stopTimersForOneShots()
	{
	GeoNotifierVector copy;
	copyToVector(m_oneShots, copy);

	stopTimer(copy);
	}

	void Geolocation::stopTimersForWatchers()
	{
	GeoNotifierVector copy;
	m_watchers.getNotifiersVector(copy);

	stopTimer(copy);
	}

	void Geolocation::stopTimers()
	{
	stopTimersForOneShots();
	stopTimersForWatchers();
	}

	void Geolocation::cancelRequests(GeoNotifierVector& notifiers)
	{
	for (GeoNotifier* notifier : notifiers)
	notifier->setFatalError(PositionError::create(PositionError::POSITION_UNAVAILABLE, framelessDocumentErrorMessage));
	}

	void Geolocation::cancelAllRequests()
	{
	GeoNotifierVector copy;
	copyToVector(m_oneShots, copy);
	cancelRequests(copy);
	m_watchers.getNotifiersVector(copy);
	cancelRequests(copy);
	}

	void Geolocation::extractNotifiersWithCachedPosition(GeoNotifierVector& notifiers, GeoNotifierVector* cached)
	{
	GeoNotifierVector nonCached;
	for (GeoNotifier* notifier : notifiers) {
	if (notifier->useCachedPosition()) {
	if (cached)
	cached->append(notifier);
	} else
	nonCached.append(notifier);
	}
	notifiers.swap(nonCached);
	}

	void Geolocation::copyToSet(const GeoNotifierVector& src, GeoNotifierSet& dest)
	{
	for (GeoNotifier* notifier : src)
	dest.add(notifier);
	}

	void Geolocation::handleError(PositionError* error)
	{
	ASSERT(error);

	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.
	GeoNotifierVector oneShotsWithCachedPosition;
	m_oneShots.clear();
	if (error->isFatal())
	m_watchers.clear();
	else {
	// Don't send non-fatal errors to notifiers due to receive a cached position.
	extractNotifiersWithCachedPosition(oneShotsCopy, &oneShotsWithCachedPosition);
	extractNotifiersWithCachedPosition(watchersCopy, 0);
	}

	sendError(oneShotsCopy, error);
	sendError(watchersCopy, error);

	// hasListeners() doesn't distinguish between notifiers due to receive a
	// cached position and those requiring a fresh position. Perform the check
	// before restoring the notifiers below.
	if (!hasListeners())
	stopUpdating();

	// Maintain a reference to the cached notifiers until their timer fires.
	copyToSet(oneShotsWithCachedPosition, m_oneShots);
	}

	void Geolocation::requestPermission()
	{
	if (m_geolocationPermission != PermissionUnknown)
	return;

	LocalFrame* frame = this->frame();
	if (!frame)
	return;

	m_geolocationPermission = PermissionRequested;

	// Ask the embedder: it maintains the geolocation challenge policy itself.
	GeolocationController::from(frame)->requestPermission(this);
	}

	void Geolocation::makeSuccessCallbacks()
	{
	ASSERT(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());

	if (!hasListeners())
	stopUpdating();
	}

	void Geolocation::positionChanged()
	{
	ASSERT(isAllowed());

	// Stop all currently running timers.
	stopTimers();

	makeSuccessCallbacks();
	}

	void Geolocation::setError(GeolocationError* error)
	{
	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;
	}

	void Geolocation::stopUpdating()
	{
	LocalFrame* frame = this->frame();
	if (!frame)
	return;

	GeolocationController::from(frame)->removeObserver(this);
	}

	void Geolocation::handlePendingPermissionNotifiers()
	{
	// 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));
	}
	}
	}

	} // namespace blink