void JavaScriptDebugServer::addListener(JavaScriptDebugListener* listener)
{
if (!hasListeners())
Page::setDebuggerForAllPages(this);
m_listeners.add(listener);
}
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.
GeoNotifierSet::const_iterator end = m_requestsAwaitingCachedPosition.end();
for (GeoNotifierSet::const_iterator iter = m_requestsAwaitingCachedPosition.begin(); iter != end; ++iter) {
GeoNotifier* notifier = iter->get();
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->hasZeroTimeout() || startUpdating(notifier))
notifier->startTimerIfNeeded();
else
notifier->setFatalError(PositionError::create(PositionError::POSITION_UNAVAILABLE, failedToStartServiceErrorMessage));
}
}
m_requestsAwaitingCachedPosition.clear();
if (!hasListeners())
stopUpdating();
}
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::clearWatch(int watchId)
{
m_watchers.remove(watchId);
if (!hasListeners())
stopUpdating();
}
void Geolocation::resume()
{
#if !ENABLE(CLIENT_BASED_GEOLOCATION)
if (hasListeners())
m_service->resume();
#endif
}
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 (auto& notifier : m_requestsAwaitingCachedPosition) {
// FIXME: This seems wrong, since makeCachedPositionCallbacks() is called in a branch where
// lastPosition() is known to be null in Geolocation::setIsAllowed().
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.remove(notifier.get()) && m_watchers.contains(notifier.get())) {
if (notifier->hasZeroTimeout() || startUpdating(notifier.get()))
notifier->startTimerIfNeeded();
else
notifier->setFatalError(PositionError::create(PositionError::POSITION_UNAVAILABLE, failedToStartServiceErrorMessage));
}
}
m_requestsAwaitingCachedPosition.clear();
if (!hasListeners())
stopUpdating();
}
void Geolocation::handleError(PositionError& error)
{
auto oneShotsCopy = copyToVector(m_oneShots);
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::requestTimedOut(GeoNotifier* notifier) {
// If this is a one-shot request, stop it.
m_oneShots.remove(notifier);
if (!hasListeners())
stopUpdating();
}
void JavaScriptDebugServer::pageCreated(Page* page)
{
if (!hasListeners())
return;
page->setDebugger(this);
}
void JavaScriptDebugServer::sourceParsed(ExecState* exec, int sourceID, const UString& sourceURL, const SourceProvider& source, int startingLineNumber, int errorLine, const UString& errorMessage)
{
if (m_callingListeners)
return;
Page* page = toPage(exec->dynamicGlobalObject());
if (!page)
return;
m_callingListeners = true;
ASSERT(hasListeners());
bool isError = errorLine != -1;
if (!m_listeners.isEmpty()) {
if (isError)
dispatchFailedToParseSource(m_listeners, exec, source, startingLineNumber, sourceURL, errorLine, errorMessage);
else
dispatchDidParseSource(m_listeners, exec, source, startingLineNumber, sourceURL, sourceID);
}
if (ListenerSet* pageListeners = m_pageListenersMap.get(page)) {
ASSERT(!pageListeners->isEmpty());
if (isError)
dispatchFailedToParseSource(*pageListeners, exec, source, startingLineNumber, sourceURL, errorLine, errorMessage);
else
dispatchDidParseSource(*pageListeners, exec, source, startingLineNumber, sourceURL, sourceID);
}
m_callingListeners = false;
}
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 JavaScriptDebugServer::removeListener(JavaScriptDebugListener* listener)
{
m_listeners.remove(listener);
if (!hasListeners()) {
Page::setDebuggerForAllPages(0);
m_doneProcessingDebuggerEvents = true;
}
}
void Geolocation::resumeTimerFired()
{
m_isSuspended = false;
if (m_resetOnResume) {
resetAllGeolocationPermission();
m_resetOnResume = false;
}
// Resume GeoNotifier timeout timers.
if (hasListeners()) {
for (auto& notifier : m_oneShots)
notifier->startTimerIfNeeded();
GeoNotifierVector watcherCopy;
m_watchers.getNotifiersVector(watcherCopy);
for (auto& watcher : watcherCopy)
watcher->startTimerIfNeeded();
}
if ((isAllowed() || isDenied()) && !m_pendingForPermissionNotifiers.isEmpty()) {
// The pending permission was granted while the object was suspended.
setIsAllowed(isAllowed());
ASSERT(!m_hasChangedPosition);
ASSERT(!m_errorWaitingForResume);
return;
}
if (isDenied() && hasListeners()) {
// The permission was revoked while the object was suspended.
setIsAllowed(false);
return;
}
if (m_hasChangedPosition) {
positionChanged();
m_hasChangedPosition = false;
}
if (m_errorWaitingForResume) {
handleError(*m_errorWaitingForResume);
m_errorWaitingForResume = nullptr;
}
}
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::clearWatch(int watchId)
{
if (watchId < firstAvailableWatchId)
return;
#if USE(PREEMPT_GEOLOCATION_PERMISSION)
if (GeoNotifier* notifier = m_watchers.find(watchId))
m_pendingForPermissionNotifiers.remove(notifier);
#endif
m_watchers.remove(watchId);
if (!hasListeners())
stopUpdating();
}
void JavaScriptDebugServer::addListener(JavaScriptDebugListener* listener, Page* page)
{
ASSERT_ARG(page, page);
if (!hasListeners())
Page::setDebuggerForAllPages(this);
pair<PageListenersMap::iterator, bool> result = m_pageListenersMap.add(page, 0);
if (result.second)
result.first->second = new ListenerSet;
ListenerSet* listeners = result.first->second;
listeners->add(listener);
}
void Geolocation::suspend(ReasonForSuspension reason)
{
if (reason == ReasonForSuspension::PageCache) {
stop();
m_resetOnResume = true;
}
// Suspend GeoNotifier timeout timers.
if (hasListeners())
stopTimers();
m_isSuspended = true;
m_resumeTimer.stop();
ActiveDOMObject::suspend(reason);
}
void JavaScriptDebugServer::dispatchFunctionToListeners(JavaScriptExecutionCallback callback, Page* page)
{
if (m_callingListeners)
return;
m_callingListeners = true;
ASSERT(hasListeners());
WebCore::dispatchFunctionToListeners(m_listeners, callback);
if (ListenerSet* pageListeners = m_pageListenersMap.get(page)) {
ASSERT(!pageListeners->isEmpty());
WebCore::dispatchFunctionToListeners(*pageListeners, callback);
}
m_callingListeners = false;
}
void Geolocation::requestUsesCachedPosition(GeoNotifier* notifier) {
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();
}
if (!hasListeners())
stopUpdating();
}
void Geolocation::makeSuccessCallbacks(Geoposition& position)
{
ASSERT(lastPosition());
ASSERT(isAllowed());
auto oneShotsCopy = copyToVector(m_oneShots);
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();
sendPosition(oneShotsCopy, position);
sendPosition(watchersCopy, position);
if (!hasListeners())
stopUpdating();
}
void JavaScriptDebugServer::removeListener(JavaScriptDebugListener* listener, Page* page)
{
ASSERT_ARG(page, page);
PageListenersMap::iterator it = m_pageListenersMap.find(page);
if (it == m_pageListenersMap.end())
return;
ListenerSet* listeners = it->second;
listeners->remove(listener);
if (listeners->isEmpty()) {
m_pageListenersMap.remove(it);
delete listeners;
}
if (!hasListeners()) {
Page::setDebuggerForAllPages(0);
m_doneProcessingDebuggerEvents = true;
}
}
void Geolocation::handleError(PositionError* error)
{
ASSERT(error);
Vector<RefPtr<GeoNotifier> > oneShotsCopy;
copyToVector(m_oneShots, oneShotsCopy);
Vector<RefPtr<GeoNotifier> > 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();
if (error->isFatal())
m_watchers.clear();
sendError(oneShotsCopy, error);
sendError(watchersCopy, error);
if (!hasListeners())
stopUpdating();
}