Use "= default" to denote default constructor or destructor
[WebKit-https.git] / Source / WebCore / html / HTMLBodyElement.cpp
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
4  *           (C) 2000 Simon Hausmann (hausmann@kde.org)
5  *           (C) 2001 Dirk Mueller (mueller@kde.org)
6  * Copyright (C) 2004-2017 Apple Inc. 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 #include "config.h"
25 #include "HTMLBodyElement.h"
26
27 #include "CSSImageValue.h"
28 #include "CSSParser.h"
29 #include "CSSValueKeywords.h"
30 #include "DOMWindow.h"
31 #include "DOMWrapperWorld.h"
32 #include "EventNames.h"
33 #include "Frame.h"
34 #include "FrameView.h"
35 #include "HTMLFrameElement.h"
36 #include "HTMLIFrameElement.h"
37 #include "HTMLNames.h"
38 #include "HTMLParserIdioms.h"
39 #include "StyleProperties.h"
40 #include <wtf/NeverDestroyed.h>
41
42 namespace WebCore {
43
44 using namespace HTMLNames;
45
46 HTMLBodyElement::HTMLBodyElement(const QualifiedName& tagName, Document& document)
47     : HTMLElement(tagName, document)
48 {
49     ASSERT(hasTagName(bodyTag));
50 }
51
52 bool HTMLBodyElement::isFirstBodyElementOfDocument() const
53 {
54     // By spec http://dev.w3.org/csswg/cssom-view/#the-html-body-element
55     // "The HTML body element is the first body HTML element child of the root HTML element html."
56     return document().body() == this;
57 }
58
59 Ref<HTMLBodyElement> HTMLBodyElement::create(Document& document)
60 {
61     return adoptRef(*new HTMLBodyElement(bodyTag, document));
62 }
63
64 Ref<HTMLBodyElement> HTMLBodyElement::create(const QualifiedName& tagName, Document& document)
65 {
66     return adoptRef(*new HTMLBodyElement(tagName, document));
67 }
68
69 HTMLBodyElement::~HTMLBodyElement() = default;
70
71 bool HTMLBodyElement::isPresentationAttribute(const QualifiedName& name) const
72 {
73     if (name == backgroundAttr || name == marginwidthAttr || name == leftmarginAttr || name == marginheightAttr || name == topmarginAttr || name == bgcolorAttr || name == textAttr || name == bgpropertiesAttr)
74         return true;
75     return HTMLElement::isPresentationAttribute(name);
76 }
77
78 void HTMLBodyElement::collectStyleForPresentationAttribute(const QualifiedName& name, const AtomicString& value, MutableStyleProperties& style)
79 {
80     if (name == backgroundAttr) {
81         String url = stripLeadingAndTrailingHTMLSpaces(value);
82         if (!url.isEmpty()) {
83             auto imageValue = CSSImageValue::create(document().completeURL(url));
84             imageValue.get().setInitiator(localName());
85             style.setProperty(CSSProperty(CSSPropertyBackgroundImage, WTFMove(imageValue)));
86         }
87     } else if (name == marginwidthAttr || name == leftmarginAttr) {
88         addHTMLLengthToStyle(style, CSSPropertyMarginRight, value);
89         addHTMLLengthToStyle(style, CSSPropertyMarginLeft, value);
90     } else if (name == marginheightAttr || name == topmarginAttr) {
91         addHTMLLengthToStyle(style, CSSPropertyMarginBottom, value);
92         addHTMLLengthToStyle(style, CSSPropertyMarginTop, value);
93     } else if (name == bgcolorAttr) {
94         addHTMLColorToStyle(style, CSSPropertyBackgroundColor, value);
95     } else if (name == textAttr) {
96         addHTMLColorToStyle(style, CSSPropertyColor, value);
97     } else if (name == bgpropertiesAttr) {
98         if (equalLettersIgnoringASCIICase(value, "fixed"))
99            addPropertyToPresentationAttributeStyle(style, CSSPropertyBackgroundAttachment, CSSValueFixed);
100     } else
101         HTMLElement::collectStyleForPresentationAttribute(name, value, style);
102 }
103
104 HTMLElement::EventHandlerNameMap HTMLBodyElement::createWindowEventHandlerNameMap()
105 {
106     static const QualifiedName* const table[] = {
107         &onbeforeunloadAttr,
108         &onblurAttr,
109         &onerrorAttr,
110         &onfocusAttr,
111         &onfocusinAttr,
112         &onfocusoutAttr,
113         &onhashchangeAttr,
114         &onlanguagechangeAttr,
115         &onloadAttr,
116         &onmessageAttr,
117         &onofflineAttr,
118         &ononlineAttr,
119         &onorientationchangeAttr,
120         &onpagehideAttr,
121         &onpageshowAttr,
122         &onpopstateAttr,
123         &onresizeAttr,
124         &onscrollAttr,
125         &onstorageAttr,
126         &onunloadAttr,
127         &onwebkitmouseforcechangedAttr,
128         &onwebkitmouseforcedownAttr,
129         &onwebkitmouseforceupAttr,
130         &onwebkitmouseforcewillbeginAttr,
131         &onwebkitwillrevealbottomAttr,
132         &onwebkitwillrevealleftAttr,
133         &onwebkitwillrevealrightAttr,
134         &onwebkitwillrevealtopAttr,
135     };
136
137     EventHandlerNameMap map;
138     populateEventHandlerNameMap(map, table);
139     return map;
140 }
141
142 const AtomicString& HTMLBodyElement::eventNameForWindowEventHandlerAttribute(const QualifiedName& attributeName)
143 {
144     static NeverDestroyed<EventHandlerNameMap> map = createWindowEventHandlerNameMap();
145     return eventNameForEventHandlerAttribute(attributeName, map.get());
146 }
147
148 void HTMLBodyElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
149 {
150     if (name == vlinkAttr || name == alinkAttr || name == linkAttr) {
151         if (value.isNull()) {
152             if (name == linkAttr)
153                 document().resetLinkColor();
154             else if (name == vlinkAttr)
155                 document().resetVisitedLinkColor();
156             else
157                 document().resetActiveLinkColor();
158         } else {
159             Color color = CSSParser::parseColor(value, !document().inQuirksMode());
160             if (color.isValid()) {
161                 if (name == linkAttr)
162                     document().setLinkColor(color);
163                 else if (name == vlinkAttr)
164                     document().setVisitedLinkColor(color);
165                 else
166                     document().setActiveLinkColor(color);
167             }
168         }
169
170         invalidateStyleForSubtree();
171         return;
172     }
173
174     if (name == onselectionchangeAttr) {
175         document().setAttributeEventListener(eventNames().selectionchangeEvent, name, value, mainThreadNormalWorld());
176         return;
177     }
178
179     auto& eventName = eventNameForWindowEventHandlerAttribute(name);
180     if (!eventName.isNull()) {
181         document().setWindowAttributeEventListener(eventName, name, value, mainThreadNormalWorld());
182         return;
183     }
184
185     HTMLElement::parseAttribute(name, value);
186 }
187
188 Node::InsertedIntoResult HTMLBodyElement::insertedInto(InsertionType insertionType, ContainerNode& parentOfInsertedTree)
189 {
190     HTMLElement::insertedInto(insertionType, parentOfInsertedTree);
191     if (!insertionType.connectedToDocument)
192         return InsertedIntoResult::Done;
193
194     // FIXME: It's surprising this is web compatible since it means a marginwidth and marginheight attribute can
195     // magically appear on the <body> of all documents embedded through <iframe> or <frame>.
196     // FIXME: Perhaps this code should be in attach() instead of here.
197     auto* ownerElement = document().ownerElement();
198     if (!is<HTMLFrameElementBase>(ownerElement))
199         return InsertedIntoResult::Done;
200
201     return InsertedIntoResult::NeedsPostInsertionCallback;
202 }
203
204 void HTMLBodyElement::didFinishInsertingNode()
205 {
206     auto* ownerElement = document().ownerElement();
207     RELEASE_ASSERT(is<HTMLFrameElementBase>(ownerElement));
208     auto& ownerFrameElement = downcast<HTMLFrameElementBase>(*ownerElement);
209
210     // Read values from the owner before setting any attributes, since setting an attribute can run arbitrary
211     // JavaScript, which might delete the owner element.
212     int marginWidth = ownerFrameElement.marginWidth();
213     int marginHeight = ownerFrameElement.marginHeight();
214
215     if (marginWidth != -1)
216         setIntegralAttribute(marginwidthAttr, marginWidth);
217     if (marginHeight != -1)
218         setIntegralAttribute(marginheightAttr, marginHeight);
219 }
220
221 bool HTMLBodyElement::isURLAttribute(const Attribute& attribute) const
222 {
223     return attribute.name() == backgroundAttr || HTMLElement::isURLAttribute(attribute);
224 }
225
226 bool HTMLBodyElement::supportsFocus() const
227 {
228     return hasEditableStyle() || HTMLElement::supportsFocus();
229 }
230
231 static int adjustForZoom(int value, const Frame& frame)
232 {
233     double zoomFactor = frame.pageZoomFactor() * frame.frameScaleFactor();
234     if (zoomFactor == 1)
235         return value;
236     // Needed because of truncation (rather than rounding) when scaling up.
237     if (zoomFactor > 1)
238         value++;
239     return static_cast<int>(value / zoomFactor);
240 }
241
242 int HTMLBodyElement::scrollLeft()
243 {
244     if (isFirstBodyElementOfDocument()) {
245         document().updateLayoutIgnorePendingStylesheets();
246         RefPtr<Frame> frame = document().frame();
247         if (!frame)
248             return 0;
249         RefPtr<FrameView> view = frame->view();
250         if (!view)
251             return 0;
252         return adjustForZoom(view->contentsScrollPosition().x(), *frame);
253     }
254     return HTMLElement::scrollLeft();
255 }
256
257 void HTMLBodyElement::setScrollLeft(int scrollLeft)
258 {
259     if (isFirstBodyElementOfDocument()) {
260         document().updateLayoutIgnorePendingStylesheets();
261         RefPtr<Frame> frame = document().frame();
262         if (!frame)
263             return;
264         RefPtr<FrameView> view = frame->view();
265         if (!view)
266             return;
267         view->setScrollPosition(IntPoint(static_cast<int>(scrollLeft * frame->pageZoomFactor() * frame->frameScaleFactor()), view->scrollY()));
268     }
269     HTMLElement::setScrollLeft(scrollLeft);
270 }
271
272 int HTMLBodyElement::scrollTop()
273 {
274     if (isFirstBodyElementOfDocument()) {
275         document().updateLayoutIgnorePendingStylesheets();
276         RefPtr<Frame> frame = document().frame();
277         if (!frame)
278             return 0;
279         RefPtr<FrameView> view = frame->view();
280         if (!view)
281             return 0;
282         return adjustForZoom(view->contentsScrollPosition().y(), *frame);
283     }
284     return HTMLElement::scrollTop();
285 }
286
287 void HTMLBodyElement::setScrollTop(int scrollTop)
288 {
289     if (isFirstBodyElementOfDocument()) {
290         document().updateLayoutIgnorePendingStylesheets();
291         RefPtr<Frame> frame = document().frame();
292         if (!frame)
293             return;
294         RefPtr<FrameView> view = frame->view();
295         if (!view)
296             return;
297         view->setScrollPosition(IntPoint(view->scrollX(), static_cast<int>(scrollTop * frame->pageZoomFactor() * frame->frameScaleFactor())));
298     }
299     return HTMLElement::setScrollTop(scrollTop);
300 }
301
302 void HTMLBodyElement::scrollTo(const ScrollToOptions& options)
303 {
304     if (isFirstBodyElementOfDocument()) {
305         // If the element is the HTML body element, document is in quirks mode, and the element is not potentially scrollable,
306         // invoke scroll() on window with options as the only argument, and terminate these steps.
307         // Note that WebKit always uses quirks mode document scrolling behavior. See Document::scrollingElement().
308         // FIXME: Scrolling an independently scrollable body is broken: webkit.org/b/161612.
309         auto* window = document().domWindow();
310         if (!window)
311             return;
312
313         window->scrollTo(options);
314         return;
315     }
316     return HTMLElement::scrollTo(options);
317 }
318
319 int HTMLBodyElement::scrollHeight()
320 {
321     if (isFirstBodyElementOfDocument()) {
322         // Update the document's layout.
323         document().updateLayoutIgnorePendingStylesheets();
324         RefPtr<Frame> frame = document().frame();
325         if (!frame)
326             return 0;
327         RefPtr<FrameView> view = frame->view();
328         if (!view)
329             return 0;
330         return adjustForZoom(view->contentsHeight(), *frame);
331     }
332     return HTMLElement::scrollHeight();
333 }
334
335 int HTMLBodyElement::scrollWidth()
336 {
337     if (isFirstBodyElementOfDocument()) {
338         // Update the document's layout.
339         document().updateLayoutIgnorePendingStylesheets();
340         RefPtr<Frame> frame = document().frame();
341         if (!frame)
342             return 0;
343         RefPtr<FrameView> view = frame->view();
344         if (!view)
345             return 0;
346         return adjustForZoom(view->contentsWidth(), *frame);
347     }
348     return HTMLElement::scrollWidth();
349 }
350
351 void HTMLBodyElement::addSubresourceAttributeURLs(ListHashSet<URL>& urls) const
352 {
353     HTMLElement::addSubresourceAttributeURLs(urls);
354
355     addSubresourceURL(urls, document().completeURL(attributeWithoutSynchronization(backgroundAttr)));
356 }
357
358 } // namespace WebCore