887ebe49244aade1b61342c1f7481a3a1c90c60d
[WebKit-https.git] / Source / WebCore / html / HTMLElement.cpp
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
4  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
5  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
6  * Copyright (C) 2011 Motorola Mobility. All rights reserved.
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Library General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Library General Public License for more details.
17  *
18  * You should have received a copy of the GNU Library General Public License
19  * along with this library; see the file COPYING.LIB.  If not, write to
20  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21  * Boston, MA 02110-1301, USA.
22  *
23  */
24
25 #include "config.h"
26 #include "HTMLElement.h"
27
28 #include "Attribute.h"
29 #include "CSSParser.h"
30 #include "CSSPropertyNames.h"
31 #include "CSSValueKeywords.h"
32 #include "CSSValuePool.h"
33 #include "DOMSettableTokenList.h"
34 #include "DocumentFragment.h"
35 #include "ElementIterator.h"
36 #include "Event.h"
37 #include "EventListener.h"
38 #include "EventNames.h"
39 #include "ExceptionCode.h"
40 #include "Frame.h"
41 #include "FrameLoader.h"
42 #include "HTMLBRElement.h"
43 #include "HTMLCollection.h"
44 #include "HTMLDocument.h"
45 #include "HTMLElementFactory.h"
46 #include "HTMLFormElement.h"
47 #include "HTMLNames.h"
48 #include "HTMLParserIdioms.h"
49 #include "HTMLTemplateElement.h"
50 #include "HTMLTextFormControlElement.h"
51 #include "NodeTraversal.h"
52 #include "RenderLineBreak.h"
53 #include "ScriptController.h"
54 #include "Settings.h"
55 #include "StylePropertySet.h"
56 #include "SubframeLoader.h"
57 #include "Text.h"
58 #include "TextIterator.h"
59 #include "XMLNames.h"
60 #include "markup.h"
61 #include <wtf/NeverDestroyed.h>
62 #include <wtf/StdLibExtras.h>
63 #include <wtf/text/CString.h>
64
65 namespace WebCore {
66
67 using namespace HTMLNames;
68 using namespace WTF;
69
70 using std::min;
71 using std::max;
72
73 PassRefPtr<HTMLElement> HTMLElement::create(const QualifiedName& tagName, Document& document)
74 {
75     return adoptRef(new HTMLElement(tagName, document));
76 }
77
78 String HTMLElement::nodeName() const
79 {
80     // FIXME: Would be nice to have an atomicstring lookup based off uppercase
81     // chars that does not have to copy the string on a hit in the hash.
82     // FIXME: We should have a way to detect XHTML elements and replace the hasPrefix() check with it.
83     if (document().isHTMLDocument() && !tagQName().hasPrefix())
84         return tagQName().localNameUpper();
85     return Element::nodeName();
86 }
87
88 bool HTMLElement::ieForbidsInsertHTML() const
89 {
90     // FIXME: Supposedly IE disallows settting innerHTML, outerHTML
91     // and createContextualFragment on these tags.  We have no tests to
92     // verify this however, so this list could be totally wrong.
93     // This list was moved from the previous endTagRequirement() implementation.
94     // This is also called from editing and assumed to be the list of tags
95     // for which no end tag should be serialized. It's unclear if the list for
96     // IE compat and the list for serialization sanity are the same.
97     if (hasLocalName(areaTag)
98         || hasLocalName(baseTag)
99         || hasLocalName(basefontTag)
100         || hasLocalName(brTag)
101         || hasLocalName(colTag)
102         || hasLocalName(embedTag)
103         || hasLocalName(frameTag)
104         || hasLocalName(hrTag)
105         || hasLocalName(imageTag)
106         || hasLocalName(imgTag)
107         || hasLocalName(inputTag)
108         || hasLocalName(isindexTag)
109         || hasLocalName(linkTag)
110         || hasLocalName(metaTag)
111         || hasLocalName(paramTag)
112         || hasLocalName(sourceTag)
113         || hasLocalName(wbrTag))
114         return true;
115     // FIXME: I'm not sure why dashboard mode would want to change the
116     // serialization of <canvas>, that seems like a bad idea.
117 #if ENABLE(DASHBOARD_SUPPORT)
118     if (hasLocalName(canvasTag)) {
119         Settings* settings = document().settings();
120         if (settings && settings->usesDashboardBackwardCompatibilityMode())
121             return true;
122     }
123 #endif
124     return false;
125 }
126
127 static inline CSSValueID unicodeBidiAttributeForDirAuto(HTMLElement* element)
128 {
129     if (element->hasLocalName(preTag) || element->hasLocalName(textareaTag))
130         return CSSValueWebkitPlaintext;
131     // FIXME: For bdo element, dir="auto" should result in "bidi-override isolate" but we don't support having multiple values in unicode-bidi yet.
132     // See https://bugs.webkit.org/show_bug.cgi?id=73164.
133     return CSSValueWebkitIsolate;
134 }
135
136 unsigned HTMLElement::parseBorderWidthAttribute(const AtomicString& value) const
137 {
138     unsigned borderWidth = 0;
139     if (value.isEmpty() || !parseHTMLNonNegativeInteger(value, borderWidth))
140         return hasLocalName(tableTag) ? 1 : borderWidth;
141     return borderWidth;
142 }
143
144 void HTMLElement::applyBorderAttributeToStyle(const AtomicString& value, MutableStylePropertySet* style)
145 {
146     addPropertyToPresentationAttributeStyle(style, CSSPropertyBorderWidth, parseBorderWidthAttribute(value), CSSPrimitiveValue::CSS_PX);
147     addPropertyToPresentationAttributeStyle(style, CSSPropertyBorderStyle, CSSValueSolid);
148 }
149
150 void HTMLElement::mapLanguageAttributeToLocale(const AtomicString& value, MutableStylePropertySet* style)
151 {
152     if (!value.isEmpty()) {
153         // Have to quote so the locale id is treated as a string instead of as a CSS keyword.
154         addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitLocale, quoteCSSString(value));
155     } else {
156         // The empty string means the language is explicitly unknown.
157         addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitLocale, CSSValueAuto);
158     }
159 }
160
161 bool HTMLElement::isPresentationAttribute(const QualifiedName& name) const
162 {
163     if (name == alignAttr || name == contenteditableAttr || name == hiddenAttr || name == langAttr || name.matches(XMLNames::langAttr) || name == draggableAttr || name == dirAttr)
164         return true;
165     return StyledElement::isPresentationAttribute(name);
166 }
167
168 void HTMLElement::collectStyleForPresentationAttribute(const QualifiedName& name, const AtomicString& value, MutableStylePropertySet* style)
169 {
170     if (name == alignAttr) {
171         if (equalIgnoringCase(value, "middle"))
172             addPropertyToPresentationAttributeStyle(style, CSSPropertyTextAlign, CSSValueCenter);
173         else
174             addPropertyToPresentationAttributeStyle(style, CSSPropertyTextAlign, value);
175     } else if (name == contenteditableAttr) {
176         if (value.isEmpty() || equalIgnoringCase(value, "true")) {
177             addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitUserModify, CSSValueReadWrite);
178             addPropertyToPresentationAttributeStyle(style, CSSPropertyWordWrap, CSSValueBreakWord);
179             addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitNbspMode, CSSValueSpace);
180             addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitLineBreak, CSSValueAfterWhiteSpace);
181         } else if (equalIgnoringCase(value, "plaintext-only")) {
182             addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitUserModify, CSSValueReadWritePlaintextOnly);
183             addPropertyToPresentationAttributeStyle(style, CSSPropertyWordWrap, CSSValueBreakWord);
184             addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitNbspMode, CSSValueSpace);
185             addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitLineBreak, CSSValueAfterWhiteSpace);
186         } else if (equalIgnoringCase(value, "false"))
187             addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitUserModify, CSSValueReadOnly);
188     } else if (name == hiddenAttr) {
189         addPropertyToPresentationAttributeStyle(style, CSSPropertyDisplay, CSSValueNone);
190     } else if (name == draggableAttr) {
191         if (equalIgnoringCase(value, "true")) {
192             addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitUserDrag, CSSValueElement);
193             addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitUserSelect, CSSValueNone);
194         } else if (equalIgnoringCase(value, "false"))
195             addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitUserDrag, CSSValueNone);
196     } else if (name == dirAttr) {
197         if (equalIgnoringCase(value, "auto"))
198             addPropertyToPresentationAttributeStyle(style, CSSPropertyUnicodeBidi, unicodeBidiAttributeForDirAuto(this));
199         else {
200             addPropertyToPresentationAttributeStyle(style, CSSPropertyDirection, value);
201             if (!hasTagName(bdiTag) && !hasTagName(bdoTag) && !hasTagName(outputTag))
202                 addPropertyToPresentationAttributeStyle(style, CSSPropertyUnicodeBidi, CSSValueEmbed);
203         }
204     } else if (name.matches(XMLNames::langAttr))
205         mapLanguageAttributeToLocale(value, style);
206     else if (name == langAttr) {
207         // xml:lang has a higher priority than lang.
208         if (!fastHasAttribute(XMLNames::langAttr))
209             mapLanguageAttributeToLocale(value, style);
210     } else
211         StyledElement::collectStyleForPresentationAttribute(name, value, style);
212 }
213
214 static NEVER_INLINE void populateEventNameForAttributeLocalNameMap(HashMap<AtomicStringImpl*, AtomicString>& map)
215 {
216     static const QualifiedName* const simpleTable[] = {
217         &onabortAttr,
218         &onbeforecopyAttr,
219         &onbeforecutAttr,
220         &onbeforepasteAttr,
221         &onblurAttr,
222         &oncanplayAttr,
223         &oncanplaythroughAttr,
224         &onchangeAttr,
225         &onclickAttr,
226         &oncontextmenuAttr,
227         &oncopyAttr,
228         &oncutAttr,
229         &ondblclickAttr,
230         &ondragAttr,
231         &ondragendAttr,
232         &ondragenterAttr,
233         &ondragleaveAttr,
234         &ondragoverAttr,
235         &ondragstartAttr,
236         &ondropAttr,
237         &ondurationchangeAttr,
238         &onemptiedAttr,
239         &onendedAttr,
240         &onerrorAttr,
241         &onfocusAttr,
242         &onfocusinAttr,
243         &onfocusoutAttr,
244         &oninputAttr,
245         &oninvalidAttr,
246         &onkeydownAttr,
247         &onkeypressAttr,
248         &onkeyupAttr,
249         &onloadAttr,
250         &onloadeddataAttr,
251         &onloadedmetadataAttr,
252         &onloadstartAttr,
253         &onmousedownAttr,
254         &onmouseenterAttr,
255         &onmouseleaveAttr,
256         &onmousemoveAttr,
257         &onmouseoutAttr,
258         &onmouseoverAttr,
259         &onmouseupAttr,
260         &onmousewheelAttr,
261         &onpasteAttr,
262         &onpauseAttr,
263         &onplayAttr,
264         &onplayingAttr,
265         &onprogressAttr,
266         &onratechangeAttr,
267         &onresetAttr,
268         &onscrollAttr,
269         &onseekedAttr,
270         &onseekingAttr,
271         &onselectAttr,
272         &onselectstartAttr,
273         &onstalledAttr,
274         &onsubmitAttr,
275         &onsuspendAttr,
276         &ontimeupdateAttr,
277         &ontouchcancelAttr,
278         &ontouchendAttr,
279         &ontouchmoveAttr,
280         &ontouchstartAttr,
281         &onvolumechangeAttr,
282         &onwaitingAttr,
283         &onwheelAttr,
284 #if ENABLE(FULLSCREEN_API)
285         &onwebkitfullscreenchangeAttr,
286         &onwebkitfullscreenerrorAttr,
287 #endif
288     };
289
290     for (unsigned i = 0, size = WTF_ARRAY_LENGTH(simpleTable); i < size; ++i) {
291         // FIXME: Would be nice to check these against the actual event names in eventNames().
292         // Not obvious how to do that simply, though.
293         const AtomicString& attributeName = simpleTable[i]->localName();
294
295         // Remove the "on" prefix. Requires some memory allocation and computing a hash, but
296         // by not using pointers from eventNames(), simpleTable can be initialized at compile time.
297         AtomicString eventName = attributeName.string().substring(2);
298
299         map.add(attributeName.impl(), eventName);
300     }
301
302     struct CustomMapping {
303         const QualifiedName& attributeName;
304         const AtomicString& eventName;
305     };
306
307     const CustomMapping customTable[] = {
308         { ontransitionendAttr, eventNames().webkitTransitionEndEvent },
309         { onwebkitanimationendAttr, eventNames().webkitAnimationEndEvent },
310         { onwebkitanimationiterationAttr, eventNames().webkitAnimationIterationEvent },
311         { onwebkitanimationstartAttr, eventNames().webkitAnimationStartEvent },
312         { onwebkittransitionendAttr, eventNames().webkitTransitionEndEvent },
313     };
314
315     for (unsigned i = 0, size = WTF_ARRAY_LENGTH(customTable); i < size; ++i)
316         map.add(customTable[i].attributeName.localName().impl(), customTable[i].eventName);
317 }
318
319 void HTMLElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
320 {
321     if (isIdAttributeName(name) || name == classAttr || name == styleAttr)
322         return StyledElement::parseAttribute(name, value);
323
324     if (name == dirAttr)
325         dirAttributeChanged(value);
326     else if (name == tabindexAttr) {
327         int tabindex = 0;
328         if (value.isEmpty())
329             clearTabIndexExplicitlyIfNeeded();
330         else if (parseHTMLInteger(value, tabindex)) {
331             // Clamp tabindex to the range of 'short' to match Firefox's behavior.
332             setTabIndexExplicitly(max(static_cast<int>(std::numeric_limits<short>::min()), min(tabindex, static_cast<int>(std::numeric_limits<short>::max()))));
333         }
334     } else if (name.namespaceURI().isNull()) {
335         // FIXME: Can we do this even faster by checking the local name "on" prefix before we do anything with the map?
336         static NeverDestroyed<HashMap<AtomicStringImpl*, AtomicString>> eventNamesGlobal;
337         auto& eventNames = eventNamesGlobal.get();
338         if (eventNames.isEmpty())
339             populateEventNameForAttributeLocalNameMap(eventNames);
340         const AtomicString& eventName = eventNames.get(name.localName().impl());
341         if (!eventName.isNull())
342             setAttributeEventListener(eventName, name, value);
343     }
344 }
345
346 String HTMLElement::innerHTML() const
347 {
348     return createMarkup(this, ChildrenOnly);
349 }
350
351 String HTMLElement::outerHTML() const
352 {
353     return createMarkup(this);
354 }
355
356 void HTMLElement::setInnerHTML(const String& html, ExceptionCode& ec)
357 {
358     if (RefPtr<DocumentFragment> fragment = createFragmentForInnerOuterHTML(html, this, AllowScriptingContent, ec)) {
359         ContainerNode* container = this;
360 #if ENABLE(TEMPLATE_ELEMENT)
361         if (hasLocalName(templateTag))
362             container = toHTMLTemplateElement(this)->content();
363 #endif
364         replaceChildrenWithFragment(*container, fragment.release(), ec);
365     }
366 }
367
368 static void mergeWithNextTextNode(PassRefPtr<Node> node, ExceptionCode& ec)
369 {
370     ASSERT(node && node->isTextNode());
371     Node* next = node->nextSibling();
372     if (!next || !next->isTextNode())
373         return;
374     
375     RefPtr<Text> textNode = toText(node.get());
376     RefPtr<Text> textNext = toText(next);
377     textNode->appendData(textNext->data(), ec);
378     if (ec)
379         return;
380     if (textNext->parentNode()) // Might have been removed by mutation event.
381         textNext->remove(ec);
382 }
383
384 void HTMLElement::setOuterHTML(const String& html, ExceptionCode& ec)
385 {
386     Node* p = parentNode();
387     if (!p || !p->isHTMLElement()) {
388         ec = NO_MODIFICATION_ALLOWED_ERR;
389         return;
390     }
391     RefPtr<HTMLElement> parent = toHTMLElement(p);
392     RefPtr<Node> prev = previousSibling();
393     RefPtr<Node> next = nextSibling();
394
395     RefPtr<DocumentFragment> fragment = createFragmentForInnerOuterHTML(html, parent.get(), AllowScriptingContent, ec);
396     if (ec)
397         return;
398       
399     parent->replaceChild(fragment.release(), this, ec);
400     RefPtr<Node> node = next ? next->previousSibling() : 0;
401     if (!ec && node && node->isTextNode())
402         mergeWithNextTextNode(node.release(), ec);
403
404     if (!ec && prev && prev->isTextNode())
405         mergeWithNextTextNode(prev.release(), ec);
406 }
407
408 PassRefPtr<DocumentFragment> HTMLElement::textToFragment(const String& text, ExceptionCode& ec)
409 {
410     RefPtr<DocumentFragment> fragment = DocumentFragment::create(document());
411     unsigned int i, length = text.length();
412     UChar c = 0;
413     for (unsigned int start = 0; start < length; ) {
414
415         // Find next line break.
416         for (i = start; i < length; i++) {
417           c = text[i];
418           if (c == '\r' || c == '\n')
419               break;
420         }
421
422         fragment->appendChild(Text::create(document(), text.substring(start, i - start)), ec);
423         if (ec)
424             return 0;
425
426         if (c == '\r' || c == '\n') {
427             fragment->appendChild(HTMLBRElement::create(document()), ec);
428             if (ec)
429                 return 0;
430             // Make sure \r\n doesn't result in two line breaks.
431             if (c == '\r' && i + 1 < length && text[i + 1] == '\n')
432                 i++;
433         }
434
435         start = i + 1; // Character after line break.
436     }
437
438     return fragment;
439 }
440
441 void HTMLElement::setInnerText(const String& text, ExceptionCode& ec)
442 {
443     if (ieForbidsInsertHTML()) {
444         ec = NO_MODIFICATION_ALLOWED_ERR;
445         return;
446     }
447     if (hasLocalName(colTag) || hasLocalName(colgroupTag) || hasLocalName(framesetTag) ||
448         hasLocalName(headTag) || hasLocalName(htmlTag) || hasLocalName(tableTag) || 
449         hasLocalName(tbodyTag) || hasLocalName(tfootTag) || hasLocalName(theadTag) ||
450         hasLocalName(trTag)) {
451         ec = NO_MODIFICATION_ALLOWED_ERR;
452         return;
453     }
454
455     // FIXME: This doesn't take whitespace collapsing into account at all.
456
457     if (!text.contains('\n') && !text.contains('\r')) {
458         if (text.isEmpty()) {
459             removeChildren();
460             return;
461         }
462         replaceChildrenWithText(*this, text, ec);
463         return;
464     }
465
466     // FIXME: Do we need to be able to detect preserveNewline style even when there's no renderer?
467     // FIXME: Can the renderer be out of date here? Do we need to call updateStyleIfNeeded?
468     // For example, for the contents of textarea elements that are display:none?
469     auto r = renderer();
470     if (r && r->style()->preserveNewline()) {
471         if (!text.contains('\r')) {
472             replaceChildrenWithText(*this, text, ec);
473             return;
474         }
475         String textWithConsistentLineBreaks = text;
476         textWithConsistentLineBreaks.replace("\r\n", "\n");
477         textWithConsistentLineBreaks.replace('\r', '\n');
478         replaceChildrenWithText(*this, textWithConsistentLineBreaks, ec);
479         return;
480     }
481
482     // Add text nodes and <br> elements.
483     ec = 0;
484     RefPtr<DocumentFragment> fragment = textToFragment(text, ec);
485     if (!ec)
486         replaceChildrenWithFragment(*this, fragment.release(), ec);
487 }
488
489 void HTMLElement::setOuterText(const String &text, ExceptionCode& ec)
490 {
491     if (ieForbidsInsertHTML()) {
492         ec = NO_MODIFICATION_ALLOWED_ERR;
493         return;
494     }
495     if (hasLocalName(colTag) || hasLocalName(colgroupTag) || hasLocalName(framesetTag) ||
496         hasLocalName(headTag) || hasLocalName(htmlTag) || hasLocalName(tableTag) || 
497         hasLocalName(tbodyTag) || hasLocalName(tfootTag) || hasLocalName(theadTag) ||
498         hasLocalName(trTag)) {
499         ec = NO_MODIFICATION_ALLOWED_ERR;
500         return;
501     }
502
503     ContainerNode* parent = parentNode();
504     if (!parent) {
505         ec = NO_MODIFICATION_ALLOWED_ERR;
506         return;
507     }
508
509     RefPtr<Node> prev = previousSibling();
510     RefPtr<Node> next = nextSibling();
511     RefPtr<Node> newChild;
512     ec = 0;
513     
514     // Convert text to fragment with <br> tags instead of linebreaks if needed.
515     if (text.contains('\r') || text.contains('\n'))
516         newChild = textToFragment(text, ec);
517     else
518         newChild = Text::create(document(), text);
519
520     if (!this || !parentNode())
521         ec = HIERARCHY_REQUEST_ERR;
522     if (ec)
523         return;
524     parent->replaceChild(newChild.release(), this, ec);
525
526     RefPtr<Node> node = next ? next->previousSibling() : 0;
527     if (!ec && node && node->isTextNode())
528         mergeWithNextTextNode(node.release(), ec);
529
530     if (!ec && prev && prev->isTextNode())
531         mergeWithNextTextNode(prev.release(), ec);
532 }
533
534 Node* HTMLElement::insertAdjacent(const String& where, Node* newChild, ExceptionCode& ec)
535 {
536     // In Internet Explorer if the element has no parent and where is "beforeBegin" or "afterEnd",
537     // a document fragment is created and the elements appended in the correct order. This document
538     // fragment isn't returned anywhere.
539     //
540     // This is impossible for us to implement as the DOM tree does not allow for such structures,
541     // Opera also appears to disallow such usage.
542
543     if (equalIgnoringCase(where, "beforeBegin")) {
544         ContainerNode* parent = this->parentNode();
545         return (parent && parent->insertBefore(newChild, this, ec)) ? newChild : 0;
546     }
547
548     if (equalIgnoringCase(where, "afterBegin"))
549         return insertBefore(newChild, firstChild(), ec) ? newChild : 0;
550
551     if (equalIgnoringCase(where, "beforeEnd"))
552         return appendChild(newChild, ec) ? newChild : 0;
553
554     if (equalIgnoringCase(where, "afterEnd")) {
555         ContainerNode* parent = this->parentNode();
556         return (parent && parent->insertBefore(newChild, nextSibling(), ec)) ? newChild : 0;
557     }
558     
559     // IE throws COM Exception E_INVALIDARG; this is the best DOM exception alternative.
560     ec = NOT_SUPPORTED_ERR;
561     return 0;
562 }
563
564 Element* HTMLElement::insertAdjacentElement(const String& where, Element* newChild, ExceptionCode& ec)
565 {
566     if (!newChild) {
567         // IE throws COM Exception E_INVALIDARG; this is the best DOM exception alternative.
568         ec = TYPE_MISMATCH_ERR;
569         return 0;
570     }
571
572     Node* returnValue = insertAdjacent(where, newChild, ec);
573     ASSERT_WITH_SECURITY_IMPLICATION(!returnValue || returnValue->isElementNode());
574     return toElement(returnValue); 
575 }
576
577 // Step 3 of http://www.whatwg.org/specs/web-apps/current-work/multipage/apis-in-html-documents.html#insertadjacenthtml()
578 static Element* contextElementForInsertion(const String& where, Element* element, ExceptionCode& ec)
579 {
580     if (equalIgnoringCase(where, "beforeBegin") || equalIgnoringCase(where, "afterEnd")) {
581         ContainerNode* parent = element->parentNode();
582         if (parent && !parent->isElementNode()) {
583             ec = NO_MODIFICATION_ALLOWED_ERR;
584             return 0;
585         }
586         ASSERT_WITH_SECURITY_IMPLICATION(!parent || parent->isElementNode());
587         return toElement(parent);
588     }
589     if (equalIgnoringCase(where, "afterBegin") || equalIgnoringCase(where, "beforeEnd"))
590         return element;
591     ec =  SYNTAX_ERR;
592     return 0;
593 }
594
595 void HTMLElement::insertAdjacentHTML(const String& where, const String& markup, ExceptionCode& ec)
596 {
597     Element* contextElement = contextElementForInsertion(where, this, ec);
598     if (!contextElement)
599         return;
600     RefPtr<DocumentFragment> fragment = createFragmentForInnerOuterHTML(markup, contextElement, AllowScriptingContent, ec);
601     if (!fragment)
602         return;
603     insertAdjacent(where, fragment.get(), ec);
604 }
605
606 void HTMLElement::insertAdjacentText(const String& where, const String& text, ExceptionCode& ec)
607 {
608     RefPtr<Text> textNode = document().createTextNode(text);
609     insertAdjacent(where, textNode.get(), ec);
610 }
611
612 void HTMLElement::applyAlignmentAttributeToStyle(const AtomicString& alignment, MutableStylePropertySet* style)
613 {
614     // Vertical alignment with respect to the current baseline of the text
615     // right or left means floating images.
616     CSSValueID floatValue = CSSValueInvalid;
617     CSSValueID verticalAlignValue = CSSValueInvalid;
618
619     if (equalIgnoringCase(alignment, "absmiddle"))
620         verticalAlignValue = CSSValueMiddle;
621     else if (equalIgnoringCase(alignment, "absbottom"))
622         verticalAlignValue = CSSValueBottom;
623     else if (equalIgnoringCase(alignment, "left")) {
624         floatValue = CSSValueLeft;
625         verticalAlignValue = CSSValueTop;
626     } else if (equalIgnoringCase(alignment, "right")) {
627         floatValue = CSSValueRight;
628         verticalAlignValue = CSSValueTop;
629     } else if (equalIgnoringCase(alignment, "top"))
630         verticalAlignValue = CSSValueTop;
631     else if (equalIgnoringCase(alignment, "middle"))
632         verticalAlignValue = CSSValueWebkitBaselineMiddle;
633     else if (equalIgnoringCase(alignment, "center"))
634         verticalAlignValue = CSSValueMiddle;
635     else if (equalIgnoringCase(alignment, "bottom"))
636         verticalAlignValue = CSSValueBaseline;
637     else if (equalIgnoringCase(alignment, "texttop"))
638         verticalAlignValue = CSSValueTextTop;
639
640     if (floatValue != CSSValueInvalid)
641         addPropertyToPresentationAttributeStyle(style, CSSPropertyFloat, floatValue);
642
643     if (verticalAlignValue != CSSValueInvalid)
644         addPropertyToPresentationAttributeStyle(style, CSSPropertyVerticalAlign, verticalAlignValue);
645 }
646
647 bool HTMLElement::hasCustomFocusLogic() const
648 {
649     return false;
650 }
651
652 bool HTMLElement::supportsFocus() const
653 {
654     return Element::supportsFocus() || (rendererIsEditable() && parentNode() && !parentNode()->rendererIsEditable());
655 }
656
657 String HTMLElement::contentEditable() const
658 {
659     const AtomicString& value = fastGetAttribute(contenteditableAttr);
660
661     if (value.isNull())
662         return "inherit";
663     if (value.isEmpty() || equalIgnoringCase(value, "true"))
664         return "true";
665     if (equalIgnoringCase(value, "false"))
666          return "false";
667     if (equalIgnoringCase(value, "plaintext-only"))
668         return "plaintext-only";
669
670     return "inherit";
671 }
672
673 void HTMLElement::setContentEditable(const String& enabled, ExceptionCode& ec)
674 {
675     if (equalIgnoringCase(enabled, "true"))
676         setAttribute(contenteditableAttr, "true");
677     else if (equalIgnoringCase(enabled, "false"))
678         setAttribute(contenteditableAttr, "false");
679     else if (equalIgnoringCase(enabled, "plaintext-only"))
680         setAttribute(contenteditableAttr, "plaintext-only");
681     else if (equalIgnoringCase(enabled, "inherit"))
682         removeAttribute(contenteditableAttr);
683     else
684         ec = SYNTAX_ERR;
685 }
686
687 bool HTMLElement::draggable() const
688 {
689     return equalIgnoringCase(getAttribute(draggableAttr), "true");
690 }
691
692 void HTMLElement::setDraggable(bool value)
693 {
694     setAttribute(draggableAttr, value ? "true" : "false");
695 }
696
697 bool HTMLElement::spellcheck() const
698 {
699     return isSpellCheckingEnabled();
700 }
701
702 void HTMLElement::setSpellcheck(bool enable)
703 {
704     setAttribute(spellcheckAttr, enable ? "true" : "false");
705 }
706
707
708 void HTMLElement::click()
709 {
710     dispatchSimulatedClick(0, SendNoEvents, DoNotShowPressedLook);
711 }
712
713 void HTMLElement::accessKeyAction(bool sendMouseEvents)
714 {
715     dispatchSimulatedClick(0, sendMouseEvents ? SendMouseUpDownEvents : SendNoEvents);
716 }
717
718 String HTMLElement::title() const
719 {
720     return getAttribute(titleAttr);
721 }
722
723 short HTMLElement::tabIndex() const
724 {
725     if (supportsFocus())
726         return Element::tabIndex();
727     return -1;
728 }
729
730 void HTMLElement::setTabIndex(int value)
731 {
732     setIntegralAttribute(tabindexAttr, value);
733 }
734
735 TranslateAttributeMode HTMLElement::translateAttributeMode() const
736 {
737     const AtomicString& value = getAttribute(translateAttr);
738
739     if (value == nullAtom)
740         return TranslateAttributeInherit;
741     if (equalIgnoringCase(value, "yes") || equalIgnoringCase(value, ""))
742         return TranslateAttributeYes;
743     if (equalIgnoringCase(value, "no"))
744         return TranslateAttributeNo;
745
746     return TranslateAttributeInherit;
747 }
748
749 bool HTMLElement::translate() const
750 {
751     for (const Node* n = this; n; n = n->parentNode()) {
752         if (n->isHTMLElement()) {
753             TranslateAttributeMode mode = static_cast<const HTMLElement*>(n)->translateAttributeMode();
754             if (mode != TranslateAttributeInherit) {
755                 ASSERT(mode == TranslateAttributeYes || mode == TranslateAttributeNo);
756                 return mode == TranslateAttributeYes;
757             }
758         }
759     }
760
761     // Default on the root element is translate=yes.
762     return true;
763 }
764
765 void HTMLElement::setTranslate(bool enable)
766 {
767     setAttribute(translateAttr, enable ? "yes" : "no");
768 }
769
770
771 PassRefPtr<HTMLCollection> HTMLElement::children()
772 {
773     return ensureCachedHTMLCollection(NodeChildren);
774 }
775
776 bool HTMLElement::rendererIsNeeded(const RenderStyle& style)
777 {
778     if (hasLocalName(noscriptTag)) {
779         Frame* frame = document().frame();
780         if (frame && frame->script().canExecuteScripts(NotAboutToExecuteScript))
781             return false;
782     } else if (hasLocalName(noembedTag)) {
783         Frame* frame = document().frame();
784         if (frame && frame->loader().subframeLoader().allowPlugins(NotAboutToInstantiatePlugin))
785             return false;
786     }
787     return StyledElement::rendererIsNeeded(style);
788 }
789
790 RenderElement* HTMLElement::createRenderer(RenderArena& arena, RenderStyle& style)
791 {
792     if (hasLocalName(wbrTag))
793         return new (arena) RenderLineBreak(*this);
794     return RenderElement::createFor(*this, style);
795 }
796
797 HTMLFormElement* HTMLElement::virtualForm() const
798 {
799     return HTMLFormElement::findClosestFormAncestor(*this);
800 }
801
802 static inline bool elementAffectsDirectionality(const Node* node)
803 {
804     return node->isHTMLElement() && (node->hasTagName(bdiTag) || toHTMLElement(node)->hasAttribute(dirAttr));
805 }
806
807 static void setHasDirAutoFlagRecursively(Node* firstNode, bool flag, Node* lastNode = 0)
808 {
809     firstNode->setSelfOrAncestorHasDirAutoAttribute(flag);
810
811     Node* node = firstNode->firstChild();
812
813     while (node) {
814         if (node->selfOrAncestorHasDirAutoAttribute() == flag)
815             return;
816
817         if (elementAffectsDirectionality(node)) {
818             if (node == lastNode)
819                 return;
820             node = NodeTraversal::nextSkippingChildren(node, firstNode);
821             continue;
822         }
823         node->setSelfOrAncestorHasDirAutoAttribute(flag);
824         if (node == lastNode)
825             return;
826         node = NodeTraversal::next(node, firstNode);
827     }
828 }
829
830 void HTMLElement::childrenChanged(const ChildChange& change)
831 {
832     StyledElement::childrenChanged(change);
833     adjustDirectionalityIfNeededAfterChildrenChanged(change.previousSiblingElement, change.type);
834 }
835
836 bool HTMLElement::hasDirectionAuto() const
837 {
838     const AtomicString& direction = fastGetAttribute(dirAttr);
839     return (hasTagName(bdiTag) && direction == nullAtom) || equalIgnoringCase(direction, "auto");
840 }
841
842 TextDirection HTMLElement::directionalityIfhasDirAutoAttribute(bool& isAuto) const
843 {
844     if (!(selfOrAncestorHasDirAutoAttribute() && hasDirectionAuto())) {
845         isAuto = false;
846         return LTR;
847     }
848
849     isAuto = true;
850     return directionality();
851 }
852
853 TextDirection HTMLElement::directionality(Node** strongDirectionalityTextNode) const
854 {
855     if (isHTMLTextFormControlElement(this)) {
856         HTMLTextFormControlElement* textElement = toHTMLTextFormControlElement(const_cast<HTMLElement*>(this));
857         bool hasStrongDirectionality;
858         Unicode::Direction textDirection = textElement->value().defaultWritingDirection(&hasStrongDirectionality);
859         if (strongDirectionalityTextNode)
860             *strongDirectionalityTextNode = hasStrongDirectionality ? textElement : 0;
861         return (textDirection == Unicode::LeftToRight) ? LTR : RTL;
862     }
863
864     Node* node = firstChild();
865     while (node) {
866         // Skip bdi, script, style and text form controls.
867         if (equalIgnoringCase(node->nodeName(), "bdi") || node->hasTagName(scriptTag) || node->hasTagName(styleTag) 
868             || (node->isElementNode() && toElement(node)->isTextFormControl())) {
869             node = NodeTraversal::nextSkippingChildren(node, this);
870             continue;
871         }
872
873         // Skip elements with valid dir attribute
874         if (node->isElementNode()) {
875             AtomicString dirAttributeValue = toElement(node)->fastGetAttribute(dirAttr);
876             if (equalIgnoringCase(dirAttributeValue, "rtl") || equalIgnoringCase(dirAttributeValue, "ltr") || equalIgnoringCase(dirAttributeValue, "auto")) {
877                 node = NodeTraversal::nextSkippingChildren(node, this);
878                 continue;
879             }
880         }
881
882         if (node->isTextNode()) {
883             bool hasStrongDirectionality;
884             WTF::Unicode::Direction textDirection = node->textContent(true).defaultWritingDirection(&hasStrongDirectionality);
885             if (hasStrongDirectionality) {
886                 if (strongDirectionalityTextNode)
887                     *strongDirectionalityTextNode = node;
888                 return (textDirection == WTF::Unicode::LeftToRight) ? LTR : RTL;
889             }
890         }
891         node = NodeTraversal::next(node, this);
892     }
893     if (strongDirectionalityTextNode)
894         *strongDirectionalityTextNode = 0;
895     return LTR;
896 }
897
898 void HTMLElement::dirAttributeChanged(const AtomicString& value)
899 {
900     Element* parent = parentElement();
901
902     if (parent && parent->isHTMLElement() && parent->selfOrAncestorHasDirAutoAttribute())
903         toHTMLElement(parent)->adjustDirectionalityIfNeededAfterChildAttributeChanged(this);
904
905     if (equalIgnoringCase(value, "auto"))
906         calculateAndAdjustDirectionality();
907 }
908
909 void HTMLElement::adjustDirectionalityIfNeededAfterChildAttributeChanged(Element* child)
910 {
911     ASSERT(selfOrAncestorHasDirAutoAttribute());
912     Node* strongDirectionalityTextNode;
913     TextDirection textDirection = directionality(&strongDirectionalityTextNode);
914     setHasDirAutoFlagRecursively(child, false);
915     if (!renderer() || !renderer()->style() || renderer()->style()->direction() == textDirection)
916         return;
917     auto lineage = elementLineage(this);
918     for (auto elementToAdjust = lineage.begin(), end = lineage.end(); elementToAdjust != end; ++elementToAdjust) {
919         if (elementAffectsDirectionality(&*elementToAdjust)) {
920             elementToAdjust->setNeedsStyleRecalc();
921             return;
922         }
923     }
924 }
925
926 void HTMLElement::calculateAndAdjustDirectionality()
927 {
928     Node* strongDirectionalityTextNode;
929     TextDirection textDirection = directionality(&strongDirectionalityTextNode);
930     setHasDirAutoFlagRecursively(this, true, strongDirectionalityTextNode);
931     if (renderer() && renderer()->style() && renderer()->style()->direction() != textDirection)
932         setNeedsStyleRecalc();
933 }
934
935 void HTMLElement::adjustDirectionalityIfNeededAfterChildrenChanged(Element* beforeChange, ChildChangeType changeType)
936 {
937     // FIXME: This function looks suspicious.
938     if (document().renderView() && (changeType == ElementRemoved || changeType == TextRemoved)) {
939         Node* node = beforeChange ? beforeChange->nextSibling() : 0;
940         for (; node; node = node->nextSibling()) {
941             if (elementAffectsDirectionality(node))
942                 continue;
943
944             setHasDirAutoFlagRecursively(node, false);
945         }
946     }
947
948     if (!selfOrAncestorHasDirAutoAttribute())
949         return;
950
951     Node* oldMarkedNode = 0;
952     if (beforeChange)
953         oldMarkedNode = changeType == ElementInserted ? ElementTraversal::nextSibling(beforeChange) : beforeChange->nextSibling();
954
955     while (oldMarkedNode && elementAffectsDirectionality(oldMarkedNode))
956         oldMarkedNode = oldMarkedNode->nextSibling();
957     if (oldMarkedNode)
958         setHasDirAutoFlagRecursively(oldMarkedNode, false);
959
960     auto lineage = lineageOfType<HTMLElement>(this);
961     for (auto elementToAdjust = lineage.begin(), end = lineage.end(); elementToAdjust != end; ++elementToAdjust) {
962         if (elementAffectsDirectionality(&*elementToAdjust)) {
963             elementToAdjust->calculateAndAdjustDirectionality();
964             return;
965         }
966     }
967 }
968
969 bool HTMLElement::isURLAttribute(const Attribute& attribute) const
970 {
971     return StyledElement::isURLAttribute(attribute);
972 }
973
974 void HTMLElement::addHTMLLengthToStyle(MutableStylePropertySet* style, CSSPropertyID propertyID, const String& value)
975 {
976     // FIXME: This function should not spin up the CSS parser, but should instead just figure out the correct
977     // length unit and make the appropriate parsed value.
978
979     // strip attribute garbage..
980     StringImpl* v = value.impl();
981     if (v) {
982         unsigned int l = 0;
983
984         while (l < v->length() && (*v)[l] <= ' ')
985             l++;
986
987         for (; l < v->length(); l++) {
988             UChar cc = (*v)[l];
989             if (cc > '9')
990                 break;
991             if (cc < '0') {
992                 if (cc == '%' || cc == '*')
993                     l++;
994                 if (cc != '.')
995                     break;
996             }
997         }
998
999         if (l != v->length()) {
1000             addPropertyToPresentationAttributeStyle(style, propertyID, v->substring(0, l));
1001             return;
1002         }
1003     }
1004
1005     addPropertyToPresentationAttributeStyle(style, propertyID, value);
1006 }
1007
1008 static RGBA32 parseColorStringWithCrazyLegacyRules(const String& colorString)
1009 {
1010     // Per spec, only look at the first 128 digits of the string.
1011     const size_t maxColorLength = 128;
1012     // We'll pad the buffer with two extra 0s later, so reserve two more than the max.
1013     Vector<char, maxColorLength+2> digitBuffer;
1014
1015     size_t i = 0;
1016     // Skip a leading #.
1017     if (colorString[0] == '#')
1018         i = 1;
1019
1020     // Grab the first 128 characters, replacing non-hex characters with 0.
1021     // Non-BMP characters are replaced with "00" due to them appearing as two "characters" in the String.
1022     for (; i < colorString.length() && digitBuffer.size() < maxColorLength; i++) {
1023         if (!isASCIIHexDigit(colorString[i]))
1024             digitBuffer.append('0');
1025         else
1026             digitBuffer.append(colorString[i]);
1027     }
1028
1029     if (!digitBuffer.size())
1030         return Color::black;
1031
1032     // Pad the buffer out to at least the next multiple of three in size.
1033     digitBuffer.append('0');
1034     digitBuffer.append('0');
1035
1036     if (digitBuffer.size() < 6)
1037         return makeRGB(toASCIIHexValue(digitBuffer[0]), toASCIIHexValue(digitBuffer[1]), toASCIIHexValue(digitBuffer[2]));
1038
1039     // Split the digits into three components, then search the last 8 digits of each component.
1040     ASSERT(digitBuffer.size() >= 6);
1041     size_t componentLength = digitBuffer.size() / 3;
1042     size_t componentSearchWindowLength = min<size_t>(componentLength, 8);
1043     size_t redIndex = componentLength - componentSearchWindowLength;
1044     size_t greenIndex = componentLength * 2 - componentSearchWindowLength;
1045     size_t blueIndex = componentLength * 3 - componentSearchWindowLength;
1046     // Skip digits until one of them is non-zero, or we've only got two digits left in the component.
1047     while (digitBuffer[redIndex] == '0' && digitBuffer[greenIndex] == '0' && digitBuffer[blueIndex] == '0' && (componentLength - redIndex) > 2) {
1048         redIndex++;
1049         greenIndex++;
1050         blueIndex++;
1051     }
1052     ASSERT(redIndex + 1 < componentLength);
1053     ASSERT(greenIndex >= componentLength);
1054     ASSERT(greenIndex + 1 < componentLength * 2);
1055     ASSERT(blueIndex >= componentLength * 2);
1056     ASSERT_WITH_SECURITY_IMPLICATION(blueIndex + 1 < digitBuffer.size());
1057
1058     int redValue = toASCIIHexValue(digitBuffer[redIndex], digitBuffer[redIndex + 1]);
1059     int greenValue = toASCIIHexValue(digitBuffer[greenIndex], digitBuffer[greenIndex + 1]);
1060     int blueValue = toASCIIHexValue(digitBuffer[blueIndex], digitBuffer[blueIndex + 1]);
1061     return makeRGB(redValue, greenValue, blueValue);
1062 }
1063
1064 // Color parsing that matches HTML's "rules for parsing a legacy color value"
1065 void HTMLElement::addHTMLColorToStyle(MutableStylePropertySet* style, CSSPropertyID propertyID, const String& attributeValue)
1066 {
1067     // An empty string doesn't apply a color. (One containing only whitespace does, which is why this check occurs before stripping.)
1068     if (attributeValue.isEmpty())
1069         return;
1070
1071     String colorString = attributeValue.stripWhiteSpace();
1072
1073     // "transparent" doesn't apply a color either.
1074     if (equalIgnoringCase(colorString, "transparent"))
1075         return;
1076
1077     // If the string is a named CSS color or a 3/6-digit hex color, use that.
1078     Color parsedColor(colorString);
1079     if (!parsedColor.isValid())
1080         parsedColor.setRGB(parseColorStringWithCrazyLegacyRules(colorString));
1081
1082     style->setProperty(propertyID, cssValuePool().createColorValue(parsedColor.rgb()));
1083 }
1084
1085 } // namespace WebCore
1086
1087 #ifndef NDEBUG
1088
1089 // For use in the debugger
1090 void dumpInnerHTML(WebCore::HTMLElement*);
1091
1092 void dumpInnerHTML(WebCore::HTMLElement* element)
1093 {
1094     printf("%s\n", element->innerHTML().ascii().data());
1095 }
1096 #endif