void SVGFilterBuilder::add(const AtomicString& id, RefPtr<FilterEffect> effect)
{
if (id.isEmpty()) {
m_lastEffect = effect;
return;
}
if (m_builtinEffects.contains(id))
return;
m_lastEffect = effect;
m_namedEffects.set(id, m_lastEffect);
}
static URL getURLForImageElement(Element& element)
{
// FIXME: Later this code should be shared with Chromium somehow. Chances are all platforms want it.
AtomicString urlString;
if (isHTMLImageElement(element) || isHTMLInputElement(element))
urlString = element.getAttribute(HTMLNames::srcAttr);
else if (element.hasTagName(SVGNames::imageTag))
urlString = element.getAttribute(XLinkNames::hrefAttr);
else if (element.hasTagName(HTMLNames::embedTag) || isHTMLObjectElement(element))
urlString = element.imageSourceURL();
return urlString.isEmpty() ? URL() : element.document().completeURL(stripLeadingAndTrailingHTMLSpaces(urlString));
}
void ImageLoader::updateFromElement()
{
// If we're not making renderers for the page, then don't load images. We don't want to slow
// down the raw HTML parsing case by loading images we don't intend to display.
Element* elem = element();
Document* doc = elem->document();
if (!doc->renderer())
return;
AtomicString attr = elem->getAttribute(elem->imageSourceAttributeName());
if (attr == m_failedLoadURL)
return;
// Do not load any image if the 'src' attribute is missing or if it is
// an empty string referring to a local file. The latter condition is
// a quirk that preserves old behavior that Dashboard widgets
// need (<rdar://problem/5994621>).
CachedImage* newImage = 0;
if (!(attr.isNull() || attr.isEmpty() && doc->baseURI().isLocalFile())) {
if (m_loadManually) {
doc->docLoader()->setAutoLoadImages(false);
newImage = new CachedImage(sourceURI(attr));
newImage->setLoading(true);
newImage->setDocLoader(doc->docLoader());
doc->docLoader()->m_documentResources.set(newImage->url(), newImage);
} else
newImage = doc->docLoader()->requestImage(sourceURI(attr));
// If we do not have an image here, it means that a cross-site
// violation occurred.
m_failedLoadURL = !newImage ? attr : AtomicString();
}
CachedImage* oldImage = m_image.get();
if (newImage != oldImage) {
setLoadingImage(newImage);
if (newImage)
newImage->addClient(this);
if (oldImage)
oldImage->removeClient(this);
}
if (RenderObject* renderer = elem->renderer()) {
if (!renderer->isImage())
return;
static_cast<RenderImage*>(renderer)->resetAnimation();
}
}
const char* WebSocketHandshake::readHTTPHeaders(const char* start, const char* end)
{
m_response.clearHeaderFields();
AtomicString name;
AtomicString value;
bool sawSecWebSocketAcceptHeaderField = false;
bool sawSecWebSocketProtocolHeaderField = false;
const char* p = start;
for (; p < end; p++) {
size_t consumedLength = parseHTTPHeader(p, end - p, m_failureReason, name, value);
if (!consumedLength)
return 0;
p += consumedLength;
// Stop once we consumed an empty line.
if (name.isEmpty())
break;
// Sec-WebSocket-Extensions may be split. We parse and check the
// header value every time the header appears.
if (equalIgnoringCase("Sec-WebSocket-Extensions", name)) {
if (!m_extensionDispatcher.processHeaderValue(value)) {
m_failureReason = formatHandshakeFailureReason(m_extensionDispatcher.failureReason());
return 0;
}
} else if (equalIgnoringCase("Sec-WebSocket-Accept", name)) {
if (sawSecWebSocketAcceptHeaderField) {
m_failureReason = formatHandshakeFailureReason("'Sec-WebSocket-Accept' header must not appear more than once in a response");
return 0;
}
m_response.addHeaderField(name, value);
sawSecWebSocketAcceptHeaderField = true;
} else if (equalIgnoringCase("Sec-WebSocket-Protocol", name)) {
if (sawSecWebSocketProtocolHeaderField) {
m_failureReason = formatHandshakeFailureReason("'Sec-WebSocket-Protocol' header must not appear more than once in a response");
return 0;
}
m_response.addHeaderField(name, value);
sawSecWebSocketProtocolHeaderField = true;
} else {
m_response.addHeaderField(name, value);
}
}
String extensions = m_extensionDispatcher.acceptedExtensions();
if (!extensions.isEmpty())
m_response.addHeaderField("Sec-WebSocket-Extensions", AtomicString(extensions));
return p;
}
void SVGDocumentExtensions::addPendingResource(const AtomicString& id, Element* element)
{
ASSERT(element);
if (id.isEmpty())
return;
HashMap<AtomicString, OwnPtr<SVGPendingElements> >::AddResult result = m_pendingResources.add(id, nullptr);
if (result.isNewEntry)
result.iterator->value = adoptPtr(new SVGPendingElements);
result.iterator->value->add(element);
element->setHasPendingResources();
}
static void appendNamespace(Vector<UChar>& result, const AtomicString& prefix, const AtomicString& ns, HashMap<AtomicStringImpl*, AtomicStringImpl*>& namespaces)
{
if (ns.isEmpty())
return;
// Use emptyAtoms's impl() for both null and empty strings since the HashMap can't handle 0 as a key
AtomicStringImpl* pre = prefix.isEmpty() ? emptyAtom.impl() : prefix.impl();
AtomicStringImpl* foundNS = namespaces.get(pre);
if (foundNS != ns.impl()) {
namespaces.set(pre, ns.impl());
DEFINE_STATIC_LOCAL(const String, xmlns, ("xmlns"));
result.append(' ');
append(result, xmlns);
if (!prefix.isEmpty()) {
result.append(':');
append(result, prefix);
}
result.append('=');
result.append('"');
appendAttributeValue(result, ns, false);
result.append('"');
}
void HTMLBRElement::collectStyleForPresentationAttribute(const QualifiedName& name, const AtomicString& value, MutableStyleProperties& style)
{
if (name == clearAttr) {
// If the string is empty, then don't add the clear property.
// <br clear> and <br clear=""> are just treated like <br> by Gecko, Mac IE, etc. -dwh
if (!value.isEmpty()) {
if (equalIgnoringCase(value, "all"))
addPropertyToPresentationAttributeStyle(style, CSSPropertyClear, CSSValueBoth);
else
addPropertyToPresentationAttributeStyle(style, CSSPropertyClear, value);
}
} else
HTMLElement::collectStyleForPresentationAttribute(name, value, style);
}
void HTMLFontElement::collectStyleForPresentationAttribute(const QualifiedName& name, const AtomicString& value, MutableStylePropertySet* style)
{
if (name == sizeAttr) {
CSSValueID size = CSSValueInvalid;
if (cssValueFromFontSizeNumber(value, size))
addPropertyToPresentationAttributeStyle(style, CSSPropertyFontSize, size);
} else if (name == colorAttr)
addHTMLColorToStyle(style, CSSPropertyColor, value);
else if (name == faceAttr && !value.isEmpty()) {
if (RefPtrWillBeRawPtr<CSSValueList> fontFaceValue = cssValuePool().createFontFaceValue(value))
style->setProperty(CSSProperty(CSSPropertyFontFamily, fontFaceValue.release()));
} else
HTMLElement::collectStyleForPresentationAttribute(name, value, style);
}
void MarkupAccumulator::appendNamespace(StringBuilder& result, const AtomicString& prefix, const AtomicString& namespaceURI, Namespaces& namespaces, bool allowEmptyDefaultNS)
{
namespaces.checkConsistency();
if (namespaceURI.isEmpty()) {
// http://www.whatwg.org/specs/web-apps/current-work/multipage/the-xhtml-syntax.html#xml-fragment-serialization-algorithm
if (allowEmptyDefaultNS && namespaces.get(emptyAtom.impl())) {
result.append(' ');
result.append(xmlnsAtom.string());
result.appendLiteral("=\"\"");
}
return;
}
// Use emptyAtoms's impl() for both null and empty strings since the HashMap can't handle 0 as a key
AtomicStringImpl* pre = prefix.isEmpty() ? emptyAtom.impl() : prefix.impl();
AtomicStringImpl* foundNS = namespaces.get(pre);
if (foundNS != namespaceURI.impl()) {
namespaces.set(pre, namespaceURI.impl());
// Add namespace to prefix pair so we can do constraint checking later.
if (inXMLFragmentSerialization() && !prefix.isEmpty())
namespaces.set(namespaceURI.impl(), pre);
// Make sure xml prefix and namespace are always known to uphold the constraints listed at http://www.w3.org/TR/xml-names11/#xmlReserved.
if (namespaceURI.impl() == XMLNames::xmlNamespaceURI.impl())
return;
result.append(' ');
result.append(xmlnsAtom.string());
if (!prefix.isEmpty()) {
result.append(':');
result.append(prefix);
}
result.append('=');
result.append('"');
appendAttributeValue(result, namespaceURI, false);
result.append('"');
}
}
bool SelectorChecker::checkPseudoClass(const CSSSelector& selector)
{
switch (selector.pseudoType()) {
case CSSSelector::PseudoFocus:
m_matchedFocusSelector = true;
return matchesFocusPseudoClass(m_element);
case CSSSelector::PseudoHover:
m_matchedHoverSelector = true;
return m_element.hovered();
case CSSSelector::PseudoActive:
m_matchedActiveSelector = true;
return m_element.active();
case CSSSelector::PseudoLang:
{
AtomicString value = m_element.computeInheritedLanguage();
const AtomicString& argument = selector.argument();
if (value.isEmpty() || !value.startsWith(argument, false))
break;
if (value.length() != argument.length() && value[argument.length()] != '-')
break;
return true;
}
case CSSSelector::PseudoHost:
{
// We can only get here if the selector was defined in the right
// scope so we don't need to check it.
// For empty parameter case, i.e. just :host or :host().
if (!selector.selectorList())
return true;
for (const CSSSelector* current = selector.selectorList()->first(); current; current = CSSSelectorList::next(*current)) {
if (match(*current))
return true;
}
return false;
}
case CSSSelector::PseudoUnknown:
case CSSSelector::PseudoNotParsed:
case CSSSelector::PseudoUserAgentCustomElement:
return false;
}
ASSERT_NOT_REACHED();
return false;
}
// Sets the entry in the font map for the given script. If family is the empty string, removes the entry instead.
static inline void setGenericFontFamilyMap(ScriptFontFamilyMap& fontMap, const AtomicString& family, UScriptCode script, Page* page)
{
ScriptFontFamilyMap::iterator it = fontMap.find(static_cast<int>(script));
if (family.isEmpty()) {
if (it == fontMap.end())
return;
fontMap.remove(it);
} else if (it != fontMap.end() && it->second == family)
return;
else
fontMap.set(static_cast<int>(script), family);
if (page)
page->setNeedsRecalcStyleInAllFrames();
}
void SearchPopupMenu::saveRecentSearches(const AtomicString& name, const Vector<String>& searchItems)
{
String fileName = String("PROGDIR:Searches");
if (!name.isEmpty())
fileName = fileName + "_" + name;
FILE *file = fopen(fileName.latin1().data(), "w");
if (file) {
Vector<String>::iterator end = (Vector<String>::iterator)searchItems.end();
for (Vector<String>::iterator it = (Vector<String>::iterator)searchItems.begin(); it < end; it++)
fprintf(file, "%s\n", (*it).utf8().data());
fclose(file);
}
}
void MarkupAccumulator::appendNamespace(StringBuilder& result, const AtomicString& prefix, const AtomicString& namespaceURI, Namespaces& namespaces)
{
namespaces.checkConsistency();
if (namespaceURI.isEmpty())
return;
// Use emptyAtoms's impl() for both null and empty strings since the HashMap can't handle 0 as a key
AtomicStringImpl* pre = prefix.isEmpty() ? emptyAtom.impl() : prefix.impl();
AtomicStringImpl* foundNS = namespaces.get(pre);
if (foundNS != namespaceURI.impl()) {
namespaces.set(pre, namespaceURI.impl());
result.append(' ');
result.append(xmlnsAtom.string());
if (!prefix.isEmpty()) {
result.append(':');
result.append(prefix);
}
result.append('=');
result.append('"');
appendAttributeValue(result, namespaceURI, false);
result.append('"');
}
}
void Attr::setPrefix(const AtomicString& prefix, ExceptionCode& ec)
{
ec = 0;
checkSetPrefix(prefix, ec);
if (ec)
return;
if ((prefix == xmlnsAtom && namespaceURI() != XMLNSNames::xmlnsNamespaceURI)
|| static_cast<Attr*>(this)->qualifiedName() == xmlnsAtom) {
ec = NAMESPACE_ERR;
return;
}
m_attribute->setPrefix(prefix.isEmpty() ? AtomicString() : prefix);
}
static bool getLineEndingTypeFromString(const AtomicString& typeString, LineEnding& endingType)
{
DEFINE_STATIC_LOCAL(AtomicString, transparent, ("transparent"));
DEFINE_STATIC_LOCAL(AtomicString, native, ("native"));
if (typeString.isEmpty() || typeString == transparent) {
endingType = EndingTransparent;
return true;
}
if (typeString == native) {
endingType = EndingNative;
return true;
}
return false;
}
void SVGDocumentExtensions::addPendingResource(const AtomicString& id, Element* element)
{
ASSERT(element);
ASSERT(element->inDocument());
if (id.isEmpty())
return;
WillBeHeapHashMap<AtomicString, OwnPtrWillBeMember<SVGPendingElements>>::AddResult result = m_pendingResources.add(id, nullptr);
if (result.isNewEntry)
result.storedValue->value = adoptPtrWillBeNoop(new SVGPendingElements);
result.storedValue->value->add(element);
element->setHasPendingResources();
}
AtomicString FrameTree::uniqueChildName(const AtomicString& requestedName) const
{
if (!requestedName.isEmpty() && !child(requestedName) && requestedName != "_blank")
return requestedName;
// Create a repeatable name for a child about to be added to us. The name must be
// unique within the frame tree. The string we generate includes a "path" of names
// from the root frame down to us. For this path to be unique, each set of siblings must
// contribute a unique name to the path, which can't collide with any HTML-assigned names.
// We generate this path component by index in the child list along with an unlikely
// frame name that can't be set in HTML because it collides with comment syntax.
const char framePathPrefix[] = "<!--framePath ";
const int framePathPrefixLength = 14;
const int framePathSuffixLength = 3;
// Find the nearest parent that has a frame with a path in it.
Vector<Frame*, 16> chain;
Frame* frame;
for (frame = m_thisFrame; frame; frame = frame->tree()->parent()) {
if (frame->tree()->name().startsWith(framePathPrefix))
break;
chain.append(frame);
}
String name;
name += framePathPrefix;
if (frame)
name += frame->tree()->name().domString().substring(framePathPrefixLength,
frame->tree()->name().length() - framePathPrefixLength - framePathSuffixLength);
for (int i = chain.size() - 1; i >= 0; --i) {
frame = chain[i];
name += "/";
name += frame->tree()->name();
}
// Suffix buffer has more than enough space for:
// 10 characters before the number
// a number (3 digits for the highest this gets in practice, 20 digits for the largest 64-bit integer)
// 6 characters after the number
// trailing null byte
// But we still use snprintf just to be extra-safe.
char suffix[40];
snprintf(suffix, sizeof(suffix), "/<!--frame%u-->-->", childCount());
name += suffix;
return AtomicString(name);
}
void SVGDocumentExtensions::addPendingResource(const AtomicString& id, PassRefPtr<SVGStyledElement> obj)
{
ASSERT(obj);
if (id.isEmpty())
return;
if (m_pendingResources.contains(id))
m_pendingResources.get(id)->add(obj);
else {
SVGPendingElements* set = new SVGPendingElements;
set->add(obj);
m_pendingResources.add(id, set);
}
}
static KURL getURLForImageNode(Node* node)
{
// FIXME: Later this code should be shared with Chromium somehow. Chances are all platforms want it.
AtomicString urlString;
if (node->hasTagName(HTMLNames::imgTag) || node->hasTagName(HTMLNames::inputTag))
urlString = static_cast<Element*>(node)->getAttribute(HTMLNames::srcAttr);
#if ENABLE(SVG)
else if (node->hasTagName(SVGNames::imageTag))
urlString = static_cast<Element*>(node)->getAttribute(XLinkNames::hrefAttr);
#endif
else if (node->hasTagName(HTMLNames::embedTag) || node->hasTagName(HTMLNames::objectTag)) {
Element* element = static_cast<Element*>(node);
urlString = element->getAttribute(element->imageSourceAttributeName());
}
return urlString.isEmpty() ? KURL() : node->document()->completeURL(stripLeadingAndTrailingHTMLSpaces(urlString));
}
void SVGDocumentExtensions::addPendingResource(const AtomicString& id, SVGStyledElement* obj)
{
ASSERT(obj);
if (id.isEmpty())
return;
if (m_pendingResources.contains(id))
m_pendingResources.get(id)->add(obj);
else {
HashSet<SVGStyledElement*>* set = new HashSet<SVGStyledElement*>();
set->add(obj);
m_pendingResources.add(id, set);
}
}
// For font families where any of the fonts don't have a valid entry in the OS/2 table
// for avgCharWidth, fallback to the legacy webkit behavior of getting the avgCharWidth
// from the width of a '0'. This only seems to apply to a fixed number of Mac fonts,
// but, in order to get similar rendering across platforms, we do this check for
// all platforms.
bool LayoutTextControl::hasValidAvgCharWidth(AtomicString family)
{
static HashSet<AtomicString>* fontFamiliesWithInvalidCharWidthMap = nullptr;
if (family.isEmpty())
return false;
if (!fontFamiliesWithInvalidCharWidthMap) {
fontFamiliesWithInvalidCharWidthMap = new HashSet<AtomicString>;
for (size_t i = 0; i < WTF_ARRAY_LENGTH(fontFamiliesWithInvalidCharWidth); ++i)
fontFamiliesWithInvalidCharWidthMap->add(AtomicString(fontFamiliesWithInvalidCharWidth[i]));
}
return !fontFamiliesWithInvalidCharWidthMap->contains(family);
}
const char* WebSocketHandshake::readHTTPHeaders(const char* start, const char* end)
{
AtomicString name;
String value;
bool sawSecWebSocketExtensionsHeaderField = false;
bool sawSecWebSocketAcceptHeaderField = false;
bool sawSecWebSocketProtocolHeaderField = false;
const char* p = start;
for (; p < end; p++) {
size_t consumedLength = parseHTTPHeader(p, end - p, m_failureReason, name, value);
if (!consumedLength)
return 0;
p += consumedLength;
// Stop once we consumed an empty line.
if (name.isEmpty())
break;
if (equalIgnoringCase("sec-websocket-extensions", name)) {
if (sawSecWebSocketExtensionsHeaderField) {
m_failureReason = "The Sec-WebSocket-Extensions header MUST NOT appear more than once in an HTTP response";
return 0;
}
if (!m_extensionDispatcher.processHeaderValue(value)) {
m_failureReason = m_extensionDispatcher.failureReason();
return 0;
}
sawSecWebSocketExtensionsHeaderField = true;
} else if (equalIgnoringCase("Sec-WebSocket-Accept", name)) {
if (sawSecWebSocketAcceptHeaderField) {
m_failureReason = "The Sec-WebSocket-Accept header MUST NOT appear more than once in an HTTP response";
return 0;
}
m_serverHandshakeResponse.addHTTPHeaderField(name, value);
sawSecWebSocketAcceptHeaderField = true;
} else if (equalIgnoringCase("Sec-WebSocket-Protocol", name)) {
if (sawSecWebSocketProtocolHeaderField) {
m_failureReason = "The Sec-WebSocket-Protocol header MUST NOT appear more than once in an HTTP response";
return 0;
}
m_serverHandshakeResponse.addHTTPHeaderField(name, value);
sawSecWebSocketProtocolHeaderField = true;
} else
m_serverHandshakeResponse.addHTTPHeaderField(name, value);
}
return p;
}
AtomicString FrameTree::uniqueChildName(const AtomicString& requestedName) const
{
// If the requested name (the frame's "name" attribute) is unique, just use that.
if (!requestedName.isEmpty() && !child(requestedName) && requestedName != "_blank")
return requestedName;
// The "name" attribute was not unique or absent. Generate a name based on the
// new frame's location in the frame tree. The name uses HTML comment syntax to
// avoid collisions with author names.
// An example path for the third child of the second child of the root frame:
// <!--framePath //<!--frame1-->/<!--frame2-->-->
const char framePathPrefix[] = "<!--framePath ";
const int framePathPrefixLength = 14;
const int framePathSuffixLength = 3;
// Find the nearest parent that has a frame with a path in it.
Vector<Frame*, 16> chain;
Frame* frame;
for (frame = &m_thisFrame; frame; frame = frame->tree().parent()) {
if (frame->tree().uniqueName().startsWith(framePathPrefix))
break;
chain.append(frame);
}
StringBuilder name;
name.append(framePathPrefix);
if (frame) {
name.append(frame->tree().uniqueName().string().substring(framePathPrefixLength,
frame->tree().uniqueName().length() - framePathPrefixLength - framePathSuffixLength));
}
for (int i = chain.size() - 1; i >= 0; --i) {
frame = chain[i];
name.append('/');
if (frame->tree().parent()) {
name.appendLiteral("<!--frame");
name.appendNumber(frame->tree().indexInParent());
name.appendLiteral("-->");
}
}
name.appendLiteral("/<!--frame");
name.appendNumber(childCount());
name.appendLiteral("-->-->");
return name.toAtomicString();
}
bool DOMTokenList::validateToken(const AtomicString& token, ExceptionCode& ec)
{
if (token.isEmpty()) {
ec = SYNTAX_ERR;
return false;
}
unsigned length = token.length();
for (unsigned i = 0; i < length; ++i) {
if (isHTMLSpace(token[i])) {
ec = INVALID_CHARACTER_ERR;
return false;
}
}
return true;
}
void HTMLCollection::namedItems(const AtomicString& name, Vector<RefPtr<Element> >& result) const
{
ASSERT(result.isEmpty());
if (name.isEmpty())
return;
updateIdNameCache();
Vector<Element*>* idResults = idCache(name);
Vector<Element*>* nameResults = nameCache(name);
for (unsigned i = 0; idResults && i < idResults->size(); ++i)
result.append(idResults->at(i));
for (unsigned i = 0; nameResults && i < nameResults->size(); ++i)
result.append(nameResults->at(i));
}
static inline String expandedName(Node* node) {
AtomicString prefix;
switch (node->getNodeType()) {
case Node::kElementNode:
prefix = toElement(node)->prefix();
break;
case Node::kAttributeNode:
prefix = toAttr(node)->prefix();
break;
default:
break;
}
return prefix.isEmpty() ? expandedNameLocalPart(node)
: prefix + ":" + expandedNameLocalPart(node);
}
bool CSSStyleSheetResource::canUseSheet(MIMETypeCheck mimeTypeCheck) const {
if (errorOccurred())
return false;
// This check exactly matches Firefox. Note that we grab the Content-Type
// header directly because we want to see what the value is BEFORE content
// sniffing. Firefox does this by setting a "type hint" on the channel. This
// implementation should be observationally equivalent.
//
// This code defaults to allowing the stylesheet for non-HTTP protocols so
// folks can use standards mode for local HTML documents.
if (mimeTypeCheck == MIMETypeCheck::Lax)
return true;
AtomicString contentType = httpContentType();
return contentType.isEmpty() || equalIgnoringCase(contentType, "text/css") ||
equalIgnoringCase(contentType, "application/x-unknown-content-type");
}
void HTMLElement::collectStyleForPresentationAttribute(const QualifiedName& name, const AtomicString& value, MutableStylePropertySet* style)
{
if (name == alignAttr) {
if (equalIgnoringCase(value, "middle"))
addPropertyToPresentationAttributeStyle(style, CSSPropertyTextAlign, CSSValueCenter);
else
addPropertyToPresentationAttributeStyle(style, CSSPropertyTextAlign, value);
} else if (name == contenteditableAttr) {
if (value.isEmpty() || equalIgnoringCase(value, "true")) {
addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitUserModify, CSSValueReadWrite);
addPropertyToPresentationAttributeStyle(style, CSSPropertyWordWrap, CSSValueBreakWord);
addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitLineBreak, CSSValueAfterWhiteSpace);
} else if (equalIgnoringCase(value, "plaintext-only")) {
addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitUserModify, CSSValueReadWritePlaintextOnly);
addPropertyToPresentationAttributeStyle(style, CSSPropertyWordWrap, CSSValueBreakWord);
addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitLineBreak, CSSValueAfterWhiteSpace);
} else if (equalIgnoringCase(value, "false"))
addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitUserModify, CSSValueReadOnly);
} else if (name == hiddenAttr) {
addPropertyToPresentationAttributeStyle(style, CSSPropertyDisplay, CSSValueNone);
} else if (name == draggableAttr) {
if (equalIgnoringCase(value, "true")) {
addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitUserDrag, CSSValueElement);
addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitUserSelect, CSSValueNone);
} else if (equalIgnoringCase(value, "false"))
addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitUserDrag, CSSValueNone);
} else if (name == dirAttr) {
if (equalIgnoringCase(value, "auto"))
addPropertyToPresentationAttributeStyle(style, CSSPropertyUnicodeBidi, unicodeBidiAttributeForDirAuto(this));
else {
if (isValidDirAttribute(value))
addPropertyToPresentationAttributeStyle(style, CSSPropertyDirection, value);
else
addPropertyToPresentationAttributeStyle(style, CSSPropertyDirection, "ltr");
if (!hasTagName(bdiTag) && !hasTagName(bdoTag) && !hasTagName(outputTag))
addPropertyToPresentationAttributeStyle(style, CSSPropertyUnicodeBidi, CSSValueEmbed);
}
} else if (name.matches(XMLNames::langAttr))
mapLanguageAttributeToLocale(value, style);
else if (name == langAttr) {
// xml:lang has a higher priority than lang.
if (!fastHasAttribute(XMLNames::langAttr))
mapLanguageAttributeToLocale(value, style);
} else
Element::collectStyleForPresentationAttribute(name, value, style);
}
size_t HTTPRequest::parseHeaders(const char* data, size_t length, String& failureReason)
{
const char* p = data;
const char* end = data + length;
AtomicString name;
String value;
for (; p < data + length; p++) {
size_t consumedLength = parseHTTPHeader(p, end - p, failureReason, name, value);
if (!consumedLength)
return 0;
p += consumedLength;
if (name.isEmpty())
break;
m_headerFields.add(name, value);
}
return p - data;
}
void EventTarget::setupLegacyTypeObserverIfNeeded(const AtomicString& legacyTypeName, bool hasLegacyTypeListeners, bool hasNewTypeListeners)
{
ASSERT(!legacyTypeName.isEmpty());
ASSERT(hasLegacyTypeListeners || hasNewTypeListeners);
ScriptExecutionContext* context = scriptExecutionContext();
if (!context || !context->isDocument())
return;
Document* document = toDocument(context);
if (!document->domWindow())
return;
FeatureObserver::Feature feature;
if (shouldObserveLegacyType(legacyTypeName, hasLegacyTypeListeners, hasNewTypeListeners, feature))
FeatureObserver::observe(document->domWindow(), feature);
}