PassRefPtrWillBeRawPtr<MouseEvent> MouseEvent::create(const AtomicString& eventType, PassRefPtrWillBeRawPtr<AbstractView> view, PassRefPtrWillBeRawPtr<Event> underlyingEvent, SimulatedClickCreationScope creationScope)
{
PlatformEvent::Modifiers modifiers = PlatformEvent::NoModifiers;
if (UIEventWithKeyState* keyStateEvent = findEventWithKeyState(underlyingEvent.get())) {
modifiers = keyStateEvent->modifiers();
}
PlatformMouseEvent::SyntheticEventType syntheticType = PlatformMouseEvent::Positionless;
int screenX = 0;
int screenY = 0;
if (underlyingEvent && underlyingEvent->isMouseEvent()) {
syntheticType = PlatformMouseEvent::RealOrIndistinguishable;
MouseEvent* mouseEvent = toMouseEvent(underlyingEvent.get());
screenX = mouseEvent->screenLocation().x();
screenY = mouseEvent->screenLocation().y();
}
double timestamp = underlyingEvent ? underlyingEvent->platformTimeStamp() : monotonicallyIncreasingTime();
RefPtrWillBeRawPtr<MouseEvent> createdEvent = MouseEvent::create(eventType, true, true, view,
0, screenX, screenY, 0, 0, 0, 0, modifiers, 0, 0, nullptr,
timestamp, syntheticType);
createdEvent->setTrusted(creationScope == SimulatedClickCreationScope::FromUserAgent);
createdEvent->setUnderlyingEvent(underlyingEvent);
if (syntheticType == PlatformMouseEvent::RealOrIndistinguishable) {
MouseEvent* mouseEvent = toMouseEvent(createdEvent->underlyingEvent());
createdEvent->initCoordinates(mouseEvent->clientLocation());
}
return createdEvent.release();
}
DispatchEventResult EventDispatcher::dispatchEvent(Node& node, PassRefPtrWillBeRawPtr<EventDispatchMediator> mediator)
{
TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("blink.debug"), "EventDispatcher::dispatchEvent");
ASSERT(!EventDispatchForbiddenScope::isEventDispatchForbidden());
EventDispatcher dispatcher(node, &mediator->event());
return mediator->dispatchEvent(dispatcher);
}
bool TextTrackCueList::add(PassRefPtrWillBeRawPtr<TextTrackCue> cue)
{
ASSERT(cue->startTime() >= 0);
ASSERT(cue->endTime() >= 0);
return add(cue, 0, m_list.size());
}
static void workerGlobalScopeDidConnect(ExecutionContext* context, PassRefPtrWillBeRawPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper, const String& subprotocol, const String& extensions)
{
ASSERT_UNUSED(context, context->isWorkerGlobalScope());
workerClientWrapper->setSubprotocol(subprotocol);
workerClientWrapper->setExtensions(extensions);
workerClientWrapper->didConnect();
}
static PassRefPtrWillBeRawPtr<Range> expandToParagraphBoundary(PassRefPtrWillBeRawPtr<Range> range)
{
RefPtrWillBeRawPtr<Range> paragraphRange = range->cloneRange();
setStart(paragraphRange.get(), startOfParagraph(VisiblePosition(range->startPosition())));
setEnd(paragraphRange.get(), endOfParagraph(VisiblePosition(range->endPosition())));
return paragraphRange;
}
static v8::Local<v8::Object> createInjectedScriptHostV8Wrapper(PassRefPtrWillBeRawPtr<InjectedScriptHost> host, InjectedScriptManager* injectedScriptManager, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
{
ASSERT(host);
v8::Handle<v8::Object> wrapper = V8DOMWrapper::createWrapper(creationContext, &V8InjectedScriptHost::wrapperTypeInfo, host->toScriptWrappableBase(), isolate);
if (UNLIKELY(wrapper.IsEmpty()))
return wrapper;
// Create a weak reference to the v8 wrapper of InspectorBackend to deref
// InspectorBackend when the wrapper is garbage collected.
InjectedScriptManager::CallbackData* callbackData = injectedScriptManager->createCallbackData(injectedScriptManager);
#if ENABLE(OILPAN)
callbackData->hostPtr = WrapperPersistent<InjectedScriptHost>::create(host.get());
#else
callbackData->host = host.get();
#endif
callbackData->handle.set(isolate, wrapper);
callbackData->handle.setWeak(callbackData, &InjectedScriptManager::setWeakCallback);
#if ENABLE(OILPAN)
V8DOMWrapper::setNativeInfoWithPersistentHandle(wrapper, &V8InjectedScriptHost::wrapperTypeInfo, host->toScriptWrappableBase(), callbackData->hostPtr);
#else
V8DOMWrapper::setNativeInfo(wrapper, &V8InjectedScriptHost::wrapperTypeInfo, host->toScriptWrappableBase());
#endif
ASSERT(V8DOMWrapper::isDOMWrapper(wrapper));
return wrapper;
}
static bool cueIsBefore(const TextTrackCue* cue, PassRefPtrWillBeRawPtr<TextTrackCue> otherCue)
{
if (cue->startTime() < otherCue->startTime())
return true;
return cue->startTime() == otherCue->startTime() && cue->endTime() > otherCue->endTime();
}
CSSCalcBinaryOperation(PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> leftSide, PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> rightSide, CalcOperator op, CalculationCategory category)
: CSSCalcExpressionNode(category, isIntegerResult(leftSide.get(), rightSide.get(), op))
, m_leftSide(leftSide)
, m_rightSide(rightSide)
, m_operator(op)
{
}
void FontFace::initCSSFontFace(Document* document, PassRefPtrWillBeRawPtr<CSSValue> src)
{
m_cssFontFace = createCSSFontFace(this, m_unicodeRange.get());
if (m_error)
return;
// Each item in the src property's list is a single CSSFontFaceSource. Put them all into a CSSFontFace.
ASSERT(src);
ASSERT(src->isValueList());
CSSValueList* srcList = toCSSValueList(src.get());
int srcLength = srcList->length();
for (int i = 0; i < srcLength; i++) {
// An item in the list either specifies a string (local font name) or a URL (remote font to download).
CSSFontFaceSrcValue* item = toCSSFontFaceSrcValue(srcList->item(i));
OwnPtrWillBeRawPtr<CSSFontFaceSource> source = nullptr;
if (!item->isLocal()) {
const Settings* settings = document ? document->settings() : nullptr;
bool allowDownloading = settings && settings->downloadableBinaryFontsEnabled();
if (allowDownloading && item->isSupportedFormat() && document) {
FontResource* fetched = item->fetch(document);
if (fetched) {
FontLoader* fontLoader = document->styleEngine().fontSelector()->fontLoader();
source = adoptPtrWillBeNoop(new RemoteFontFaceSource(fetched, fontLoader));
}
}
} else {
source = adoptPtrWillBeNoop(new LocalFontFaceSource(item->resource()));
}
if (source)
m_cssFontFace->addSource(source.release());
}
}
static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> buildSerializablePositionOffset(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> offset, CSSValueID defaultSide)
{
CSSValueID side = defaultSide;
RefPtrWillBeRawPtr<CSSPrimitiveValue> amount = nullptr;
if (!offset) {
side = CSSValueCenter;
} else if (offset->isValueID()) {
side = offset->getValueID();
} else if (Pair* pair = offset->getPairValue()) {
side = pair->first()->getValueID();
amount = pair->second();
} else {
amount = offset;
}
if (side == CSSValueCenter) {
side = defaultSide;
amount = cssValuePool().createValue(50, CSSPrimitiveValue::CSS_PERCENTAGE);
} else if ((side == CSSValueRight || side == CSSValueBottom)
&& amount->isPercentage()) {
side = defaultSide;
amount = cssValuePool().createValue(100 - amount->getFloatValue(), CSSPrimitiveValue::CSS_PERCENTAGE);
} else if (amount->isLength() && !amount->getFloatValue()) {
if (side == CSSValueRight || side == CSSValueBottom)
amount = cssValuePool().createValue(100, CSSPrimitiveValue::CSS_PERCENTAGE);
else
amount = cssValuePool().createValue(0, CSSPrimitiveValue::CSS_PERCENTAGE);
side = defaultSide;
}
return cssValuePool().createValue(Pair::create(cssValuePool().createValue(side), amount.release(), Pair::KeepIdenticalValues));
}
void HTMLElementStack::pushHTMLBodyElement(PassRefPtrWillBeRawPtr<HTMLStackItem> item)
{
ASSERT(item->hasTagName(HTMLNames::bodyTag));
ASSERT(!m_bodyElement);
m_bodyElement = item->element();
pushCommon(item);
}
void SpellCheckRequester::enqueueRequest(PassRefPtrWillBeRawPtr<SpellCheckRequest> request)
{
ASSERT(request);
bool continuation = false;
if (!m_requestQueue.isEmpty()) {
RefPtrWillBeRawPtr<SpellCheckRequest> lastRequest = m_requestQueue.last();
// It's a continuation if the number of the last request got incremented in the new one and
// both apply to the same editable.
continuation = request->rootEditableElement() == lastRequest->rootEditableElement()
&& request->requestNumber() == lastRequest->requestNumber() + 1;
}
// Spellcheck requests for chunks of text in the same element should not overwrite each other.
if (!continuation) {
for (auto& requestQueue : m_requestQueue) {
if (request->rootEditableElement() != requestQueue->rootEditableElement())
continue;
requestQueue = request;
return;
}
}
m_requestQueue.append(request);
}
void HTMLElementStack::insertAbove(PassRefPtrWillBeRawPtr<HTMLStackItem> item, ElementRecord* recordBelow)
{
ASSERT(item);
ASSERT(recordBelow);
ASSERT(m_top);
ASSERT(!item->hasTagName(htmlTag));
ASSERT(!item->hasTagName(headTag));
ASSERT(!item->hasTagName(bodyTag));
ASSERT(m_rootNode);
if (recordBelow == m_top) {
push(item);
return;
}
for (ElementRecord* recordAbove = m_top.get(); recordAbove; recordAbove = recordAbove->next()) {
if (recordAbove->next() != recordBelow)
continue;
m_stackDepth++;
recordAbove->setNext(adoptPtrWillBeNoop(new ElementRecord(item, recordAbove->releaseNext())));
recordAbove->next()->element()->beginParsingChildren();
return;
}
ASSERT_NOT_REACHED();
}
v8::Handle<v8::Object> CustomElementWrapper<ElementType, WrapperType>::wrap(PassRefPtrWillBeRawPtr<ElementType> element, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate, v8::Handle<v8::Object> (*createSpecificWrapper)(ElementType* element, v8::Handle<v8::Object> creationContext, v8::Isolate*))
{
ASSERT(DOMDataStore::getWrapper<V8Element>(element.get(), isolate).IsEmpty());
// FIXME: creationContext.IsEmpty() should never happen. Remove
// this when callers (like InspectorController::inspect) are fixed
// to never pass an empty creation context.
v8::Handle<v8::Context> context = creationContext.IsEmpty() ? isolate->GetCurrentContext() : creationContext->CreationContext();
if (!element->isUpgradedCustomElement() || DOMWrapperWorld::world(context).isIsolatedWorld())
return createUpgradeCandidateWrapper(element.get(), creationContext, isolate, createSpecificWrapper);
V8PerContextData* perContextData = V8PerContextData::from(context);
if (!perContextData)
return v8::Handle<v8::Object>();
CustomElementBinding* binding = perContextData->customElementBinding(element->customElementDefinition());
v8::Handle<v8::Object> wrapper = V8DOMWrapper::createWrapper(creationContext, binding->wrapperType(), element.get(), isolate);
if (wrapper.IsEmpty())
return v8::Handle<v8::Object>();
wrapper->SetPrototype(binding->prototype());
V8DOMWrapper::associateObjectWithWrapper<WrapperType>(element, binding->wrapperType(), wrapper, isolate, WrapperConfiguration::Dependent);
return wrapper;
}
void FontFace::initCSSFontFace(Document* document, PassRefPtrWillBeRawPtr<CSSValue> src)
{
m_cssFontFace = createCSSFontFace(this, m_unicodeRange.get());
if (m_error)
return;
// Each item in the src property's list is a single CSSFontFaceSource. Put them all into a CSSFontFace.
ASSERT(src);
ASSERT(src->isValueList());
CSSValueList* srcList = toCSSValueList(src.get());
int srcLength = srcList->length();
bool foundSVGFont = false;
for (int i = 0; i < srcLength; i++) {
// An item in the list either specifies a string (local font name) or a URL (remote font to download).
CSSFontFaceSrcValue* item = toCSSFontFaceSrcValue(srcList->item(i));
OwnPtrWillBeRawPtr<CSSFontFaceSource> source = nullptr;
#if ENABLE(SVG_FONTS)
foundSVGFont = item->isSVGFontFaceSrc() || item->svgFontFaceElement();
#endif
if (!item->isLocal()) {
Settings* settings = document ? document->frame() ? document->frame()->settings() : 0 : 0;
bool allowDownloading = foundSVGFont || (settings && settings->downloadableBinaryFontsEnabled());
if (allowDownloading && item->isSupportedFormat() && document) {
FontResource* fetched = item->fetch(document);
if (fetched) {
FontLoader* fontLoader = document->styleEngine()->fontSelector()->fontLoader();
#if ENABLE(SVG_FONTS)
if (foundSVGFont) {
source = adoptPtrWillBeNoop(new SVGRemoteFontFaceSource(item->resource(), fetched, fontLoader));
} else
#endif
{
source = adoptPtrWillBeNoop(new RemoteFontFaceSource(fetched, fontLoader));
}
}
}
} else {
#if ENABLE(SVG_FONTS)
if (item->svgFontFaceElement()) {
RefPtrWillBeRawPtr<SVGFontFaceElement> fontfaceElement = item->svgFontFaceElement();
// SVGFontFaceSource assumes that it is the case where <font-face> element resides in the same document.
// We put a RELEASE_ASSERT here as it will cause UAF if the assumption is false.
RELEASE_ASSERT(fontfaceElement->inDocument());
RELEASE_ASSERT(fontfaceElement->document() == document);
source = adoptPtrWillBeNoop(new SVGFontFaceSource(fontfaceElement.get()));
} else
#endif
{
source = adoptPtrWillBeNoop(new LocalFontFaceSource(item->resource()));
}
}
if (source)
m_cssFontFace->addSource(source.release());
}
}
v8::Handle<v8::Object> V8TestInterfaceDocument::createWrapper(PassRefPtrWillBeRawPtr<TestInterfaceDocument> impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
{
ASSERT(impl);
ASSERT(!DOMDataStore::containsWrapper<V8TestInterfaceDocument>(impl.get(), isolate));
if (ScriptWrappable::wrapperCanBeStoredInObject(impl.get())) {
const WrapperTypeInfo* actualInfo = ScriptWrappable::fromObject(impl.get())->typeInfo();
// Might be a XXXConstructor::wrapperTypeInfo instead of an XXX::wrapperTypeInfo. These will both have
// the same object de-ref functions, though, so use that as the basis of the check.
RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(actualInfo->derefObjectFunction == wrapperTypeInfo.derefObjectFunction);
}
if (LocalFrame* frame = impl->frame()) {
if (frame->script().initializeMainWorld()) {
// initializeMainWorld may have created a wrapper for the object, retry from the start.
v8::Handle<v8::Object> wrapper = DOMDataStore::getWrapper<V8TestInterfaceDocument>(impl.get(), isolate);
if (!wrapper.IsEmpty())
return wrapper;
}
}
v8::Handle<v8::Object> wrapper = V8DOMWrapper::createWrapper(creationContext, &wrapperTypeInfo, toInternalPointer(impl.get()), isolate);
if (UNLIKELY(wrapper.IsEmpty()))
return wrapper;
installPerContextEnabledProperties(wrapper, impl.get(), isolate);
V8DOMWrapper::associateObjectWithWrapper<V8TestInterfaceDocument>(impl, &wrapperTypeInfo, wrapper, isolate, WrapperConfiguration::Dependent);
return wrapper;
}
TextCheckingParagraph::TextCheckingParagraph(PassRefPtrWillBeRawPtr<Range> checkingRange, PassRefPtrWillBeRawPtr<Range> paragraphRange)
: m_checkingRange(checkingRange.get())
, m_paragraphRange(paragraphRange.get())
, m_checkingStart(-1)
, m_checkingEnd(-1)
, m_checkingLength(-1)
{
}
void HTMLElementStack::push(PassRefPtrWillBeRawPtr<HTMLStackItem> item)
{
ASSERT(!item->hasTagName(htmlTag));
ASSERT(!item->hasTagName(headTag));
ASSERT(!item->hasTagName(bodyTag));
ASSERT(m_rootNode);
pushCommon(item);
}
void ProcessingInstruction::setCSSStyleSheet(PassRefPtrWillBeRawPtr<CSSStyleSheet> sheet)
{
ASSERT(!resource());
ASSERT(!m_loading);
m_sheet = sheet;
sheet->setTitle(m_title);
sheet->setDisabled(m_alternate);
}
void SpellCheckerClientImpl::requestCheckingOfString(PassRefPtrWillBeRawPtr<TextCheckingRequest> request)
{
if (m_webView->spellCheckClient()) {
const String& text = request->data().text();
const Vector<uint32_t>& markers = request->data().markers();
const Vector<unsigned>& markerOffsets = request->data().offsets();
m_webView->spellCheckClient()->requestCheckingOfText(text, markers, markerOffsets, new WebTextCheckingCompletionImpl(request));
}
}
void IDBDatabase::enqueueEvent(PassRefPtrWillBeRawPtr<Event> event)
{
ASSERT(!m_contextStopped);
ASSERT(executionContext());
EventQueue* eventQueue = executionContext()->eventQueue();
event->setTarget(this);
eventQueue->enqueueEvent(event.get());
m_enqueuedEvents.append(event);
}
void WorkerConsole::reportMessageToConsole(PassRefPtrWillBeRawPtr<ConsoleMessage> consoleMessage)
{
if (RefPtrWillBeRawPtr<ScriptCallStack> callStack = consoleMessage->callStack()) {
const ScriptCallFrame& lastCaller = callStack->at(0);
consoleMessage->setURL(lastCaller.sourceURL());
consoleMessage->setLineNumber(lastCaller.lineNumber());
}
m_scope->addConsoleMessage(consoleMessage);
}
bool EventTarget::dispatchEventInternal(PassRefPtrWillBeRawPtr<Event> event)
{
event->setTarget(this);
event->setCurrentTarget(this);
event->setEventPhase(Event::AT_TARGET);
bool defaultWasNotPrevented = fireEventListeners(event.get());
event->setEventPhase(0);
return defaultWasNotPrevented;
}
bool ServiceWorkerGlobalScope::dispatchEventInternal(PassRefPtrWillBeRawPtr<Event> event)
{
m_eventNestingLevel++;
bool result = WorkerGlobalScope::dispatchEventInternal(event.get());
if (event->interfaceName() == EventNames::ErrorEvent && m_eventNestingLevel == 2)
m_hadErrorInTopLevelEventHandler = true;
m_eventNestingLevel--;
return result;
}
void CueTimeline::addCueInternal(PassRefPtrWillBeRawPtr<TextTrackCue> cue)
{
// Negative duration cues need be treated in the interval tree as
// zero-length cues.
double endTime = std::max(cue->startTime(), cue->endTime());
CueInterval interval = m_cueTree.createInterval(cue->startTime(), endTime, cue.get());
if (!m_cueTree.contains(interval))
m_cueTree.add(interval);
}
static PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> create(PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> leftSide, PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> rightSide, CalcOperator op)
{
ASSERT(leftSide->category() != CalcOther && rightSide->category() != CalcOther);
CalculationCategory newCategory = determineCategory(*leftSide, *rightSide, op);
if (newCategory == CalcOther)
return nullptr;
return adoptRefWillBeNoop(new CSSCalcBinaryOperation(leftSide, rightSide, op, newCategory));
}
void FontFace::loadWithCallback(PassRefPtrWillBeRawPtr<LoadFontCallback> callback, ExecutionContext* context)
{
loadInternal(context);
if (m_status == Loaded)
callback->notifyLoaded(this);
else if (m_status == Error)
callback->notifyError(this);
else
m_callbacks.append(callback);
}
PassRefPtrWillBeRawPtr<AnimationEffect> makeAnimationEffect(CSSPropertyID id, PassRefPtrWillBeRawPtr<AnimatableValue> value)
{
AnimatableValueKeyframeVector keyframes(2);
keyframes[0] = AnimatableValueKeyframe::create();
keyframes[0]->setOffset(0.0);
keyframes[0]->setPropertyValue(id, value.get());
keyframes[1] = AnimatableValueKeyframe::create();
keyframes[1]->setOffset(1.0);
keyframes[1]->setPropertyValue(id, value.get());
return AnimatableValueKeyframeEffectModel::create(keyframes);
}
void CustomElementScheduler::resolveOrScheduleResolution(PassRefPtrWillBeRawPtr<CustomElementRegistrationContext> context, PassRefPtrWillBeRawPtr<Element> element, const CustomElementDescriptor& descriptor)
{
if (CustomElementCallbackDispatcher::inCallbackDeliveryScope()) {
context->resolve(element.get(), descriptor);
return;
}
HTMLImportLoader* loader = element->document().importLoader();
OwnPtrWillBeRawPtr<CustomElementMicrotaskResolutionStep> step = CustomElementMicrotaskResolutionStep::create(context, element, descriptor);
CustomElementMicrotaskDispatcher::instance().enqueue(loader, step.release());
}
void CustomElementScheduler::resolveOrScheduleResolution(PassRefPtrWillBeRawPtr<CustomElementRegistrationContext> context, PassRefPtrWillBeRawPtr<Element> element, const CustomElementDescriptor& descriptor)
{
if (CustomElementProcessingStack::inCallbackDeliveryScope()) {
context->resolve(element.get(), descriptor);
return;
}
Document& document = element->document();
OwnPtrWillBeRawPtr<CustomElementMicrotaskResolutionStep> step = CustomElementMicrotaskResolutionStep::create(context, element, descriptor);
enqueueMicrotaskStep(document, step.release());
}