// ActiveScriptWrappable bool RTCDataChannel::hasPendingActivity() const { if (m_stopped) return false; // A RTCDataChannel object must not be garbage collected if its // * readyState is connecting and at least one event listener is registered // for open events, message events, error events, or close events. // * readyState is open and at least one event listener is registered for // message events, error events, or close events. // * readyState is closing and at least one event listener is registered for // error events, or close events. // * underlying data transport is established and data is queued to be // transmitted. bool hasValidListeners = false; switch (m_readyState) { case ReadyStateConnecting: hasValidListeners |= hasEventListeners(EventTypeNames::open); // fallthrough intended case ReadyStateOpen: hasValidListeners |= hasEventListeners(EventTypeNames::message); // fallthrough intended case ReadyStateClosing: hasValidListeners |= hasEventListeners(EventTypeNames::error) || hasEventListeners(EventTypeNames::close); break; default: break; } if (hasValidListeners) return true; return m_readyState != ReadyStateClosed && bufferedAmount() > 0; }
void XMLHttpRequest::callReadyStateChangeListener() { if (!scriptExecutionContext()) return; #if ENABLE(INSPECTOR) InspectorTimelineAgent* timelineAgent = InspectorTimelineAgent::retrieve(scriptExecutionContext()); bool callTimelineAgentOnReadyStateChange = timelineAgent && hasEventListeners(eventNames().readystatechangeEvent); if (callTimelineAgentOnReadyStateChange) timelineAgent->willChangeXHRReadyState(m_url.string(), m_state); #endif m_progressEventThrottle.dispatchEvent(XMLHttpRequestProgressEvent::create(eventNames().readystatechangeEvent), m_state == DONE ? FlushProgressEvent : DoNotFlushProgressEvent); #if ENABLE(INSPECTOR) if (callTimelineAgentOnReadyStateChange && (timelineAgent = InspectorTimelineAgent::retrieve(scriptExecutionContext()))) timelineAgent->didChangeXHRReadyState(); #endif if (m_state == DONE && !m_error) { #if ENABLE(INSPECTOR) timelineAgent = InspectorTimelineAgent::retrieve(scriptExecutionContext()); bool callTimelineAgentOnLoad = timelineAgent && hasEventListeners(eventNames().loadEvent); if (callTimelineAgentOnLoad) timelineAgent->willLoadXHR(m_url.string()); #endif m_progressEventThrottle.dispatchEvent(XMLHttpRequestProgressEvent::create(eventNames().loadEvent)); #if ENABLE(INSPECTOR) if (callTimelineAgentOnLoad && (timelineAgent = InspectorTimelineAgent::retrieve(scriptExecutionContext()))) timelineAgent->didLoadXHR(); #endif } }
bool IDBDatabase::hasPendingActivity() const { ASSERT(&originThread() == &Thread::current() || mayBeGCThread()); if (m_closedInServer || isContextStopped()) return false; if (!m_activeTransactions.isEmpty() || !m_committingTransactions.isEmpty() || !m_abortingTransactions.isEmpty()) return true; return hasEventListeners(m_eventNames.abortEvent) || hasEventListeners(m_eventNames.errorEvent) || hasEventListeners(m_eventNames.versionchangeEvent); }
bool IDBDatabase::hasPendingActivity() const { ASSERT(currentThread() == originThreadID()); if (m_closedInServer) return false; if (!m_activeTransactions.isEmpty() || !m_committingTransactions.isEmpty() || !m_abortingTransactions.isEmpty()) return true; return hasEventListeners(eventNames().abortEvent) || hasEventListeners(eventNames().errorEvent) || hasEventListeners(eventNames().versionchangeEvent); }
bool HTMLElement::supportsSpatialNavigationFocus() const { // This function checks whether the element satisfies the extended criteria // for the element to be focusable, introduced by spatial navigation feature, // i.e. checks if click or keyboard event handler is specified. // This is the way to make it possible to navigate to (focus) elements // which web designer meant for being active (made them respond to click events). if (!document().settings() || !document().settings()->spatialNavigationEnabled()) return false; return hasEventListeners(EventTypeNames::click) || hasEventListeners(EventTypeNames::keydown) || hasEventListeners(EventTypeNames::keypress) || hasEventListeners(EventTypeNames::keyup); }
ImageCapture::~ImageCapture() { DCHECK(!hasEventListeners()); // There should be no more outstanding |m_serviceRequests| at this point // since each of them holds a persistent handle to this object. DCHECK(m_serviceRequests.isEmpty()); }
bool AnimationPlayer::update(TimingUpdateReason reason) { if (!m_timeline) return false; updateCurrentTimingState(reason); m_outdated = false; if (m_content) { double inheritedTime = isNull(m_timeline->currentTimeInternal()) ? nullValue() : currentTimeInternal(); m_content->updateInheritedTime(inheritedTime, reason); } if (finished() && !m_finished) { if (reason == TimingUpdateForAnimationFrame && hasStartTime()) { const AtomicString& eventType = EventTypeNames::finish; if (executionContext() && hasEventListeners(eventType)) { m_pendingFinishedEvent = AnimationPlayerEvent::create(eventType, currentTime(), timeline()->currentTime()); m_pendingFinishedEvent->setTarget(this); m_pendingFinishedEvent->setCurrentTarget(this); m_timeline->document()->enqueueAnimationFrameEvent(m_pendingFinishedEvent); } m_finished = true; } } ASSERT(!m_outdated); return !m_finished || !finished(); }
bool AnimationPlayer::update(TimingUpdateReason reason) { if (!m_timeline) return false; PlayStateUpdateScope updateScope(*this, reason, DoNotSetCompositorPending); m_outdated = false; bool idle = playStateInternal() == Idle; if (m_content) { double inheritedTime = idle || isNull(m_timeline->currentTimeInternal()) ? nullValue() : currentTimeInternal(); // Special case for end-exclusivity when playing backwards. if (inheritedTime == 0 && m_playbackRate < 0) inheritedTime = -1; m_content->updateInheritedTime(inheritedTime, reason); } if ((idle || finished()) && !m_finished) { if (reason == TimingUpdateForAnimationFrame && (idle || hasStartTime())) { const AtomicString& eventType = EventTypeNames::finish; if (executionContext() && hasEventListeners(eventType)) { double eventCurrentTime = currentTimeInternal() * 1000; m_pendingFinishedEvent = AnimationPlayerEvent::create(eventType, eventCurrentTime, timeline()->currentTime()); m_pendingFinishedEvent->setTarget(this); m_pendingFinishedEvent->setCurrentTarget(this); m_timeline->document()->enqueueAnimationFrameEvent(m_pendingFinishedEvent); } m_finished = true; } } ASSERT(!m_outdated); return !m_finished; }
bool AudioScheduledSourceNode::removeEventListener(const AtomicString& eventType, EventListener* listener, bool useCapture) { bool success = AudioNode::removeEventListener(eventType, listener, useCapture); if (success && eventType == eventNames().endedEvent) m_hasEndedListener = hasEventListeners(eventNames().endedEvent); return success; }
bool ScriptProcessorNode::removeEventListener(const AtomicString& eventType, EventListener& listener, bool useCapture) { bool success = AudioNode::removeEventListener(eventType, listener, useCapture); if (success && eventType == eventNames().audioprocessEvent) m_hasAudioProcessListener = hasEventListeners(eventNames().audioprocessEvent); return success; }
void HTMLAnchorElement::parseAttribute(Attribute* attr) { if (attr->name() == hrefAttr) { bool wasLink = isLink(); setIsLink(!attr->isNull()); if (wasLink != isLink()) setNeedsStyleRecalc(); if (isLink()) { String parsedURL = stripLeadingAndTrailingHTMLSpaces(attr->value()); if (document()->isDNSPrefetchEnabled()) { if (protocolIs(parsedURL, "http") || protocolIs(parsedURL, "https") || parsedURL.startsWith("//")) prefetchDNS(document()->completeURL(parsedURL).host()); } if (document()->page() && !document()->page()->javaScriptURLsAreAllowed() && protocolIsJavaScript(parsedURL)) { clearIsLink(); // FIXME: This is horribly factored. if (Attribute* hrefAttribute = getAttributeItem(hrefAttr)) hrefAttribute->setValue(nullAtom); } #ifdef ARTEMIS else if(protocolIsJavaScript(parsedURL) && !hasEventListeners(eventNames().clickEvent)) { // Don't set the onclick event handler if it already has one. setAttributeEventListener(eventNames().clickEvent, createAttributeEventListener(this, attr)); } #endif } invalidateCachedVisitedLinkHash(); } else if (attr->name() == nameAttr || attr->name() == titleAttr) { // Do nothing. } else if (attr->name() == relAttr) setRel(attr->value()); else HTMLElement::parseAttribute(attr); }
bool AudioScheduledSourceNode::addEventListener(const AtomicString& eventType, RefPtr<EventListener>&& listener, bool useCapture) { bool success = AudioNode::addEventListener(eventType, WTFMove(listener), useCapture); if (success && eventType == eventNames().endedEvent) m_hasEndedListener = hasEventListeners(eventNames().endedEvent); return success; }
bool NetworkInformation::hasPendingActivity() const { ASSERT(m_contextStopped || m_observing == hasEventListeners()); // Prevent collection of this object when there are active listeners. return m_observing; }
bool ScriptProcessorNode::addEventListener(const AtomicString& eventType, Ref<EventListener>&& listener, bool useCapture) { bool success = AudioNode::addEventListener(eventType, WTFMove(listener), useCapture); if (success && eventType == eventNames().audioprocessEvent) m_hasAudioProcessListener = hasEventListeners(eventNames().audioprocessEvent); return success; }
bool NetworkInformation::removeEventListener(const AtomicString& eventType, EventListener* listener, bool useCapture) { if (!EventTargetWithInlineData::removeEventListener(eventType, listener, useCapture)) return false; if (!hasEventListeners()) stopObserving(); return true; }
void MediaDevices::removedEventListener( const AtomicString& eventType, const RegisteredEventListener& registeredListener) { EventTargetWithInlineData::removedEventListener(eventType, registeredListener); if (!hasEventListeners()) stopObserving(); }
bool PresentationRequest::hasPendingActivity() const { if (!getExecutionContext() || getExecutionContext()->activeDOMObjectsAreStopped()) return false; // Prevents garbage collecting of this object when not hold by another // object but still has listeners registered. return hasEventListeners(); }
bool ScriptProcessorNode::hasPendingActivity() const { // To prevent the node from leaking after the context is closed. if (context()->isContextClosed()) return false; // If |onaudioprocess| event handler is defined, the node should not be // GCed even if it is out of scope. if (hasEventListeners(EventTypeNames::audioprocess)) return true; return false; }
bool Animation::update(TimingUpdateReason reason) { if (!m_timeline) return false; PlayStateUpdateScope updateScope(*this, reason, DoNotSetCompositorPending); clearOutdated(); bool idle = playStateInternal() == Idle; if (m_content) { double inheritedTime = idle || isNull(m_timeline->currentTimeInternal()) ? nullValue() : currentTimeInternal(); if (!isNull(inheritedTime)) { double timeForClipping = m_held && (!limited(inheritedTime) || isNull(m_startTime)) // Use hold time when there is no start time. ? inheritedTime // Use calculated current time when the animation is limited. : calculateCurrentTime(); if (clipped(timeForClipping)) inheritedTime = nullValue(); } // Special case for end-exclusivity when playing backwards. if (inheritedTime == 0 && m_playbackRate < 0) inheritedTime = -1; m_content->updateInheritedTime(inheritedTime, reason); } if ((idle || limited()) && !m_finished) { if (reason == TimingUpdateForAnimationFrame && (idle || hasStartTime())) { if (idle) { // TODO(dstockwell): Fire the cancel event. } else { const AtomicString& eventType = EventTypeNames::finish; if (executionContext() && hasEventListeners(eventType)) { double eventCurrentTime = currentTimeInternal() * 1000; m_pendingFinishedEvent = AnimationPlayerEvent::create(eventType, eventCurrentTime, timeline()->currentTime()); m_pendingFinishedEvent->setTarget(this); m_pendingFinishedEvent->setCurrentTarget(this); m_timeline->document()->enqueueAnimationFrameEvent(m_pendingFinishedEvent); } } m_finished = true; } } ASSERT(!m_outdated); return !m_finished || std::isfinite(timeToEffectChange()); }
bool MediaStreamTrack::hasPendingActivity() const { // If 'ended' listeners exist and the object hasn't yet reached // that state, keep the object alive. // // An otherwise unreachable MediaStreamTrack object in an non-ended // state will otherwise indirectly be transitioned to the 'ended' state // while finalizing m_component. Which dispatches an 'ended' event, // referring to this object as the target. If this object is then GCed // at the same time, v8 objects will retain (wrapper) references to // this dead MediaStreamTrack object. Bad. // // Hence insisting on keeping this object alive until the 'ended' // state has been reached & handled. return !ended() && hasEventListeners(EventTypeNames::ended); }
bool BatteryManager::hasPendingActivity() const { // Prevent V8 from garbage collecting the wrapper object if there are // event listeners attached to it. return m_state == Resolved && hasEventListeners(); }
bool LegacyDatabase::hasPendingActivity() const { // The script wrapper must not be collected before the object is closed or // we can't fire a "versionchange" event to let script manually close the connection. return !m_closePending && hasEventListeners() && !m_contextStopped; }
bool MediaDevices::hasPendingActivity() const { DCHECK(m_stopped || m_observing == hasEventListeners()); return m_observing; }
void MediaDevices::removeAllEventListeners() { EventTargetWithInlineData::removeAllEventListeners(); DCHECK(!hasEventListeners()); stopObserving(); }
bool ImageCapture::hasPendingActivity() const { return hasEventListeners(); }
bool AnimationPlayer::hasPendingActivity() const { return m_pendingFinishedEvent || (!m_finished && hasEventListeners(EventTypeNames::finish)); }
void ImageCapture::contextDestroyed() { removeAllEventListeners(); m_serviceRequests.clear(); DCHECK(!hasEventListeners()); }
void NetworkInformation::removeAllEventListeners() { EventTargetWithInlineData::removeAllEventListeners(); ASSERT(!hasEventListeners()); stopObserving(); }
bool Sensor::hasPendingActivity() const { if (m_state == Sensor::SensorState::Idle || m_state == Sensor::SensorState::Errored) return false; return hasEventListeners(); }
bool Sensor::hasPendingActivity() const { if (m_state == Sensor::SensorState::IDLE || m_state == Sensor::SensorState::ERRORED) return false; return hasEventListeners(); }