bool SizesCalcParser::calculate() {
Vector<SizesCalcValue> stack;
for (const auto& value : m_valueList) {
if (value.operation == 0) {
stack.append(value);
} else {
if (!operateOnStack(stack, value.operation))
return false;
}
}
if (stack.size() == 1 && stack.last().isLength) {
m_result = std::max(clampTo<float>(stack.last().value), (float)0.0);
return true;
}
return false;
}
void JSString::Rope::destructNonRecursive()
{
Vector<Rope*, 32> workQueue;
Rope* rope = this;
while (true) {
unsigned length = rope->ropeLength();
for (unsigned i = 0; i < length; ++i) {
Fiber& fiber = rope->fibers(i);
if (fiber.isString())
fiber.string()->deref();
else {
Rope* nextRope = fiber.rope();
if (nextRope->hasOneRef())
workQueue.append(nextRope);
else
nextRope->deref();
}
}
if (rope != this)
fastFree(rope);
if (workQueue.isEmpty())
return;
rope = workQueue.last();
workQueue.removeLast();
}
}
static bool parseKeyTimes(const String& string, Vector<float>& result, bool verifyOrder)
{
result.clear();
Vector<String> parseList;
string.split(';', true, parseList);
for (unsigned n = 0; n < parseList.size(); ++n) {
String timeString = parseList[n].stripWhiteSpace();
bool ok;
float time = timeString.toFloat(&ok);
if (!ok || time < 0 || time > 1)
goto fail;
if (verifyOrder) {
if (!n) {
if (time)
goto fail;
} else if (time < result.last()) {
goto fail;
}
}
result.append(time);
}
return true;
fail:
result.clear();
return false;
}
void EventRetargeter::calculateEventPath(Node* targetNode, Event* event, EventPath& eventPath)
{
bool inDocument = targetNode->inDocument();
bool isSVGElement = targetNode->isSVGElement();
bool isMouseOrFocusEvent = event->isMouseEvent() || event->isFocusEvent();
#if ENABLE(TOUCH_EVENTS)
bool isTouchEvent = event->isTouchEvent();
#endif
Vector<EventTarget*, 32> targetStack;
for (Node* node = nodeOrHostIfPseudoElement(targetNode); node; node = node->parentOrShadowHostNode()) {
if (targetStack.isEmpty())
targetStack.append(eventTargetRespectingTargetRules(node));
if (isMouseOrFocusEvent)
eventPath.append(adoptPtr(new MouseOrFocusEventContext(node, eventTargetRespectingTargetRules(node), targetStack.last())));
#if ENABLE(TOUCH_EVENTS)
else if (isTouchEvent)
eventPath.append(adoptPtr(new TouchEventContext(node, eventTargetRespectingTargetRules(node), targetStack.last())));
#endif
else
eventPath.append(adoptPtr(new EventContext(node, eventTargetRespectingTargetRules(node), targetStack.last())));
if (!inDocument)
return;
if (!node->isShadowRoot())
continue;
if (determineDispatchBehavior(event, toShadowRoot(node), targetStack.last()) == StayInsideShadowDOM)
return;
if (!isSVGElement) {
ASSERT(!targetStack.isEmpty());
targetStack.removeLast();
}
}
}
static float curveLength(PathTraversalState& traversalState, CurveType curve)
{
Vector<CurveType> curveStack;
curveStack.append(curve);
float totalLength = 0.0f;
do {
float length = curve.approximateDistance();
if ((length - distanceLine(curve.start, curve.end)) > kPathSegmentLengthTolerance) {
CurveType left, right;
curve.split(left, right);
curve = left;
curveStack.append(right);
} else {
totalLength += length;
if (traversalState.m_action == PathTraversalState::TraversalPointAtLength
|| traversalState.m_action == PathTraversalState::TraversalNormalAngleAtLength) {
traversalState.m_previous = curve.start;
traversalState.m_current = curve.end;
if (traversalState.m_totalLength + totalLength > traversalState.m_desiredLength)
return totalLength;
}
curve = curveStack.last();
curveStack.removeLast();
}
} while (!curveStack.isEmpty());
return totalLength;
}
PassRefPtr<BitmapTexture> BitmapTexturePool::acquireTexture(const IntSize& size, TextureMapper* textureMapper)
{
BitmapTexturePoolEntry* selectedEntry = 0;
for (size_t i = 0; i < m_textures.size(); ++i) {
BitmapTexturePoolEntry* entry = &m_textures[i];
// If the surface has only one reference (the one in m_textures), we can safely reuse it.
if (entry->m_texture->refCount() > 1)
continue;
if (entry->m_texture->canReuseWith(size)) {
selectedEntry = entry;
break;
}
}
if (!selectedEntry) {
m_textures.append(BitmapTexturePoolEntry(textureMapper->createTexture()));
selectedEntry = &m_textures.last();
}
scheduleReleaseUnusedTextures();
selectedEntry->markUsed();
return selectedEntry->m_texture;
}
// Overview: These functions convert a JSString from holding a string in rope form
// down to a simple String representation. It does so by building up the string
// backwards, since we want to avoid recursion, we expect that the tree structure
// representing the rope is likely imbalanced with more nodes down the left side
// (since appending to the string is likely more common) - and as such resolving
// in this fashion should minimize work queue size. (If we built the queue forwards
// we would likely have to place all of the constituent StringImpls into the
// Vector before performing any concatenation, but by working backwards we likely
// only fill the queue with the number of substrings at any given level in a
// rope-of-ropes.)
void JSRopeString::resolveRopeSlowCase8(LChar* buffer) const
{
LChar* position = buffer + m_length; // We will be working backwards over the rope.
Vector<JSString*, 32, UnsafeVectorOverflow> workQueue; // Putting strings into a Vector is only OK because there are no GC points in this method.
for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i) {
workQueue.append(m_fibers[i].get());
// Clearing here works only because there are no GC points in this method.
m_fibers[i].clear();
}
while (!workQueue.isEmpty()) {
JSString* currentFiber = workQueue.last();
workQueue.removeLast();
if (currentFiber->isRope()) {
JSRopeString* currentFiberAsRope = static_cast<JSRopeString*>(currentFiber);
for (size_t i = 0; i < s_maxInternalRopeLength && currentFiberAsRope->m_fibers[i]; ++i)
workQueue.append(currentFiberAsRope->m_fibers[i].get());
continue;
}
StringImpl* string = static_cast<StringImpl*>(currentFiber->m_value.impl());
unsigned length = string->length();
position -= length;
StringImpl::copyChars(position, string->characters8(), length);
}
ASSERT(buffer == position);
ASSERT(!isRope());
}
bool injectIDBKeyIntoScriptValue(DOMRequestState* requestState, PassRefPtr<IDBKey> key, Deprecated::ScriptValue& value, const IDBKeyPath& keyPath)
{
LOG(StorageAPI, "injectIDBKeyIntoScriptValue");
ASSERT(keyPath.type() == IndexedDB::KeyPathType::String);
Vector<String> keyPathElements;
IDBKeyPathParseError error;
IDBParseKeyPath(keyPath.string(), keyPathElements, error);
ASSERT(error == IDBKeyPathParseError::None);
if (keyPathElements.isEmpty())
return false;
ExecState* exec = requestState->exec();
JSValue parent = ensureNthValueOnKeyPath(exec, value.jsValue(), keyPathElements, keyPathElements.size() - 1);
if (parent.isUndefined())
return false;
if (!set(exec, parent, keyPathElements.last(), idbKeyToJSValue(exec, exec->lexicalGlobalObject(), key.get())))
return false;
return true;
}
TEST(WTF_Vector, MoveOnly_Append)
{
Vector<MoveOnly> vector;
for (size_t i = 0; i < 100; ++i) {
MoveOnly moveOnly(i);
vector.append(std::move(moveOnly));
EXPECT_EQ(moveOnly.value(), 0U);
}
for (size_t i = 0; i < 100; ++i)
EXPECT_EQ(vector[i].value(), i);
for (size_t i = 0; i < 16; ++i) {
Vector<MoveOnly> vector;
vector.append(i);
for (size_t j = 0; j < i; ++j)
vector.append(j);
vector.append(std::move(vector[0]));
EXPECT_EQ(vector[0].value(), 0U);
for (size_t j = 0; j < i; ++j)
EXPECT_EQ(vector[j + 1].value(), j);
EXPECT_EQ(vector.last().value(), i);
}
}
bool injectIDBKeyIntoScriptValue(JSC::ExecState& exec, const IDBKeyData& keyData, JSC::JSValue value, const IDBKeyPath& keyPath)
{
LOG(IndexedDB, "injectIDBKeyIntoScriptValue");
ASSERT(keyPath.type() == IndexedDB::KeyPathType::String);
Vector<String> keyPathElements;
IDBKeyPathParseError error;
IDBParseKeyPath(keyPath.string(), keyPathElements, error);
ASSERT(error == IDBKeyPathParseError::None);
if (keyPathElements.isEmpty())
return false;
JSValue parent = ensureNthValueOnKeyPath(&exec, value, keyPathElements, keyPathElements.size() - 1);
if (parent.isUndefined())
return false;
auto key = keyData.maybeCreateIDBKey();
if (!key)
return false;
if (!set(&exec, parent, keyPathElements.last(), idbKeyToJSValue(&exec, exec.lexicalGlobalObject(), key.get())))
return false;
return true;
}
PassRefPtr<IDBKey> IDBKeyData::maybeCreateIDBKey() const
{
if (m_isNull)
return nullptr;
switch (m_type) {
case KeyType::Invalid:
return IDBKey::createInvalid();
case KeyType::Array:
{
Vector<RefPtr<IDBKey>> array;
for (auto& keyData : m_arrayValue) {
array.append(keyData.maybeCreateIDBKey());
ASSERT(array.last());
}
return IDBKey::createArray(array);
}
case KeyType::String:
return IDBKey::createString(m_stringValue);
case KeyType::Date:
return IDBKey::createDate(m_numberValue);
case KeyType::Number:
return IDBKey::createNumber(m_numberValue);
case KeyType::Max:
case KeyType::Min:
ASSERT_NOT_REACHED();
return nullptr;
}
ASSERT_NOT_REACHED();
return nullptr;
}
static void indicesOfNearestSnapOffsetRanges(LayoutType offset, const Vector<ScrollOffsetRange<LayoutType>>& snapOffsetRanges, unsigned& lowerIndex, unsigned& upperIndex)
{
if (snapOffsetRanges.isEmpty()) {
lowerIndex = invalidSnapOffsetIndex;
upperIndex = invalidSnapOffsetIndex;
return;
}
int lowerIndexAsInt = -1;
int upperIndexAsInt = snapOffsetRanges.size();
do {
int middleIndex = (lowerIndexAsInt + upperIndexAsInt) / 2;
auto& range = snapOffsetRanges[middleIndex];
if (range.start < offset && offset < range.end) {
lowerIndexAsInt = middleIndex;
upperIndexAsInt = middleIndex;
break;
}
if (offset > range.end)
lowerIndexAsInt = middleIndex;
else
upperIndexAsInt = middleIndex;
} while (lowerIndexAsInt < upperIndexAsInt - 1);
if (offset <= snapOffsetRanges.first().start)
lowerIndex = invalidSnapOffsetIndex;
else
lowerIndex = lowerIndexAsInt;
if (offset >= snapOffsetRanges.last().end)
upperIndex = invalidSnapOffsetIndex;
else
upperIndex = upperIndexAsInt;
}
// Fills bounds with points from argv starting at firstCoord; also resizes selected to match the size of bounds
static void readPolyBounds(S32 argc, const char **argv, S32 firstCoord, F32 gridSize,
bool allowFirstAndLastPointToBeEqual, Vector<Point> &bounds, Vector<bool> &selected)
{
Point p, lastP;
bool isTwoPointLine = (argc - firstCoord) / 2 == 2;
bounds.clear();
// Make sure we don't crash with firstCoord = 0; argc = 7; or some uneven number
for(S32 i = firstCoord; i < argc - 1; i += 2)
{
// If we are loading legacy levels (earlier than 019), then we have a gridsize multiplier
if(gridSize != 1.f)
p.set( (F32) (atof(argv[i]) * gridSize), (F32) (atof(argv[i+1]) * gridSize ) );
else
p.set( (F32) atof(argv[i]), (F32) atof(argv[i+1]));
// Normally, we'll want to filter out adjacent points that are identical. But we also
// need to handle the situation where the user has created a 2-pt 0-length line.
// Because the users demand it. We will deliver.
if(i == firstCoord || p != lastP || isTwoPointLine)
bounds.push_back(p);
lastP.set(p);
}
// Check if last point was same as first; if so, scrap it
if(!allowFirstAndLastPointToBeEqual && bounds.first() == bounds.last())
bounds.erase(bounds.size() - 1);
selected.resize(bounds.size());
}
static void parseKeyTimes(const String &parse, Vector<float> &result, bool verifyOrder)
{
result.clear();
Vector<String> parseList;
parse.split(';', parseList);
for (unsigned n = 0; n < parseList.size(); ++n) {
String timeString = parseList[n];
bool ok;
float time = timeString.toFloat(&ok);
if (!ok || time < 0 || time > 1.f) {
goto fail;
}
if (verifyOrder) {
if (!n) {
if (time != 0) {
goto fail;
}
} else if (time < result.last()) {
goto fail;
}
}
result.append(time);
}
return;
fail:
result.clear();
}
// Overview: These functions convert a JSString from holding a string in rope form
// down to a simple String representation. It does so by building up the string
// backwards, since we want to avoid recursion, we expect that the tree structure
// representing the rope is likely imbalanced with more nodes down the left side
// (since appending to the string is likely more common) - and as such resolving
// in this fashion should minimize work queue size. (If we built the queue forwards
// we would likely have to place all of the constituent StringImpls into the
// Vector before performing any concatenation, but by working backwards we likely
// only fill the queue with the number of substrings at any given level in a
// rope-of-ropes.)
void JSRopeString::resolveRopeSlowCase8(LChar* buffer) const
{
LChar* position = buffer + length(); // We will be working backwards over the rope.
Vector<JSString*, 32, UnsafeVectorOverflow> workQueue; // Putting strings into a Vector is only OK because there are no GC points in this method.
for (size_t i = 0; i < s_maxInternalRopeLength && fiber(i); ++i)
workQueue.append(fiber(i).get());
while (!workQueue.isEmpty()) {
JSString* currentFiber = workQueue.last();
workQueue.removeLast();
const LChar* characters;
if (currentFiber->isRope()) {
JSRopeString* currentFiberAsRope = static_cast<JSRopeString*>(currentFiber);
if (!currentFiberAsRope->isSubstring()) {
for (size_t i = 0; i < s_maxInternalRopeLength && currentFiberAsRope->fiber(i); ++i)
workQueue.append(currentFiberAsRope->fiber(i).get());
continue;
}
ASSERT(!currentFiberAsRope->substringBase()->isRope());
characters =
currentFiberAsRope->substringBase()->m_value.characters8() +
currentFiberAsRope->substringOffset();
} else
characters = currentFiber->m_value.characters8();
unsigned length = currentFiber->length();
position -= length;
StringImpl::copyChars(position, characters, length);
}
ASSERT(buffer == position);
}
void SVGTextLayoutAttributesBuilder::fillAttributesAtPosition(const TextPosition& position)
{
Vector<float> values;
extractFloatValuesFromSVGLengthList(position.element, position.element->x(), values, position.length);
fillListAtPosition(m_positioningLists.xValues, values, position.start);
values.clear();
extractFloatValuesFromSVGLengthList(position.element, position.element->y(), values, position.length);
fillListAtPosition(m_positioningLists.yValues, values, position.start);
values.clear();
extractFloatValuesFromSVGLengthList(position.element, position.element->dx(), values, position.length);
fillListAtPosition(m_positioningLists.dxValues, values, position.start);
values.clear();
extractFloatValuesFromSVGLengthList(position.element, position.element->dy(), values, position.length);
fillListAtPosition(m_positioningLists.dyValues, values, position.start);
values.clear();
extractFloatValuesFromSVGNumberList(position.element->rotate(), values, position.length);
fillListAtPosition(m_positioningLists.rotateValues, values, position.start);
// The last rotation value always spans the whole scope.
if (values.isEmpty())
return;
float lastValue = values.last();
for (unsigned i = values.size(); i < position.length; ++i)
m_positioningLists.rotateValues[position.start + i] = lastValue;
}
bool injectIDBKeyIntoScriptValue(DOMRequestState*, PassRefPtr<IDBKey> key, ScriptValue& value, const IDBKeyPath& keyPath)
{
IDB_TRACE("injectIDBKeyIntoScriptValue");
ASSERT(v8::Context::InContext());
ASSERT(keyPath.type() == IDBKeyPath::StringType);
Vector<String> keyPathElements;
IDBKeyPathParseError error;
IDBParseKeyPath(keyPath.string(), keyPathElements, error);
ASSERT(error == IDBKeyPathParseErrorNone);
if (!keyPathElements.size())
return 0;
v8::HandleScope handleScope;
v8::Handle<v8::Value> v8Value(value.v8Value());
v8::Handle<v8::Value> parent(ensureNthValueOnKeyPath(v8Value, keyPathElements, keyPathElements.size() - 1));
if (parent.IsEmpty())
return false;
if (!set(parent, keyPathElements.last(), toV8(key.get())))
return false;
return true;
}
HRESULT _gfxD3DXInclude::Open(THIS_ D3DXINCLUDE_TYPE IncludeType, LPCSTR pFileName,
LPCVOID pParentData, LPCVOID *ppData, UINT *pBytes,
LPSTR pFullPath, DWORD cbFullPath)
{
// First try making the path relative to the parent.
Torque::Path path = Torque::Path::Join( mLastPath.last(), '/', pFileName );
path = Torque::Path::CompressPath( path );
if ( !Torque::FS::ReadFile( path, (void *&)*ppData, *pBytes, true ) )
{
// Ok... now try using the path as is.
path = String( pFileName );
path = Torque::Path::CompressPath( path );
if ( !Torque::FS::ReadFile( path, (void *&)*ppData, *pBytes, true ) )
{
AssertISV(false, avar( "Failed to open include '%s'.", pFileName));
return E_FAIL;
}
}
// If the data was of zero size then we cannot recurse
// into this file and DX won't call Close() below.
//
// So in this case don't push on the path.
if ( *pBytes > 0 )
mLastPath.push_back( path.getRootAndPath() );
return S_OK;
}
void JSRopeString::resolveRopeSlowCase(UChar* buffer) const
{
UChar* position = buffer + m_length; // We will be working backwards over the rope.
Vector<JSString*, 32, UnsafeVectorOverflow> workQueue; // These strings are kept alive by the parent rope, so using a Vector is OK.
for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i)
workQueue.append(m_fibers[i].get());
while (!workQueue.isEmpty()) {
JSString* currentFiber = workQueue.last();
workQueue.removeLast();
if (currentFiber->isRope()) {
JSRopeString* currentFiberAsRope = static_cast<JSRopeString*>(currentFiber);
for (size_t i = 0; i < s_maxInternalRopeLength && currentFiberAsRope->m_fibers[i]; ++i)
workQueue.append(currentFiberAsRope->m_fibers[i].get());
continue;
}
StringImpl* string = static_cast<StringImpl*>(currentFiber->m_value.impl());
unsigned length = string->length();
position -= length;
if (string->is8Bit())
StringImpl::copyChars(position, string->characters8(), length);
else
StringImpl::copyChars(position, string->characters16(), length);
}
ASSERT(buffer == position);
ASSERT(!isRope());
}
static JSValueRef addTouchPointCallback(JSContextRef context, JSObjectRef, JSObjectRef, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
{
if (argumentCount < 2)
return JSValueMakeUndefined(context);
int x = static_cast<int>(JSValueToNumber(context, arguments[0], exception));
ASSERT(!exception || !*exception);
int y = static_cast<int>(JSValueToNumber(context, arguments[1], exception));
ASSERT(!exception || !*exception);
int id = touches.isEmpty() ? 0 : touches.last().id() + 1;
// pixelViewportPosition is unused in the WebKit layer, so use this for screen position
IntPoint pos(x, y);
BlackBerry::Platform::TouchPoint touch(id, BlackBerry::Platform::TouchPoint::TouchPressed, pos, pos, 0);
// Unfortunately we don't know the scroll position at this point, so use pos for the content position too.
// This assumes scroll position is 0,0
touch.populateDocumentPosition(pos, pos);
touches.append(touch);
return JSValueMakeUndefined(context);
}
void Forest::_renderCellBounds( ObjectRenderInst *ri, SceneRenderState *state, BaseMatInstance *overrideMat )
{
PROFILE_SCOPE( Forest_RenderCellBounds );
if ( overrideMat )
return;
GFXTransformSaver saver;
MatrixF projBias(true);
const Frustum frustum = GFX->getFrustum();
MathUtils::getZBiasProjectionMatrix( 0.001f, frustum, &projBias );
GFX->setProjectionMatrix( projBias );
VectorF extents;
Point3F pos;
// Get top level cells
Vector<ForestCell*> cellStack;
mData->getCells( &cellStack );
// Holds child cells we need to render as we encounter them.
Vector<ForestCell*> frontier;
GFXDrawUtil *drawer = GFX->getDrawUtil();
GFXStateBlockDesc desc;
desc.setZReadWrite( true, false );
desc.setBlend( true );
desc.setFillModeWireframe();
while ( !cellStack.empty() )
{
while ( !cellStack.empty() )
{
const ForestCell *cell = cellStack.last();
cellStack.pop_back();
Box3F box = cell->getBounds();
drawer->drawCube( desc, box, ColorI( 0, 255, 0 ) );
RectF rect = cell->getRect();
box.minExtents.set( rect.point.x, rect.point.y, box.minExtents.z );
box.maxExtents.set( rect.point.x + rect.extent.x, rect.point.y + rect.extent.y, box.minExtents.z );
drawer->drawCube( desc, box, ColorI::RED );
// If this cell has children, add them to the frontier.
if ( !cell->isLeaf() )
cell->getChildren( &frontier );
}
// Now the frontier becomes the cellStack and we empty the frontier.
cellStack = frontier;
frontier.clear();
}
}
XMLTokenizer::XMLTokenizer(DocumentFragment* fragment, Element* parentElement, FragmentScriptingPermission scriptingPermission)
: m_doc(fragment->document())
, m_view(0)
, m_context(0)
, m_pendingCallbacks(new PendingCallbacks)
, m_currentNode(fragment)
, m_sawError(false)
, m_sawXSLTransform(false)
, m_sawFirstElement(false)
, m_isXHTMLDocument(false)
#if ENABLE(XHTMLMP)
, m_isXHTMLMPDocument(false)
, m_hasDocTypeDeclaration(false)
#endif
, m_parserPaused(false)
, m_requestingScript(false)
, m_finishCalled(false)
, m_errorCount(0)
, m_lastErrorLine(0)
, m_lastErrorColumn(0)
, m_pendingScript(0)
, m_scriptStartLine(0)
, m_parsingFragment(true)
, m_scriptingPermission(scriptingPermission)
{
fragment->ref();
if (m_doc)
m_doc->ref();
// Add namespaces based on the parent node
Vector<Element*> elemStack;
while (parentElement) {
elemStack.append(parentElement);
Node* n = parentElement->parentNode();
if (!n || !n->isElementNode())
break;
parentElement = static_cast<Element*>(n);
}
if (elemStack.isEmpty())
return;
for (Element* element = elemStack.last(); !elemStack.isEmpty(); elemStack.removeLast()) {
if (NamedNodeMap* attrs = element->attributes()) {
for (unsigned i = 0; i < attrs->length(); i++) {
Attribute* attr = attrs->attributeItem(i);
if (attr->localName() == xmlnsAtom)
m_defaultNamespaceURI = attr->value();
else if (attr->prefix() == xmlnsAtom)
m_prefixToNamespaceMap.set(attr->localName(), attr->value());
}
}
}
// If the parent element is not in document tree, there may be no xmlns attribute; just default to the parent's namespace.
if (m_defaultNamespaceURI.isNull() && !parentElement->inDocument())
m_defaultNamespaceURI = parentElement->namespaceURI();
}
XMLDocumentParser::XMLDocumentParser(DocumentFragment* fragment, Element* parentElement, FragmentScriptingPermission permission)
: ScriptableDocumentParser(fragment->document())
, m_view(0)
, m_wroteText(false)
, m_currentNode(fragment)
, m_sawError(false)
, m_sawCSS(false)
, m_sawXSLTransform(false)
, m_sawFirstElement(false)
, m_isXHTMLDocument(false)
#if ENABLE(XHTMLMP)
, m_isXHTMLMPDocument(false)
, m_hasDocTypeDeclaration(false)
#endif
, m_parserPaused(false)
, m_requestingScript(false)
, m_finishCalled(false)
, m_errorCount(0)
, m_lastErrorPosition(TextPosition1::belowRangePosition())
, m_pendingScript(0)
, m_scriptStartPosition(TextPosition1::belowRangePosition())
, m_parsingFragment(true)
, m_scriptingPermission(permission)
{
fragment->ref();
// Add namespaces based on the parent node
Vector<Element*> elemStack;
while (parentElement) {
elemStack.append(parentElement);
Node* n = parentElement->parentNode();
if (!n || !n->isElementNode())
break;
parentElement = static_cast<Element*>(n);
}
if (elemStack.isEmpty())
return;
QXmlStreamNamespaceDeclarations namespaces;
for (Element* element = elemStack.last(); !elemStack.isEmpty(); elemStack.removeLast()) {
if (NamedNodeMap* attrs = element->attributes()) {
for (unsigned i = 0; i < attrs->length(); i++) {
Attribute* attr = attrs->attributeItem(i);
if (attr->localName() == "xmlns")
m_defaultNamespaceURI = attr->value();
else if (attr->prefix() == "xmlns")
namespaces.append(QXmlStreamNamespaceDeclaration(attr->localName(), attr->value()));
}
}
}
m_stream.addExtraNamespaceDeclarations(namespaces);
m_stream.setEntityResolver(new EntityResolver);
// If the parent element is not in document tree, there may be no xmlns attribute; just default to the parent's namespace.
if (m_defaultNamespaceURI.isNull() && !parentElement->inDocument())
m_defaultNamespaceURI = parentElement->namespaceURI();
}
static bool popIfBlockMatches(Vector<CSSParserTokenType>& blockStack, CSSParserTokenType type)
{
if (!blockStack.isEmpty() && blockStack.last() == type) {
blockStack.removeLast();
return true;
}
return false;
}
String pathByAppendingComponent(const String& path, const String& component)
{
if (component.isEmpty())
return path;
Vector<UChar, MAX_PATH> buffer;
buffer.append(path.characters(), path.length());
if (buffer.last() != L'\\' && buffer.last() != L'/'
&& component[0] != L'\\' && component[0] != L'/')
buffer.append(L'\\');
buffer.append(component.characters(), component.length());
return String(buffer.data(), buffer.size());
}
TEST(WTF_Vector, AppendLast)
{
Vector<unsigned> vector;
vector.append(0);
// FIXME: This test needs to be run with GuardMalloc to show the bug.
for (size_t i = 0; i < 100; ++i)
vector.append(const_cast<const unsigned&>(vector.last()));
}
FloatPointGraph::Node* FloatPointGraph::findOrCreateNode(FloatPoint point)
{
for (auto& testNode : m_allNodes) {
if (areEssentiallyEqual(*testNode, point))
return testNode.get();
}
m_allNodes.append(std::make_unique<FloatPointGraph::Node>(point));
return m_allNodes.last().get();
}
XMLDocumentParser::XMLDocumentParser(DocumentFragment* fragment, Element* parentElement, FragmentScriptingPermission scriptingPermission)
: ScriptableDocumentParser(fragment->document())
, m_view(0)
, m_context(0)
, m_pendingCallbacks(PendingCallbacks::create())
, m_depthTriggeringEntityExpansion(-1)
, m_isParsingEntityDeclaration(false)
, m_currentNode(fragment)
, m_sawError(false)
, m_sawCSS(false)
, m_sawXSLTransform(false)
, m_sawFirstElement(false)
, m_isXHTMLDocument(false)
, m_parserPaused(false)
, m_requestingScript(false)
, m_finishCalled(false)
, m_xmlErrors(fragment->document())
, m_pendingScript(0)
, m_scriptStartPosition(TextPosition::belowRangePosition())
, m_parsingFragment(true)
, m_scriptingPermission(scriptingPermission)
{
fragment->ref();
// Add namespaces based on the parent node
Vector<Element*> elemStack;
while (parentElement) {
elemStack.append(parentElement);
ContainerNode* n = parentElement->parentNode();
if (!n || !n->isElementNode())
break;
parentElement = static_cast<Element*>(n);
}
if (elemStack.isEmpty())
return;
for (; !elemStack.isEmpty(); elemStack.removeLast()) {
Element* element = elemStack.last();
if (element->hasAttributes()) {
for (unsigned i = 0; i < element->attributeCount(); i++) {
const Attribute* attribute = element->attributeItem(i);
if (attribute->localName() == xmlnsAtom)
m_defaultNamespaceURI = attribute->value();
else if (attribute->prefix() == xmlnsAtom)
m_prefixToNamespaceMap.set(attribute->localName(), attribute->value());
}
}
}
// If the parent element is not in document tree, there may be no xmlns attribute; just default to the parent's namespace.
if (m_defaultNamespaceURI.isNull() && !parentElement->inDocument())
m_defaultNamespaceURI = parentElement->namespaceURI();
}
void EventRelatedTargetAdjuster::adjust(Vector<EventContext>& ancestors)
{
Vector<EventTarget*> relatedTargetStack;
TreeScope* lastTreeScope = 0;
Node* lastNode = 0;
for (ComposedShadowTreeParentWalker walker(m_relatedTarget.get()); walker.get(); walker.parentIncludingInsertionPointAndShadowRoot()) {
Node* node = walker.get();
if (relatedTargetStack.isEmpty())
relatedTargetStack.append(node);
else if (isInsertionPoint(node) && toInsertionPoint(node)->contains(lastNode))
relatedTargetStack.append(relatedTargetStack.last());
TreeScope* scope = node->treeScope();
// Skips adding a node to the map if treeScope does not change. Just for the performance optimization.
if (scope != lastTreeScope)
m_relatedTargetMap.add(scope, relatedTargetStack.last());
lastTreeScope = scope;
lastNode = node;
if (node->isShadowRoot()) {
ASSERT(!relatedTargetStack.isEmpty());
relatedTargetStack.removeLast();
}
}
lastTreeScope = 0;
EventTarget* adjustedRelatedTarget = 0;
for (Vector<EventContext>::iterator iter = ancestors.begin(); iter < ancestors.end(); ++iter) {
TreeScope* scope = iter->node()->treeScope();
if (scope == lastTreeScope) {
// Re-use the previous adjustedRelatedTarget if treeScope does not change. Just for the performance optimization.
iter->setRelatedTarget(adjustedRelatedTarget);
} else {
adjustedRelatedTarget = findRelatedTarget(scope);
iter->setRelatedTarget(adjustedRelatedTarget);
}
lastTreeScope = scope;
if (iter->target() == adjustedRelatedTarget) {
// Event dispatching should be stopped here.
ancestors.shrink(iter - ancestors.begin());
break;
}
}
}
const TreeScope* TreeScope::commonAncestorTreeScope(const TreeScope& other) const
{
Vector<const TreeScope*, 16> thisChain;
for (const TreeScope* tree = this; tree; tree = tree->parentTreeScope())
thisChain.append(tree);
Vector<const TreeScope*, 16> otherChain;
for (const TreeScope* tree = &other; tree; tree = tree->parentTreeScope())
otherChain.append(tree);
// Keep popping out the last elements of these chains until a mismatched pair is found. If |this| and |other|
// belong to different documents, null will be returned.
const TreeScope* lastAncestor = 0;
while (!thisChain.isEmpty() && !otherChain.isEmpty() && thisChain.last() == otherChain.last()) {
lastAncestor = thisChain.last();
thisChain.removeLast();
otherChain.removeLast();
}
return lastAncestor;
}
