Audit RenderObject casts and fix problems and style issues found
authordarin@apple.com <darin@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 2 Jun 2016 04:01:35 +0000 (04:01 +0000)
committerdarin@apple.com <darin@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 2 Jun 2016 04:01:35 +0000 (04:01 +0000)
https://bugs.webkit.org/show_bug.cgi?id=158221

Reviewed by Chris Dumez.

Source/WebCore:

* bindings/objc/DOM.mm:
(-[DOMElement image]): Use auto to get more specific types in code getting
the renderer for an element instead of dumbing down the type to RenderObject.

* dom/Element.cpp:
(WebCore::Element::scrollByUnits): Call renderer only once. The comment in
Node advises we should do this since it has a branch in it.
(WebCore::Element::absoluteEventBounds): Call renderer only once. Also use
auto for a rect type to clarify that we are not changing the type of the
rect returned by the fucntion.
(WebCore::Element::webkitGetRegionFlowRanges): Call renderer only once.

* editing/CompositeEditCommand.cpp:
(WebCore::CompositeEditCommand::addBlockPlaceholderIfNeeded): Use auto
to get a mroe specific renderer type.

* editing/SimplifyMarkupCommand.cpp:
(WebCore::SimplifyMarkupCommand::doApply): Call renderer only once.

* editing/cocoa/HTMLConverter.mm:
(HTMLConverter::_addAttachmentForElement): Add an obviously missing
null check for something that is null checked elsewhere.
(fileWrapperForURL): Ditto.
(fileWrapperForElement): Changed argument type to HTMLImageElement& since
the call site already checks the type of the object. Use HTMLImageElement::src
instead of repeating the code here. Check the type of the renderer instead of
assuming it's a RenderImage.
(WebCore::editingAttributedStringFromRange): Pass a reference, not a pointer.

* html/HTMLAnchorElement.cpp:
(WebCore::appendServerMapMousePosition): Take a reference to an event rather
than a "known to be non-null" pointer. Call renderer only once. Round the
floating point values rather than truncating them.
(WebCore::HTMLAnchorElement::handleClick): Pass a reference.

* html/HTMLAttachmentElement.cpp:
(WebCore::HTMLAttachmentElement::setFile): Removed the now-unneeded cast since
the renderer function returns a pointer of a more specific type now.
(WebCore::HTMLAttachmentElement::parseAttribute): Ditto.
(WebCore::HTMLAttachmentElement::attachmentTitle): Use auto& to avoid a bit of
reference count churn.

* html/HTMLAttachmentElement.h: Override renderer to return a more specific type.
This follows the pattern that ContainerNode::renderer uses.

* html/HTMLButtonElement.h: Ditto.

* html/HTMLCanvasElement.cpp: Gave the constants at the top of the file more
normal names. Removed unneeded "static" from them. Moved the
defaultInterpolationQuality constant here from the header because it doesn't
need to be there.
(WebCore::HTMLCanvasElement::HTMLCanvasElement): Updated for name changes.
(WebCore::HTMLCanvasElement::createElementRenderer): Removed unneeded code to
set m_rendererIsCanvas to record renderer type; we can just check the type.
(WebCore::HTMLCanvasElement::setHeight): Updated for name changes.
(WebCore::HTMLCanvasElement::setWidth): Ditto.
(WebCore::HTMLCanvasElement::reset): Check the type of the renderer directly
instead of calling m_rendererIsCanvas. This helped make it clear we were
do extra unneeded checks since a renderer can't both be a RenderCanvas and
not be a RenderBox.
(WebCore::HTMLCanvasElement::createImageBuffer): Updated for name changes.

* html/HTMLCanvasElement.h: Moved DefaultInterpolationQuality into the cpp file.
Use nullptr instead of 0. Removed m_rendererIsCanvas.

* html/HTMLFieldSetElement.cpp:
(WebCore::HTMLFieldSetElement::HTMLFieldSetElement): Initialize m_documentVersion
in the class definition.
(WebCore::HTMLFieldSetElement::~HTMLFieldSetElement): Use m_hasDisabledAttribute.
(WebCore::updateFromControlElementsAncestorDisabledStateUnder): Fixed typo.
(WebCore::HTMLFieldSetElement::disabledAttributeChanged): Fixed mistake in this
function that would cause the number of disabled fieldset elements to be too high
if the disabled attribute's value was changed from one value to another. Use a
boolean to track the old value; can't think of a solution that works without that.
(WebCore::HTMLFieldSetElement::childrenChanged): Fixed typo.
(WebCore::HTMLFieldSetElement::didMoveToNewDocument): Use m_hasDisabledAttribute.
(WebCore::HTMLFieldSetElement::updateAssociatedElements): Changed name to make it
clearer what this function does. Tweaked a bit without changing behavior.
(WebCore::HTMLFieldSetElement::associatedElements): Updated for name change.
(WebCore::HTMLFieldSetElement::length): Changed to call associatedElements instead of
repeating that it does.

* html/HTMLFieldSetElement.h: Override renderer to return a more specific type.
Also updated for other changes mentioned above.

* html/HTMLFrameElement.cpp:
(WebCore::HTMLFrameElement::HTMLFrameElement): Initialize booleans in the class
definition rather than doing it here.
(WebCore::HTMLFrameElement::parseAttribute): Call renderer only once.

* html/HTMLFrameElement.h: Override renderer to return a more specific type.
Also initialize some booleans in the class definition.

* html/HTMLIFrameElement.h: Override renderer to return a more specific type.

* html/HTMLMediaElement.cpp:
(WebCore::HTMLMediaElement::updateRenderer): Added. Helper for a common idiom.
(WebCore::HTMLMediaElement::didAttachRenderers): Use auto to get a more specific
type for the renderer.
(WebCore::HTMLMediaElement::willDetachRenderers): Call renderer only once.
(WebCore::HTMLMediaElement::didRecalcStyle): Use updateRenderer to call renderer
only once.
(WebCore::HTMLMediaElement::loadResource): Ditto.
(WebCore::HTMLMediaElement::waitForSourceChange): Ditto.
(WebCore::HTMLMediaElement::noneSupported): Ditto.
(WebCore::HTMLMediaElement::setReadyState): Ditto.
(WebCore::HTMLMediaElement::progressEventTimerFired): Ditto.
(WebCore::HTMLMediaElement::selectNextSourceChild): Renamed goto label to use a style
that fits WebKit coding style. Call renderer only once in MediaQuery code.
(WebCore::HTMLMediaElement::mediaPlayerRepaint): Call renderer only once.
(WebCore::HTMLMediaElement::mediaPlayerSizeChanged): Use updateRenderer to call
renderer only once.
(WebCore::HTMLMediaElement::mediaPlayerRenderingCanBeAccelerated): Call renderer
only once.
(WebCore::HTMLMediaElement::mediaPlayerGraphicsDeviceAdapter): Call page only once.
(WebCore::HTMLMediaElement::mediaEngineWasUpdated): Use updateRenderer to call
renderer only once.
(WebCore::HTMLMediaElement::mediaPlayerCharacteristicChanged): Ditto.
(WebCore::HTMLMediaElement::updatePlayState): Ditto.
(WebCore::HTMLMediaElement::stopWithoutDestroyingMediaPlayer): Ditto.
(WebCore::HTMLMediaElement::resume): Ditto.
(WebCore::HTMLMediaElement::mediaPlayerContentBoxRect): Call renderer only once.
(WebCore::mediaElementIsAllowedToAutoplay): Use auto to get a more specific type.

* html/HTMLMediaElement.h: Removed conditionals around forward declarations.
Tweaked formatting a bit. Added the updateRender function. Override renderer to
return a more specific type.

* html/HTMLSelectElement.cpp:
(WebCore::HTMLSelectElement::optionElementChildrenChanged): Don't use the renderer
just to get to the document for the AXObjectCache.
(WebCore::HTMLSelectElement::setLength): Use auto for the list items vector.
(WebCore::HTMLSelectElement::nextValidIndex): Ditto.
(WebCore::HTMLSelectElement::firstSelectableListIndex): Ditto.
(WebCore::HTMLSelectElement::nextSelectableListIndexPageAway): Ditto. Also add a
null check for the renderer.
(WebCore::HTMLSelectElement::updateListBoxSelection): Split an assertion with &&
in it into two separate assertions. Use auto for the list items vector and use
a reference for the list items.
(WebCore::HTMLSelectElement::listBoxOnChange): Use auto for the list items vector
and use a reference for the list items.
(WebCore::HTMLSelectElement::setRecalcListItems): Don't use the renderer
just to get to the document for the AXObjectCache.
(WebCore::HTMLSelectElement::selectOption): Use auto for the list items vector.
(WebCore::HTMLSelectElement::optionToListIndex): Ditto.
(WebCore::HTMLSelectElement::listToOptionIndex): Ditto.
(WebCore::HTMLSelectElement::searchOptionsForValue): Ditto.
(WebCore::HTMLSelectElement::restoreFormControlState): Ditto.
(WebCore::HTMLSelectElement::platformHandleKeydownEvent): Call renderer only once.
(WebCore::HTMLSelectElement::menuListDefaultEventHandler): Split an assertion with
&& in it into two separate assertions. Use auto for the list items vector. Call
renderer only once.
(WebCore::HTMLSelectElement::updateSelectedState): Use a reference for the list
item.
(WebCore::HTMLSelectElement::listBoxDefaultEventHandler): Use auto for the list
items vvector. Call renderer less often; could not quite get it down to once.
(WebCore::HTMLSelectElement::defaultEventHandler): Call renderer only once.
(WebCore::HTMLSelectElement::lastSelectedListIndex): Use auto for the list items
vector and use a reference for the list items.
(WebCore::HTMLSelectElement::optionAtIndex): Use a reference for the list item.
(WebCore::HTMLSelectElement::accessKeySetSelectedIndex): Use auto for the list
items vector and use a reference for the list items.
(WebCore::HTMLSelectElement::length): Use auto for the list items vector.

* html/HTMLTextAreaElement.h: Override renderer to return a more specific type.

* html/HTMLVideoElement.cpp:
(WebCore::HTMLVideoElement::didAttachRenderers): Call renderer only once and
don't downcast it. There was no obvious type check because the renderer has a
guaranteed type, but this is now clearer because it's the renderer function
that returns a more specific type.
(WebCore::HTMLVideoElement::parseAttribute): Ditto.
(WebCore::HTMLVideoElement::setDisplayMode): Ditto.

* html/HTMLVideoElement.h: Override renderer to return a more specific type.
* html/HTMLWBRElement.h: Ditto.

* html/MediaElementSession.cpp:
(WebCore::MediaElementSession::canControlControlsManager): Removed
unneeded typecast in code that null checks a renderer.
(WebCore::isMainContent): Remove now-unneeded downcast of a renderer
obtained from an HTMLMediaElement. Fixed awkward formatting by splitting
an if statement into two.
(WebCore::isElementLargeEnoughForMainContent): Remove now unneeded downcast
of a renderer obtained from an HTMLMediaElement.

* html/TextFieldInputType.cpp:
(WebCore::TextFieldInputType::forwardEvent): Call renderer only once.
Also use auto more in the code rather than writing out types.

* html/shadow/SliderThumbElement.cpp:
(WebCore::SliderThumbElement::setPositionFromPoint): Used the renderBox
function more consistently for all the renderers used here; before,
some had null checks and others did not.

* html/shadow/TextControlInnerElements.cpp:
(WebCore::SearchFieldResultsButtonElement::defaultEventHandler): Use auto
a bit more.

* page/EventHandler.cpp:
(WebCore::enclosingScrollableArea): Removed a redundant null check and
stopped using the name "element" for a local variable that was not
always an element.

* page/PrintContext.cpp:
(WebCore::enclosingBoxModelObject): Rewrote loop to be simpler and tighter.
Also marked this inline since it's used only one place.
(WebCore::PrintContext::pageNumberForElement): Use auto for the return
value rather than writing out the type.

* page/SpatialNavigation.cpp:
(WebCore::isScrollableNode): Tighten the code and use auto a bit.

* platform/ios/WebVideoFullscreenControllerAVKit.mm: Add an include of
RenderVideo.h since this gets at the renderer for a video.

* rendering/RenderAttachment.h:
(WebCore::HTMLAttachmentElement::renderer): Added. Function is here because
it can only be called by code that includes this header. This matches the
pattern of RenderElement.h and ContainerNode::renderer.

* rendering/RenderFrame.cpp: Added now-needed include.

* rendering/RenderFrame.h:
(WebCore::HTMLFrameElement::renderer): Added. Same logic as above.

* rendering/RenderLayerFilterInfo.cpp:
(WebCore::RenderLayer::FilterInfo::updateReferenceFilterClients): Use auto
a bit and call rendeer only once.

* rendering/RenderMedia.h:
(WebCore::HTMLMediaElement::renderer): Added. Same logic as above.
* rendering/RenderTextControlMultiLine.h:
(WebCore::HTMLTextAreaElement::renderer): Ditto.

* rendering/RenderVideo.cpp:
(WebCore::placeholder): Renamed. Tightened up argument type to match what
is passed at all the call sites. Use auto instead of RenderObject.
(WebCore::RenderVideo::offsetLeft): Use auto and the renamed function above.
(WebCore::RenderVideo::offsetTop): Ditto.
(WebCore::RenderVideo::offsetWidth): Ditto.
(WebCore::RenderVideo::offsetHeight): Ditto.

* rendering/RenderVideo.h:
(WebCore::HTMLVideoElement::renderer): Added. Same logic as above.

* svg/SVGGElement.cpp:
(WebCore::SVGGElement::createElementRenderer): Fixed typo.

* svg/SVGGraphicsElement.cpp:
(WebCore::SVGGraphicsElement::createElementRenderer): Removed
non-helpful oblique comment.
* svg/SVGPathElement.cpp:
(WebCore::SVGPathElement::createElementRenderer): Ditto.

Source/WebKit/mac:

* Misc/WebNSPasteboardExtras.mm:
(imageFromElement): Use auto and tighten the logic a bit.
(-[NSPasteboard _web_declareAndWriteDragImageForElement:URL:title:archive:source:]):
Use auto and added a comment about this not using imageFromElement.

* Plugins/WebBaseNetscapePluginView.mm:
(-[WebBaseNetscapePluginView _windowClipRect]): Consistently cast to
RenderEmbeddedObject, which is the class used for renderers for plug-ins.
(-[WebBaseNetscapePluginView inFlatteningPaint]): Ditto.
(-[WebBaseNetscapePluginView invalidatePluginContentRect:]): Ditto.
(-[WebBaseNetscapePluginView actualVisibleRectInWindow]): Ditto.

* WebCoreSupport/WebFrameLoaderClient.mm:
(WebFrameLoaderClient::createPlugin): Changed code so it does a null check
rather than assuming the renderer is non-null.
(WebFrameLoaderClient::createJavaAppletWidget): Ditto.

Source/WebKit2:

* Shared/WebRenderObject.cpp:
(WebKit::WebRenderObject::WebRenderObject): Tightened up the code that
builds the tree of objects; fewer local variables.

* WebProcess/Plugins/PluginView.cpp:
(WebKit::PluginView::invalidateRect): Cast to RenderEmbeddedObject since
that is the class used for plug-ins.
(WebKit::PluginView::pluginProcessCrashed): Ditto.
* WebProcess/WebPage/WebPage.cpp:
(WebKit::WebPage::createPlugin): Ditto.
(WebKit::WebPage::plugInIsPrimarySize): Check the renderer for null here.
Did not change this to RenderEmbeddedObject, though, because I wasn't
absolute certain this is only called with that type of renderer.

* WebProcess/WebPage/ios/WebPageIOS.mm:
(WebKit::WebPage::rangeForWebSelectionAtPosition): Tweaked.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@201588 268f45cc-cd09-0410-ab3c-d52691b4dbfc

52 files changed:
Source/WebCore/ChangeLog
Source/WebCore/bindings/objc/DOM.mm
Source/WebCore/dom/Element.cpp
Source/WebCore/editing/CompositeEditCommand.cpp
Source/WebCore/editing/SimplifyMarkupCommand.cpp
Source/WebCore/editing/cocoa/HTMLConverter.mm
Source/WebCore/html/HTMLAnchorElement.cpp
Source/WebCore/html/HTMLAttachmentElement.cpp
Source/WebCore/html/HTMLAttachmentElement.h
Source/WebCore/html/HTMLButtonElement.h
Source/WebCore/html/HTMLCanvasElement.cpp
Source/WebCore/html/HTMLCanvasElement.h
Source/WebCore/html/HTMLFieldSetElement.cpp
Source/WebCore/html/HTMLFieldSetElement.h
Source/WebCore/html/HTMLFrameElement.cpp
Source/WebCore/html/HTMLFrameElement.h
Source/WebCore/html/HTMLIFrameElement.h
Source/WebCore/html/HTMLMediaElement.cpp
Source/WebCore/html/HTMLMediaElement.h
Source/WebCore/html/HTMLSelectElement.cpp
Source/WebCore/html/HTMLTextAreaElement.h
Source/WebCore/html/HTMLVideoElement.cpp
Source/WebCore/html/HTMLVideoElement.h
Source/WebCore/html/HTMLWBRElement.h
Source/WebCore/html/MediaElementSession.cpp
Source/WebCore/html/TextFieldInputType.cpp
Source/WebCore/html/shadow/SliderThumbElement.cpp
Source/WebCore/html/shadow/TextControlInnerElements.cpp
Source/WebCore/page/EventHandler.cpp
Source/WebCore/page/PrintContext.cpp
Source/WebCore/page/SpatialNavigation.cpp
Source/WebCore/platform/ios/WebVideoFullscreenControllerAVKit.mm
Source/WebCore/rendering/RenderAttachment.h
Source/WebCore/rendering/RenderFrame.cpp
Source/WebCore/rendering/RenderFrame.h
Source/WebCore/rendering/RenderLayerFilterInfo.cpp
Source/WebCore/rendering/RenderMedia.h
Source/WebCore/rendering/RenderTextControlMultiLine.h
Source/WebCore/rendering/RenderVideo.cpp
Source/WebCore/rendering/RenderVideo.h
Source/WebCore/svg/SVGGElement.cpp
Source/WebCore/svg/SVGGraphicsElement.cpp
Source/WebCore/svg/SVGPathElement.cpp
Source/WebKit/mac/ChangeLog
Source/WebKit/mac/Misc/WebNSPasteboardExtras.mm
Source/WebKit/mac/Plugins/WebBaseNetscapePluginView.mm
Source/WebKit/mac/WebCoreSupport/WebFrameLoaderClient.mm
Source/WebKit2/ChangeLog
Source/WebKit2/Shared/WebRenderObject.cpp
Source/WebKit2/WebProcess/Plugins/PluginView.cpp
Source/WebKit2/WebProcess/WebPage/WebPage.cpp
Source/WebKit2/WebProcess/WebPage/ios/WebPageIOS.mm

index 658a4d8..80a0369 100644 (file)
@@ -1,3 +1,265 @@
+2016-05-31  Darin Adler  <darin@apple.com>
+
+        Audit RenderObject casts and fix problems and style issues found
+        https://bugs.webkit.org/show_bug.cgi?id=158221
+
+        Reviewed by Chris Dumez.
+
+        * bindings/objc/DOM.mm:
+        (-[DOMElement image]): Use auto to get more specific types in code getting
+        the renderer for an element instead of dumbing down the type to RenderObject.
+
+        * dom/Element.cpp:
+        (WebCore::Element::scrollByUnits): Call renderer only once. The comment in
+        Node advises we should do this since it has a branch in it.
+        (WebCore::Element::absoluteEventBounds): Call renderer only once. Also use
+        auto for a rect type to clarify that we are not changing the type of the
+        rect returned by the fucntion.
+        (WebCore::Element::webkitGetRegionFlowRanges): Call renderer only once.
+
+        * editing/CompositeEditCommand.cpp:
+        (WebCore::CompositeEditCommand::addBlockPlaceholderIfNeeded): Use auto
+        to get a mroe specific renderer type.
+
+        * editing/SimplifyMarkupCommand.cpp:
+        (WebCore::SimplifyMarkupCommand::doApply): Call renderer only once.
+
+        * editing/cocoa/HTMLConverter.mm:
+        (HTMLConverter::_addAttachmentForElement): Add an obviously missing
+        null check for something that is null checked elsewhere.
+        (fileWrapperForURL): Ditto.
+        (fileWrapperForElement): Changed argument type to HTMLImageElement& since
+        the call site already checks the type of the object. Use HTMLImageElement::src
+        instead of repeating the code here. Check the type of the renderer instead of
+        assuming it's a RenderImage.
+        (WebCore::editingAttributedStringFromRange): Pass a reference, not a pointer.
+
+        * html/HTMLAnchorElement.cpp:
+        (WebCore::appendServerMapMousePosition): Take a reference to an event rather
+        than a "known to be non-null" pointer. Call renderer only once. Round the
+        floating point values rather than truncating them.
+        (WebCore::HTMLAnchorElement::handleClick): Pass a reference.
+
+        * html/HTMLAttachmentElement.cpp:
+        (WebCore::HTMLAttachmentElement::setFile): Removed the now-unneeded cast since
+        the renderer function returns a pointer of a more specific type now.
+        (WebCore::HTMLAttachmentElement::parseAttribute): Ditto.
+        (WebCore::HTMLAttachmentElement::attachmentTitle): Use auto& to avoid a bit of
+        reference count churn.
+
+        * html/HTMLAttachmentElement.h: Override renderer to return a more specific type.
+        This follows the pattern that ContainerNode::renderer uses.
+
+        * html/HTMLButtonElement.h: Ditto.
+
+        * html/HTMLCanvasElement.cpp: Gave the constants at the top of the file more
+        normal names. Removed unneeded "static" from them. Moved the
+        defaultInterpolationQuality constant here from the header because it doesn't
+        need to be there.
+        (WebCore::HTMLCanvasElement::HTMLCanvasElement): Updated for name changes.
+        (WebCore::HTMLCanvasElement::createElementRenderer): Removed unneeded code to
+        set m_rendererIsCanvas to record renderer type; we can just check the type.
+        (WebCore::HTMLCanvasElement::setHeight): Updated for name changes.
+        (WebCore::HTMLCanvasElement::setWidth): Ditto.
+        (WebCore::HTMLCanvasElement::reset): Check the type of the renderer directly
+        instead of calling m_rendererIsCanvas. This helped make it clear we were
+        do extra unneeded checks since a renderer can't both be a RenderCanvas and
+        not be a RenderBox.
+        (WebCore::HTMLCanvasElement::createImageBuffer): Updated for name changes.
+
+        * html/HTMLCanvasElement.h: Moved DefaultInterpolationQuality into the cpp file.
+        Use nullptr instead of 0. Removed m_rendererIsCanvas.
+
+        * html/HTMLFieldSetElement.cpp:
+        (WebCore::HTMLFieldSetElement::HTMLFieldSetElement): Initialize m_documentVersion
+        in the class definition.
+        (WebCore::HTMLFieldSetElement::~HTMLFieldSetElement): Use m_hasDisabledAttribute.
+        (WebCore::updateFromControlElementsAncestorDisabledStateUnder): Fixed typo.
+        (WebCore::HTMLFieldSetElement::disabledAttributeChanged): Fixed mistake in this
+        function that would cause the number of disabled fieldset elements to be too high
+        if the disabled attribute's value was changed from one value to another. Use a
+        boolean to track the old value; can't think of a solution that works without that.
+        (WebCore::HTMLFieldSetElement::childrenChanged): Fixed typo.
+        (WebCore::HTMLFieldSetElement::didMoveToNewDocument): Use m_hasDisabledAttribute.
+        (WebCore::HTMLFieldSetElement::updateAssociatedElements): Changed name to make it
+        clearer what this function does. Tweaked a bit without changing behavior.
+        (WebCore::HTMLFieldSetElement::associatedElements): Updated for name change.
+        (WebCore::HTMLFieldSetElement::length): Changed to call associatedElements instead of
+        repeating that it does.
+
+        * html/HTMLFieldSetElement.h: Override renderer to return a more specific type.
+        Also updated for other changes mentioned above.
+
+        * html/HTMLFrameElement.cpp:
+        (WebCore::HTMLFrameElement::HTMLFrameElement): Initialize booleans in the class
+        definition rather than doing it here.
+        (WebCore::HTMLFrameElement::parseAttribute): Call renderer only once.
+
+        * html/HTMLFrameElement.h: Override renderer to return a more specific type.
+        Also initialize some booleans in the class definition.
+
+        * html/HTMLIFrameElement.h: Override renderer to return a more specific type.
+
+        * html/HTMLMediaElement.cpp:
+        (WebCore::HTMLMediaElement::updateRenderer): Added. Helper for a common idiom.
+        (WebCore::HTMLMediaElement::didAttachRenderers): Use auto to get a more specific
+        type for the renderer.
+        (WebCore::HTMLMediaElement::willDetachRenderers): Call renderer only once.
+        (WebCore::HTMLMediaElement::didRecalcStyle): Use updateRenderer to call renderer
+        only once.
+        (WebCore::HTMLMediaElement::loadResource): Ditto.
+        (WebCore::HTMLMediaElement::waitForSourceChange): Ditto.
+        (WebCore::HTMLMediaElement::noneSupported): Ditto.
+        (WebCore::HTMLMediaElement::setReadyState): Ditto.
+        (WebCore::HTMLMediaElement::progressEventTimerFired): Ditto.
+        (WebCore::HTMLMediaElement::selectNextSourceChild): Renamed goto label to use a style
+        that fits WebKit coding style. Call renderer only once in MediaQuery code.
+        (WebCore::HTMLMediaElement::mediaPlayerRepaint): Call renderer only once.
+        (WebCore::HTMLMediaElement::mediaPlayerSizeChanged): Use updateRenderer to call
+        renderer only once.
+        (WebCore::HTMLMediaElement::mediaPlayerRenderingCanBeAccelerated): Call renderer
+        only once.
+        (WebCore::HTMLMediaElement::mediaPlayerGraphicsDeviceAdapter): Call page only once.
+        (WebCore::HTMLMediaElement::mediaEngineWasUpdated): Use updateRenderer to call
+        renderer only once.
+        (WebCore::HTMLMediaElement::mediaPlayerCharacteristicChanged): Ditto.
+        (WebCore::HTMLMediaElement::updatePlayState): Ditto.
+        (WebCore::HTMLMediaElement::stopWithoutDestroyingMediaPlayer): Ditto.
+        (WebCore::HTMLMediaElement::resume): Ditto.
+        (WebCore::HTMLMediaElement::mediaPlayerContentBoxRect): Call renderer only once.
+        (WebCore::mediaElementIsAllowedToAutoplay): Use auto to get a more specific type.
+
+        * html/HTMLMediaElement.h: Removed conditionals around forward declarations.
+        Tweaked formatting a bit. Added the updateRender function. Override renderer to
+        return a more specific type.
+
+        * html/HTMLSelectElement.cpp:
+        (WebCore::HTMLSelectElement::optionElementChildrenChanged): Don't use the renderer
+        just to get to the document for the AXObjectCache.
+        (WebCore::HTMLSelectElement::setLength): Use auto for the list items vector.
+        (WebCore::HTMLSelectElement::nextValidIndex): Ditto.
+        (WebCore::HTMLSelectElement::firstSelectableListIndex): Ditto.
+        (WebCore::HTMLSelectElement::nextSelectableListIndexPageAway): Ditto. Also add a
+        null check for the renderer.
+        (WebCore::HTMLSelectElement::updateListBoxSelection): Split an assertion with &&
+        in it into two separate assertions. Use auto for the list items vector and use
+        a reference for the list items.
+        (WebCore::HTMLSelectElement::listBoxOnChange): Use auto for the list items vector
+        and use a reference for the list items.
+        (WebCore::HTMLSelectElement::setRecalcListItems): Don't use the renderer
+        just to get to the document for the AXObjectCache.
+        (WebCore::HTMLSelectElement::selectOption): Use auto for the list items vector.
+        (WebCore::HTMLSelectElement::optionToListIndex): Ditto.
+        (WebCore::HTMLSelectElement::listToOptionIndex): Ditto.
+        (WebCore::HTMLSelectElement::searchOptionsForValue): Ditto.
+        (WebCore::HTMLSelectElement::restoreFormControlState): Ditto.
+        (WebCore::HTMLSelectElement::platformHandleKeydownEvent): Call renderer only once.
+        (WebCore::HTMLSelectElement::menuListDefaultEventHandler): Split an assertion with
+        && in it into two separate assertions. Use auto for the list items vector. Call
+        renderer only once.
+        (WebCore::HTMLSelectElement::updateSelectedState): Use a reference for the list
+        item.
+        (WebCore::HTMLSelectElement::listBoxDefaultEventHandler): Use auto for the list
+        items vvector. Call renderer less often; could not quite get it down to once.
+        (WebCore::HTMLSelectElement::defaultEventHandler): Call renderer only once.
+        (WebCore::HTMLSelectElement::lastSelectedListIndex): Use auto for the list items
+        vector and use a reference for the list items.
+        (WebCore::HTMLSelectElement::optionAtIndex): Use a reference for the list item.
+        (WebCore::HTMLSelectElement::accessKeySetSelectedIndex): Use auto for the list
+        items vector and use a reference for the list items.
+        (WebCore::HTMLSelectElement::length): Use auto for the list items vector.
+
+        * html/HTMLTextAreaElement.h: Override renderer to return a more specific type.
+
+        * html/HTMLVideoElement.cpp:
+        (WebCore::HTMLVideoElement::didAttachRenderers): Call renderer only once and
+        don't downcast it. There was no obvious type check because the renderer has a
+        guaranteed type, but this is now clearer because it's the renderer function
+        that returns a more specific type.
+        (WebCore::HTMLVideoElement::parseAttribute): Ditto.
+        (WebCore::HTMLVideoElement::setDisplayMode): Ditto.
+
+        * html/HTMLVideoElement.h: Override renderer to return a more specific type.
+        * html/HTMLWBRElement.h: Ditto.
+
+        * html/MediaElementSession.cpp:
+        (WebCore::MediaElementSession::canControlControlsManager): Removed
+        unneeded typecast in code that null checks a renderer.
+        (WebCore::isMainContent): Remove now-unneeded downcast of a renderer
+        obtained from an HTMLMediaElement. Fixed awkward formatting by splitting
+        an if statement into two.
+        (WebCore::isElementLargeEnoughForMainContent): Remove now unneeded downcast
+        of a renderer obtained from an HTMLMediaElement.
+
+        * html/TextFieldInputType.cpp:
+        (WebCore::TextFieldInputType::forwardEvent): Call renderer only once.
+        Also use auto more in the code rather than writing out types.
+
+        * html/shadow/SliderThumbElement.cpp:
+        (WebCore::SliderThumbElement::setPositionFromPoint): Used the renderBox
+        function more consistently for all the renderers used here; before,
+        some had null checks and others did not.
+
+        * html/shadow/TextControlInnerElements.cpp:
+        (WebCore::SearchFieldResultsButtonElement::defaultEventHandler): Use auto
+        a bit more.
+
+        * page/EventHandler.cpp:
+        (WebCore::enclosingScrollableArea): Removed a redundant null check and
+        stopped using the name "element" for a local variable that was not
+        always an element.
+
+        * page/PrintContext.cpp:
+        (WebCore::enclosingBoxModelObject): Rewrote loop to be simpler and tighter.
+        Also marked this inline since it's used only one place.
+        (WebCore::PrintContext::pageNumberForElement): Use auto for the return
+        value rather than writing out the type.
+
+        * page/SpatialNavigation.cpp:
+        (WebCore::isScrollableNode): Tighten the code and use auto a bit.
+
+        * platform/ios/WebVideoFullscreenControllerAVKit.mm: Add an include of
+        RenderVideo.h since this gets at the renderer for a video.
+
+        * rendering/RenderAttachment.h:
+        (WebCore::HTMLAttachmentElement::renderer): Added. Function is here because
+        it can only be called by code that includes this header. This matches the
+        pattern of RenderElement.h and ContainerNode::renderer.
+
+        * rendering/RenderFrame.cpp: Added now-needed include.
+
+        * rendering/RenderFrame.h:
+        (WebCore::HTMLFrameElement::renderer): Added. Same logic as above.
+
+        * rendering/RenderLayerFilterInfo.cpp:
+        (WebCore::RenderLayer::FilterInfo::updateReferenceFilterClients): Use auto
+        a bit and call rendeer only once.
+
+        * rendering/RenderMedia.h:
+        (WebCore::HTMLMediaElement::renderer): Added. Same logic as above.
+        * rendering/RenderTextControlMultiLine.h:
+        (WebCore::HTMLTextAreaElement::renderer): Ditto.
+
+        * rendering/RenderVideo.cpp:
+        (WebCore::placeholder): Renamed. Tightened up argument type to match what
+        is passed at all the call sites. Use auto instead of RenderObject.
+        (WebCore::RenderVideo::offsetLeft): Use auto and the renamed function above.
+        (WebCore::RenderVideo::offsetTop): Ditto.
+        (WebCore::RenderVideo::offsetWidth): Ditto.
+        (WebCore::RenderVideo::offsetHeight): Ditto.
+
+        * rendering/RenderVideo.h:
+        (WebCore::HTMLVideoElement::renderer): Added. Same logic as above.
+
+        * svg/SVGGElement.cpp:
+        (WebCore::SVGGElement::createElementRenderer): Fixed typo.
+
+        * svg/SVGGraphicsElement.cpp:
+        (WebCore::SVGGraphicsElement::createElementRenderer): Removed
+        non-helpful oblique comment.
+        * svg/SVGPathElement.cpp:
+        (WebCore::SVGPathElement::createElementRenderer): Ditto.
+
 2016-06-01  Chris Fleizach  <cfleizach@apple.com>
 
         LayoutTest accessibility/ios-simulator/attributed-string-for-range.html failing on ios-simulator debug
index f4745e1..4011ea3 100644 (file)
@@ -707,10 +707,10 @@ id <DOMEventTarget> kit(WebCore::EventTarget* eventTarget)
 - (NSImage*)image
 {
     // FIXME: Could we move this function to WebCore::Node and autogenerate?
-    WebCore::RenderObject* renderer = core(self)->renderer();
+    auto* renderer = core(self)->renderer();
     if (!is<RenderImage>(renderer))
         return nil;
-    WebCore::CachedImage* cachedImage = downcast<RenderImage>(*renderer).cachedImage();
+    auto* cachedImage = downcast<RenderImage>(*renderer).cachedImage();
     if (!cachedImage || cachedImage->errorOccurred())
         return nil;
     return cachedImage->imageForRenderer(renderer)->getNSImage();
index ff3c656..50fdb31 100644 (file)
@@ -675,10 +675,11 @@ void Element::scrollByUnits(int units, ScrollGranularity granularity)
 {
     document().updateLayoutIgnorePendingStylesheets();
 
-    if (!renderer())
+    auto* renderer = this->renderer();
+    if (!renderer)
         return;
 
-    if (!renderer()->hasOverflowClip())
+    if (!renderer->hasOverflowClip())
         return;
 
     ScrollDirection direction = ScrollDown;
@@ -687,7 +688,7 @@ void Element::scrollByUnits(int units, ScrollGranularity granularity)
         units = -units;
     }
     Element* stopElement = this;
-    downcast<RenderBox>(*renderer()).scroll(direction, granularity, units, &stopElement);
+    downcast<RenderBox>(*renderer).scroll(direction, granularity, units, &stopElement);
 }
 
 void Element::scrollByLines(int lines)
@@ -1009,8 +1010,9 @@ LayoutRect Element::absoluteEventBounds(bool& boundsIncludeAllDescendantElements
         if (svgElement.getBoundingBox(localRect, SVGLocatable::DisallowStyleUpdate))
             result = LayoutRect(renderer()->localToAbsoluteQuad(localRect, UseTransforms, &includesFixedPositionElements).boundingBox());
     } else {
-        if (is<RenderBox>(renderer())) {
-            RenderBox& box = *downcast<RenderBox>(renderer());
+        auto* renderer = this->renderer();
+        if (is<RenderBox>(renderer)) {
+            auto& box = downcast<RenderBox>(*renderer);
 
             bool computedBounds = false;
             
@@ -1030,7 +1032,7 @@ LayoutRect Element::absoluteEventBounds(bool& boundsIncludeAllDescendantElements
                     // FIXME: this doesn't handle nested columns.
                     RenderElement* multicolContainer = flowThread->parent();
                     if (multicolContainer && is<RenderBox>(multicolContainer)) {
-                        LayoutRect overflowRect = downcast<RenderBox>(multicolContainer)->layoutOverflowRect();
+                        auto overflowRect = downcast<RenderBox>(*multicolContainer).layoutOverflowRect();
                         result = LayoutRect(multicolContainer->localToAbsoluteQuad(FloatRect(overflowRect), UseTransforms, &includesFixedPositionElements).boundingBox());
                         computedBounds = true;
                     }
@@ -1043,7 +1045,7 @@ LayoutRect Element::absoluteEventBounds(bool& boundsIncludeAllDescendantElements
                 boundsIncludeAllDescendantElements = layoutOverflowRectContainsAllDescendants(box);
             }
         } else
-            result = LayoutRect(renderer()->absoluteBoundingBoxRect(true /* useTransforms */, &includesFixedPositionElements));
+            result = LayoutRect(renderer->absoluteBoundingBoxRect(true /* useTransforms */, &includesFixedPositionElements));
     }
 
     return result;
@@ -2967,12 +2969,12 @@ Vector<RefPtr<Range>> Element::webkitGetRegionFlowRanges() const
 {
     Vector<RefPtr<Range>> rangeObjects;
     document().updateLayoutIgnorePendingStylesheets();
-    if (renderer() && renderer()->isRenderNamedFlowFragmentContainer()) {
-        RenderNamedFlowFragment& namedFlowFragment = *downcast<RenderBlockFlow>(*renderer()).renderNamedFlowFragment();
+    auto* renderer = this->renderer();
+    if (renderer && renderer->isRenderNamedFlowFragmentContainer()) {
+        auto& namedFlowFragment = *downcast<RenderBlockFlow>(*renderer).renderNamedFlowFragment();
         if (namedFlowFragment.isValid())
             namedFlowFragment.getRanges(rangeObjects);
     }
-
     return rangeObjects;
 }
 
index d2312d1..b9042fa 100644 (file)
@@ -1059,13 +1059,12 @@ RefPtr<Node> CompositeEditCommand::addBlockPlaceholderIfNeeded(Element* containe
 
     document().updateLayoutIgnorePendingStylesheets();
 
-    RenderObject* renderer = container->renderer();
+    auto* renderer = container->renderer();
     if (!is<RenderBlockFlow>(renderer))
         return nullptr;
     
-    // append the placeholder to make sure it follows
-    // any unrendered blocks
-    RenderBlockFlow& blockFlow = downcast<RenderBlockFlow>(*renderer);
+    // Append the placeholder to make sure it follows any unrendered blocks.
+    auto& blockFlow = downcast<RenderBlockFlow>(*renderer);
     if (!blockFlow.height() || (blockFlow.isListItem() && blockFlow.isEmpty()))
         return appendBlockPlaceholder(container);
 
index c28607c..31570a5 100644 (file)
@@ -70,7 +70,8 @@ void SimplifyMarkupCommand::doApply()
             if (!currentNode)
                 break;
 
-            if (!is<RenderInline>(currentNode->renderer()) || downcast<RenderInline>(*currentNode->renderer()).alwaysCreateLineBoxes())
+            auto* renderer = currentNode->renderer();
+            if (!is<RenderInline>(renderer) || downcast<RenderInline>(*renderer).alwaysCreateLineBoxes())
                 continue;
             
             if (currentNode->firstChild() != currentNode->lastChild()) {
index e17d0ca..d21cdcd 100644 (file)
@@ -317,7 +317,7 @@ typedef NSUInteger NSTextTabType;
 
 #else
 static NSFileWrapper *fileWrapperForURL(DocumentLoader *, NSURL *);
-static NSFileWrapper *fileWrapperForElement(Element*);
+static NSFileWrapper *fileWrapperForElement(HTMLImageElement&);
 
 @interface NSTextAttachment (WebCoreNSTextAttachment)
 - (void)setIgnoresOrientation:(BOOL)flag;
@@ -1393,7 +1393,7 @@ BOOL HTMLConverter::_addAttachmentForElement(Element& element, NSURL *url, BOOL
         if (path)
             fileWrapper = [[[NSFileWrapper alloc] initWithURL:url options:0 error:NULL] autorelease];
     }
-    if (!fileWrapper) {
+    if (!fileWrapper && dataSource) {
         RefPtr<ArchiveResource> resource = dataSource->subresource(url);
         if (!resource)
             resource = dataSource->subresource(url);
@@ -2423,19 +2423,20 @@ Node* HTMLConverterCaches::cacheAncestorsOfStartToBeConverted(const Range& range
 
 #if !PLATFORM(IOS)
 
-static NSFileWrapper *fileWrapperForURL(DocumentLoader *dataSource, NSURL *URL)
+static NSFileWrapper *fileWrapperForURL(DocumentLoaderdataSource, NSURL *URL)
 {
     if ([URL isFileURL])
         return [[[NSFileWrapper alloc] initWithURL:[URL URLByResolvingSymlinksInPath] options:0 error:nullptr] autorelease];
 
-    RefPtr<ArchiveResource> resource = dataSource->subresource(URL);
-    if (resource) {
-        NSFileWrapper *wrapper = [[[NSFileWrapper alloc] initRegularFileWithContents:resource->data().createNSData().get()] autorelease];
-        NSString *filename = resource->response().suggestedFilename();
-        if (!filename || ![filename length])
-            filename = suggestedFilenameWithMIMEType(resource->url(), resource->mimeType());
-        [wrapper setPreferredFilename:filename];
-        return wrapper;
+    if (dataSource) {
+        if (RefPtr<ArchiveResource> resource = dataSource->subresource(URL)) {
+            NSFileWrapper *wrapper = [[[NSFileWrapper alloc] initRegularFileWithContents:resource->data().createNSData().get()] autorelease];
+            NSString *filename = resource->response().suggestedFilename();
+            if (!filename || ![filename length])
+                filename = suggestedFilenameWithMIMEType(resource->url(), resource->mimeType());
+            [wrapper setPreferredFilename:filename];
+            return wrapper;
+        }
     }
     
     NSMutableURLRequest *request = [[NSMutableURLRequest alloc] initWithURL:URL];
@@ -2452,22 +2453,20 @@ static NSFileWrapper *fileWrapperForURL(DocumentLoader *dataSource, NSURL *URL)
     return nil;
 }
 
-static NSFileWrapper *fileWrapperForElement(Element* element)
+static NSFileWrapper *fileWrapperForElement(HTMLImageElement& element)
 {
-    NSFileWrapper *wrapper = nil;
-    
-    const AtomicString& attr = element->getAttribute(srcAttr);
-    if (!attr.isEmpty()) {
-        NSURL *URL = element->document().completeURL(attr);
-        if (DocumentLoader* loader = element->document().loader())
-            wrapper = fileWrapperForURL(loader, URL);
-    }
+    // FIXME: Should this use currentSrc instead of src?
+    auto src = element.src();
+    NSFileWrapper *wrapper = src.isEmpty() ? nil : fileWrapperForURL(element.document().loader(), src);
+
     if (!wrapper) {
-        auto& renderer = downcast<RenderImage>(*element->renderer());
-        if (renderer.cachedImage() && !renderer.cachedImage()->errorOccurred()) {
-            wrapper = [[NSFileWrapper alloc] initRegularFileWithContents:(NSData *)(renderer.cachedImage()->imageForRenderer(&renderer)->getTIFFRepresentation())];
-            [wrapper setPreferredFilename:@"image.tiff"];
-            [wrapper autorelease];
+        auto* renderer = element.renderer();
+        if (is<RenderImage>(renderer)) {
+            auto* image = downcast<RenderImage>(*renderer).cachedImage();
+            if (image && !image->errorOccurred()) {
+                wrapper = [[[NSFileWrapper alloc] initRegularFileWithContents:(NSData *)image->imageForRenderer(renderer)->getTIFFRepresentation()] autorelease];
+                [wrapper setPreferredFilename:@"image.tiff"];
+            }
         }
     }
 
@@ -2486,6 +2485,7 @@ NSAttributedString *attributedStringFromRange(Range& range)
 }
     
 #if !PLATFORM(IOS)
+
 // This function uses TextIterator, which makes offsets in its result compatible with HTML editing.
 NSAttributedString *editingAttributedStringFromRange(Range& range, IncludeImagesInAttributedString includeOrSkipImages)
 {
@@ -2505,8 +2505,8 @@ NSAttributedString *editingAttributedStringFromRange(Range& range, IncludeImages
             if (&startContainer == &endContainer && (startOffset == endOffset - 1)) {
                 Node* node = startContainer.traverseToChildAt(startOffset);
                 if (is<HTMLImageElement>(node)) {
-                    NSFileWrapper* fileWrapper = fileWrapperForElement(downcast<HTMLImageElement>(node));
-                    NSTextAttachmentattachment = [[NSTextAttachment alloc] initWithFileWrapper:fileWrapper];
+                    auto fileWrapper = fileWrapperForElement(downcast<HTMLImageElement>(*node));
+                    NSTextAttachment *attachment = [[NSTextAttachment alloc] initWithFileWrapper:fileWrapper];
                     [string appendAttributedString:[NSAttributedString attributedStringWithAttachment:attachment]];
                     [attachment release];
                 }
@@ -2546,6 +2546,7 @@ NSAttributedString *editingAttributedStringFromRange(Range& range, IncludeImages
 
     return [string autorelease];
 }
+
 #endif
     
 }
index e6d957d..0f40c24 100644 (file)
@@ -138,34 +138,32 @@ bool HTMLAnchorElement::isKeyboardFocusable(KeyboardEvent* event) const
     return hasNonEmptyBox(renderBoxModelObject());
 }
 
-static void appendServerMapMousePosition(StringBuilder& url, Event* event)
+static void appendServerMapMousePosition(StringBuilder& url, Event& event)
 {
-    ASSERT(event);
-    if (!is<MouseEvent>(*event))
+    if (!is<MouseEvent>(event))
         return;
+    auto& mouseEvent = downcast<MouseEvent>(event);
 
-    ASSERT(event->target());
-    Node* target = event->target()->toNode();
+    ASSERT(mouseEvent.target());
+    auto* target = mouseEvent.target()->toNode();
     ASSERT(target);
     if (!is<HTMLImageElement>(*target))
         return;
 
-    HTMLImageElement& imageElement = downcast<HTMLImageElement>(*target);
+    auto& imageElement = downcast<HTMLImageElement>(*target);
     if (!imageElement.isServerMap())
         return;
 
-    if (!is<RenderImage>(imageElement.renderer()))
+    auto* renderer = imageElement.renderer();
+    if (!is<RenderImage>(renderer))
         return;
-    auto& renderer = downcast<RenderImage>(*imageElement.renderer());
 
-    // FIXME: This should probably pass true for useTransforms.
-    FloatPoint absolutePosition = renderer.absoluteToLocal(FloatPoint(downcast<MouseEvent>(*event).pageX(), downcast<MouseEvent>(*event).pageY()));
-    int x = absolutePosition.x();
-    int y = absolutePosition.y();
+    // FIXME: This should probably pass UseTransforms in the MapCoordinatesFlags.
+    auto absolutePosition = downcast<RenderImage>(*renderer).absoluteToLocal(FloatPoint(mouseEvent.pageX(), mouseEvent.pageY()));
     url.append('?');
-    url.appendNumber(x);
+    url.appendNumber(std::lround(absolutePosition.x()));
     url.append(',');
-    url.appendNumber(y);
+    url.appendNumber(std::lround(absolutePosition.y()));
 }
 
 void HTMLAnchorElement::defaultEventHandler(Event* event)
@@ -551,7 +549,7 @@ void HTMLAnchorElement::handleClick(Event* event)
 
     StringBuilder url;
     url.append(stripLeadingAndTrailingHTMLSpaces(fastGetAttribute(hrefAttr)));
-    appendServerMapMousePosition(url, event);
+    appendServerMapMousePosition(url, *event);
     URL kurl = document().completeURL(url.toString());
 
     auto downloadAttribute = nullAtom;
index 7476303..32e6b60 100644 (file)
@@ -65,18 +65,15 @@ void HTMLAttachmentElement::setFile(File* file)
 {
     m_file = file;
 
-    auto* renderer = this->renderer();
-    if (!is<RenderAttachment>(renderer))
-        return;
-
-    downcast<RenderAttachment>(*renderer).invalidate();
+    if (auto* renderer = this->renderer())
+        renderer->invalidate();
 }
 
 void HTMLAttachmentElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
 {
-    if ((name == progressAttr || name == titleAttr || name == subtitleAttr || name == typeAttr) && is<RenderAttachment>(renderer())) {
-        downcast<RenderAttachment>(*renderer()).invalidate();
-        return;
+    if (name == progressAttr || name == subtitleAttr || name == titleAttr || name == typeAttr) {
+        if (auto* renderer = this->renderer())
+            renderer->invalidate();
     }
 
     HTMLElement::parseAttribute(name, value);
@@ -84,7 +81,7 @@ void HTMLAttachmentElement::parseAttribute(const QualifiedName& name, const Atom
 
 String HTMLAttachmentElement::attachmentTitle() const
 {
-    String title = fastGetAttribute(titleAttr);
+    auto& title = fastGetAttribute(titleAttr);
     if (!title.isEmpty())
         return title;
     return m_file ? m_file->name() : String();
index a89881f..d475f0f 100644 (file)
@@ -23,8 +23,7 @@
  * THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef HTMLAttachmentElement_h
-#define HTMLAttachmentElement_h
+#pragma once
 
 #if ENABLE(ATTACHMENT_ELEMENT)
 
 namespace WebCore {
 
 class File;
+class RenderAttachment;
 
 class HTMLAttachmentElement final : public HTMLElement {
 public:
     static Ref<HTMLAttachmentElement> create(const QualifiedName&, Document&);
+
     WEBCORE_EXPORT File* file() const;
     void setFile(File*);
 
     WEBCORE_EXPORT String attachmentTitle() const;
     String attachmentType() const;
 
+    RenderAttachment* renderer() const;
+
 private:
     HTMLAttachmentElement(const QualifiedName&, Document&);
     virtual ~HTMLAttachmentElement();
@@ -59,4 +62,3 @@ private:
 } // namespace WebCore
 
 #endif // ENABLE(ATTACHMENT_ELEMENT)
-#endif // HTMLAttachmentElement_h
index c235327..a6de605 100644 (file)
  *
  */
 
-#ifndef HTMLButtonElement_h
-#define HTMLButtonElement_h
+#pragma once
 
 #include "HTMLFormControlElement.h"
 
 namespace WebCore {
 
+class RenderButton;
+
 class HTMLButtonElement final : public HTMLFormControlElement {
 public:
     static Ref<HTMLButtonElement> create(const QualifiedName&, Document&, HTMLFormElement*);
@@ -38,6 +39,8 @@ public:
 
     bool willRespondToMouseClickEvents() override;
 
+    RenderButton* renderer() const;
+
 private:
     HTMLButtonElement(const QualifiedName& tagName, Document&, HTMLFormElement*);
 
@@ -77,5 +80,3 @@ private:
 };
 
 } // namespace
-
-#endif
index e05e5e8..0e92d90 100644 (file)
 #include "ScriptController.h"
 #include "Settings.h"
 #include <math.h>
-#include <wtf/RAMSize.h>
-
 #include <runtime/JSCInlines.h>
 #include <runtime/JSLock.h>
+#include <wtf/RAMSize.h>
 
 #if ENABLE(WEBGL)    
 #include "WebGLContextAttributes.h"
@@ -63,25 +62,33 @@ namespace WebCore {
 using namespace HTMLNames;
 
 // These values come from the WhatWG/W3C HTML spec.
-static const int DefaultWidth = 300;
-static const int DefaultHeight = 150;
+const int defaultWidth = 300;
+const int defaultHeight = 150;
 
 // Firefox limits width/height to 32767 pixels, but slows down dramatically before it
 // reaches that limit. We limit by area instead, giving us larger maximum dimensions,
 // in exchange for a smaller maximum canvas size. The maximum canvas size is in device pixels.
 #if PLATFORM(IOS)
-static const unsigned MaxCanvasArea = 4096 * 4096;
+const unsigned maxCanvasArea = 4096 * 4096;
 #elif PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101100
-static const unsigned MaxCanvasArea = 8192 * 8192;
+const unsigned maxCanvasArea = 8192 * 8192;
+#else
+const unsigned maxCanvasArea = 16384 * 16384;
+#endif
+
+#if USE(CG)
+// FIXME: It seems strange that the default quality is not the one that is literally named "default".
+// Should fix names to make this easier to understand, or write an excellent comment here explaining why not.
+const InterpolationQuality defaultInterpolationQuality = InterpolationLow;
 #else
-static const unsigned MaxCanvasArea = 16384 * 16384;
+const InterpolationQuality defaultInterpolationQuality = InterpolationDefault;
 #endif
 
 static size_t activePixelMemory = 0;
 
 HTMLCanvasElement::HTMLCanvasElement(const QualifiedName& tagName, Document& document)
     : HTMLElement(tagName, document)
-    , m_size(DefaultWidth, DefaultHeight)
+    , m_size(defaultWidth, defaultHeight)
 {
     ASSERT(hasTagName(canvasTag));
 }
@@ -127,12 +134,8 @@ void HTMLCanvasElement::parseAttribute(const QualifiedName& name, const AtomicSt
 RenderPtr<RenderElement> HTMLCanvasElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition& insertionPosition)
 {
     Frame* frame = document().frame();
-    if (frame && frame->script().canExecuteScripts(NotAboutToExecuteScript)) {
-        m_rendererIsCanvas = true;
+    if (frame && frame->script().canExecuteScripts(NotAboutToExecuteScript))
         return createRenderer<RenderHTMLCanvas>(*this, WTFMove(style));
-    }
-
-    m_rendererIsCanvas = false;
     return HTMLElement::createElementRenderer(WTFMove(style), insertionPosition);
 }
 
@@ -158,12 +161,12 @@ void HTMLCanvasElement::removeObserver(CanvasObserver& observer)
 
 void HTMLCanvasElement::setHeight(unsigned value)
 {
-    setAttributeWithoutSynchronization(heightAttr, AtomicString::number(limitToOnlyHTMLNonNegative(value, DefaultHeight)));
+    setAttributeWithoutSynchronization(heightAttr, AtomicString::number(limitToOnlyHTMLNonNegative(value, defaultHeight)));
 }
 
 void HTMLCanvasElement::setWidth(unsigned value)
 {
-    setAttributeWithoutSynchronization(widthAttr, AtomicString::number(limitToOnlyHTMLNonNegative(value, DefaultWidth)));
+    setAttributeWithoutSynchronization(widthAttr, AtomicString::number(limitToOnlyHTMLNonNegative(value, defaultWidth)));
 }
 
 #if ENABLE(WEBGL)
@@ -336,8 +339,8 @@ void HTMLCanvasElement::reset()
 
     bool hadImageBuffer = hasCreatedImageBuffer();
 
-    int w = limitToOnlyHTMLNonNegative(fastGetAttribute(widthAttr), DefaultWidth);
-    int h = limitToOnlyHTMLNonNegative(fastGetAttribute(heightAttr), DefaultHeight);
+    int w = limitToOnlyHTMLNonNegative(fastGetAttribute(widthAttr), defaultWidth);
+    int h = limitToOnlyHTMLNonNegative(fastGetAttribute(heightAttr), defaultHeight);
 
     if (m_contextStateSaver) {
         // Reset to the initial graphics context state.
@@ -367,16 +370,16 @@ void HTMLCanvasElement::reset()
         static_cast<WebGLRenderingContextBase*>(m_context.get())->reshape(width(), height());
 #endif
 
-    if (auto renderer = this->renderer()) {
-        if (m_rendererIsCanvas) {
-            if (oldSize != size()) {
-                downcast<RenderHTMLCanvas>(*renderer).canvasSizeChanged();
-                if (renderBox() && renderBox()->hasAcceleratedCompositing())
-                    renderBox()->contentChanged(CanvasChanged);
-            }
-            if (hadImageBuffer)
-                renderer->repaint();
+    auto renderer = this->renderer();
+    if (is<RenderHTMLCanvas>(renderer)) {
+        auto& canvasRenderer = downcast<RenderHTMLCanvas>(*renderer);
+        if (oldSize != size()) {
+            canvasRenderer.canvasSizeChanged();
+            if (canvasRenderer.hasAcceleratedCompositing())
+                canvasRenderer.contentChanged(CanvasChanged);
         }
+        if (hadImageBuffer)
+            canvasRenderer.repaint();
     }
 
     for (auto& observer : m_observers)
@@ -636,10 +639,10 @@ void HTMLCanvasElement::createImageBuffer() const
     if (!deviceSize.isExpressibleAsIntSize())
         return;
 
-    if (deviceSize.width() * deviceSize.height() > MaxCanvasArea) {
+    if (deviceSize.width() * deviceSize.height() > maxCanvasArea) {
         StringBuilder stringBuilder;
         stringBuilder.appendLiteral("Canvas area exceeds the maximum limit (width * height > ");
-        stringBuilder.appendNumber(MaxCanvasArea);
+        stringBuilder.appendNumber(maxCanvasArea);
         stringBuilder.appendLiteral(").");
         document().addConsoleMessage(MessageSource::JS, MessageLevel::Warning, stringBuilder.toString());
         return;
@@ -666,7 +669,7 @@ void HTMLCanvasElement::createImageBuffer() const
     if (!m_imageBuffer)
         return;
     m_imageBuffer->context().setShadowsIgnoreTransforms(true);
-    m_imageBuffer->context().setImageInterpolationQuality(DefaultInterpolationQuality);
+    m_imageBuffer->context().setImageInterpolationQuality(defaultInterpolationQuality);
     if (document().settings() && !document().settings()->antialiased2dCanvasEnabled())
         m_imageBuffer->context().setShouldAntialias(false);
     m_imageBuffer->context().setStrokeThickness(1);
index d25b8ea..fe696a4 100644 (file)
@@ -25,8 +25,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
  */
 
-#ifndef HTMLCanvasElement_h
-#define HTMLCanvasElement_h
+#pragma once
 
 #include "FloatRect.h"
 #include "HTMLElement.h"
 #include <memory>
 #include <wtf/Forward.h>
 
-#if USE(CG)
-#define DefaultInterpolationQuality InterpolationLow
-#else
-#define DefaultInterpolationQuality InterpolationDefault
-#endif
-
 namespace WebCore {
 
 class CanvasContextAttributes;
@@ -48,9 +41,8 @@ class GraphicsContext;
 class GraphicsContextStateSaver;
 class HTMLCanvasElement;
 class Image;
-class ImageData;
 class ImageBuffer;
-class IntSize;
+class ImageData;
 
 namespace DisplayList {
 typedef unsigned AsTextFlags;
@@ -74,7 +66,6 @@ public:
     void addObserver(CanvasObserver&);
     void removeObserver(CanvasObserver&);
 
-    // Attributes and functions exposed to script
     unsigned width() const { return size().width(); }
     unsigned height() const { return size().height(); }
 
@@ -94,8 +85,8 @@ public:
         reset();
     }
 
-    CanvasRenderingContext* getContext(const String&, CanvasContextAttributes* attributes = 0);
-    bool probablySupportsContext(const String&, CanvasContextAttributes* = 0);
+    CanvasRenderingContext* getContext(const String&, CanvasContextAttributes* = nullptr);
+    bool probablySupportsContext(const String&, CanvasContextAttributes* = nullptr);
     static bool is2dType(const String&);
 #if ENABLE(WEBGL)
     static bool is3dType(const String&);
@@ -103,7 +94,7 @@ public:
 
     static String toEncodingMimeType(const String& mimeType);
     String toDataURL(const String& mimeType, const double* quality, ExceptionCode&);
-    String toDataURL(const String& mimeType, ExceptionCode& ec) { return toDataURL(mimeType, 0, ec); }
+    String toDataURL(const String& mimeType, ExceptionCode& ec) { return toDataURL(mimeType, nullptr, ec); }
 
     // Used for rendering
     void didDraw(const FloatRect&);
@@ -177,7 +168,6 @@ private:
     IntSize m_size;
 
     bool m_originClean { true };
-    bool m_rendererIsCanvas { false };
     bool m_ignoreReset { false };
 
     bool m_usesDisplayListDrawing { false };
@@ -193,6 +183,4 @@ private:
     mutable RefPtr<Image> m_copiedImage; // FIXME: This is temporary for platforms that have to copy the image buffer to render (and for CSSCanvasValue).
 };
 
-} //namespace
-
-#endif
+} // namespace WebCore
index dd5df2c..72f278d 100644 (file)
@@ -40,14 +40,13 @@ using namespace HTMLNames;
 
 inline HTMLFieldSetElement::HTMLFieldSetElement(const QualifiedName& tagName, Document& document, HTMLFormElement* form)
     : HTMLFormControlElement(tagName, document, form)
-    , m_documentVersion(0)
 {
     ASSERT(hasTagName(fieldsetTag));
 }
 
 HTMLFieldSetElement::~HTMLFieldSetElement()
 {
-    if (fastHasAttribute(disabledAttr))
+    if (m_hasDisabledAttribute)
         document().removeDisabledFieldsetElement();
 }
 
@@ -65,7 +64,7 @@ static void updateFromControlElementsAncestorDisabledStateUnder(HTMLElement& sta
         control = Traversal<HTMLFormControlElement>::firstWithin(startNode);
     while (control) {
         control->setAncestorDisabled(isDisabled);
-        // Don't call setAncestorDisabled(false) on form contorls inside disabled fieldsets.
+        // Don't call setAncestorDisabled(false) on form controls inside disabled fieldsets.
         if (is<HTMLFieldSetElement>(*control) && control->fastHasAttribute(disabledAttr))
             control = Traversal<HTMLFormControlElement>::nextSkippingChildren(*control, &startNode);
         else
@@ -75,10 +74,14 @@ static void updateFromControlElementsAncestorDisabledStateUnder(HTMLElement& sta
 
 void HTMLFieldSetElement::disabledAttributeChanged()
 {
-    if (fastHasAttribute(disabledAttr))
-        document().addDisabledFieldsetElement();
-    else
-        document().removeDisabledFieldsetElement();
+    bool hasDisabledAttribute = fastHasAttribute(disabledAttr);
+    if (m_hasDisabledAttribute != hasDisabledAttribute) {
+        m_hasDisabledAttribute = hasDisabledAttribute;
+        if (hasDisabledAttribute)
+            document().addDisabledFieldsetElement();
+        else
+            document().removeDisabledFieldsetElement();
+    }
 
     HTMLFormControlElement::disabledAttributeChanged();
 }
@@ -113,7 +116,7 @@ void HTMLFieldSetElement::childrenChanged(const ChildChange& change)
     if (!legend)
         return;
 
-    // We only care about the first legend element (in which form contorls are not disabled by this element) changing here.
+    // We only care about the first legend element (in which form controls are not disabled by this element) changing here.
     updateFromControlElementsAncestorDisabledStateUnder(*legend, false /* isDisabled */);
     while ((legend = Traversal<HTMLLegendElement>::nextSibling(*legend)))
         updateFromControlElementsAncestorDisabledStateUnder(*legend, true);
@@ -122,7 +125,7 @@ void HTMLFieldSetElement::childrenChanged(const ChildChange& change)
 void HTMLFieldSetElement::didMoveToNewDocument(Document* oldDocument)
 {
     HTMLFormControlElement::didMoveToNewDocument(oldDocument);
-    if (fastHasAttribute(disabledAttr)) {
+    if (m_hasDisabledAttribute) {
         if (oldDocument)
             oldDocument->removeDisabledFieldsetElement();
         document().addDisabledFieldsetElement();
@@ -170,7 +173,7 @@ Ref<HTMLCollection> HTMLFieldSetElement::elementsForNativeBindings()
     return elements();
 }
 
-void HTMLFieldSetElement::refreshElementsIfNeeded() const
+void HTMLFieldSetElement::updateAssociatedElements() const
 {
     uint64_t documentVersion = document().domTreeVersion();
     if (m_documentVersion == documentVersion)
@@ -180,8 +183,8 @@ void HTMLFieldSetElement::refreshElementsIfNeeded() const
 
     m_associatedElements.clear();
 
-    for (auto& element : descendantsOfType<Element>(const_cast<HTMLFieldSetElement&>(*this))) {
-        if (element.hasTagName(objectTag))
+    for (auto& element : descendantsOfType<HTMLElement>(const_cast<HTMLFieldSetElement&>(*this))) {
+        if (is<HTMLObjectElement>(element))
             m_associatedElements.append(&downcast<HTMLObjectElement>(element));
         else if (is<HTMLFormControlElement>(element))
             m_associatedElements.append(&downcast<HTMLFormControlElement>(element));
@@ -190,15 +193,14 @@ void HTMLFieldSetElement::refreshElementsIfNeeded() const
 
 const Vector<FormAssociatedElement*>& HTMLFieldSetElement::associatedElements() const
 {
-    refreshElementsIfNeeded();
+    updateAssociatedElements();
     return m_associatedElements;
 }
 
 unsigned HTMLFieldSetElement::length() const
 {
-    refreshElementsIfNeeded();
     unsigned length = 0;
-    for (auto& element : m_associatedElements) {
+    for (auto* element : associatedElements()) {
         if (element->isEnumeratable())
             ++length;
     }
index c2c6734..ce7add1 100644 (file)
@@ -21,8 +21,7 @@
  *
  */
 
-#ifndef HTMLFieldSetElement_h
-#define HTMLFieldSetElement_h
+#pragma once
 
 #include "HTMLFormControlElement.h"
 #include <wtf/HashSet.h>
@@ -31,6 +30,7 @@ namespace WebCore {
 
 class FormAssociatedElement;
 class HTMLFormControlsCollection;
+class RenderFieldSet;
 
 class HTMLFieldSetElement final : public HTMLFormControlElement {
 public:
@@ -47,6 +47,8 @@ public:
     void addInvalidDescendant(const HTMLFormControlElement&);
     void removeInvalidDescendant(const HTMLFormControlElement&);
 
+    RenderFieldSet* renderer() const;
+
 private:
     HTMLFieldSetElement(const QualifiedName&, Document&, HTMLFormElement*);
     ~HTMLFieldSetElement();
@@ -64,14 +66,13 @@ private:
     bool matchesValidPseudoClass() const override;
     bool matchesInvalidPseudoClass() const override;
 
-    void refreshElementsIfNeeded() const;
+    void updateAssociatedElements() const;
 
     mutable Vector<FormAssociatedElement*> m_associatedElements;
-    // When dom tree is modified, we have to refresh the m_associatedElements array.
-    mutable uint64_t m_documentVersion;
+    // When the DOM tree is modified, we have to refresh the m_associatedElements array.
+    mutable uint64_t m_documentVersion { 0 };
     HashSet<const HTMLFormControlElement*> m_invalidDescendants;
+    bool m_hasDisabledAttribute { false };
 };
 
 } // namespace
-
-#endif
index 6ff11df..a252d15 100644 (file)
@@ -35,8 +35,6 @@ using namespace HTMLNames;
 
 inline HTMLFrameElement::HTMLFrameElement(const QualifiedName& tagName, Document& document)
     : HTMLFrameElementBase(tagName, document)
-    , m_frameBorder(true)
-    , m_frameBorderSet(false)
 {
     ASSERT(hasTagName(frameTag));
     setHasCustomStyleResolveCallbacks();
@@ -80,8 +78,8 @@ void HTMLFrameElement::parseAttribute(const QualifiedName& name, const AtomicStr
         m_frameBorderSet = !value.isNull();
         // FIXME: If we are already attached, this has no effect.
     } else if (name == noresizeAttr) {
-        if (renderer())
-            renderer()->updateFromElement();
+        if (auto* renderer = this->renderer())
+            renderer->updateFromElement();
     } else
         HTMLFrameElementBase::parseAttribute(name, value);
 }
index 6df8686..4f08ab0 100644 (file)
  *
  */
 
-#ifndef HTMLFrameElement_h
-#define HTMLFrameElement_h
+#pragma once
 
 #include "HTMLFrameElementBase.h"
 
 namespace WebCore {
 
+class RenderFrame;
+
 class HTMLFrameElement final : public HTMLFrameElementBase {
 public:
     static Ref<HTMLFrameElement> create(const QualifiedName&, Document&);
 
     bool hasFrameBorder() const { return m_frameBorder; }
-
     bool noResize() const;
 
+    RenderFrame* renderer() const;
+
 private:
     HTMLFrameElement(const QualifiedName&, Document&);
 
-    void didAttachRenderers() override;
+    void didAttachRenderers() final;
+    bool rendererIsNeeded(const RenderStyle&) final;
+    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) final;
+    void parseAttribute(const QualifiedName&, const AtomicString&) final;
 
-    bool rendererIsNeeded(const RenderStyle&) override;
-    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
-    
-    void parseAttribute(const QualifiedName&, const AtomicString&) override;
-
-    bool m_frameBorder;
-    bool m_frameBorderSet;
+    bool m_frameBorder { true };
+    bool m_frameBorderSet { false };
 };
 
 } // namespace WebCore
-
-#endif // HTMLFrameElement_h
index 0b50dd0..0690b22 100644 (file)
  *
  */
 
-#ifndef HTMLIFrameElement_h
-#define HTMLIFrameElement_h
+#pragma once
 
 #include "HTMLFrameElementBase.h"
 
 namespace WebCore {
 
 class DOMTokenList;
+class RenderIFrame;
 
 class HTMLIFrameElement final : public HTMLFrameElementBase {
 public:
@@ -36,23 +36,23 @@ public:
 
     DOMTokenList& sandbox();
 
+    RenderIFrame* renderer() const;
+
 private:
     HTMLIFrameElement(const QualifiedName&, Document&);
 
 #if PLATFORM(IOS)
-    bool isKeyboardFocusable(KeyboardEvent*) const override { return false; }
+    bool isKeyboardFocusable(KeyboardEvent*) const final { return false; }
 #endif
 
-    void parseAttribute(const QualifiedName&, const AtomicString&) override;
-    bool isPresentationAttribute(const QualifiedName&) const override;
-    void collectStyleForPresentationAttribute(const QualifiedName&, const AtomicString&, MutableStyleProperties&) override;
+    void parseAttribute(const QualifiedName&, const AtomicString&) final;
+    bool isPresentationAttribute(const QualifiedName&) const final;
+    void collectStyleForPresentationAttribute(const QualifiedName&, const AtomicString&, MutableStyleProperties&) final;
 
-    bool rendererIsNeeded(const RenderStyle&) override;
-    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
+    bool rendererIsNeeded(const RenderStyle&) final;
+    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) final;
 
     std::unique_ptr<DOMTokenList> m_sandbox;
 };
 
 } // namespace WebCore
-
-#endif // HTMLIFrameElement_h
index 36741db..d5d6d62 100644 (file)
@@ -24,7 +24,9 @@
  */
 
 #include "config.h"
+
 #if ENABLE(VIDEO)
+
 #include "HTMLMediaElement.h"
 
 #include "ApplicationCacheHost.h"
@@ -831,9 +833,15 @@ void HTMLMediaElement::willAttachRenderers()
     ASSERT(!renderer());
 }
 
+inline void HTMLMediaElement::updateRenderer()
+{
+    if (auto* renderer = this->renderer())
+        renderer->updateFromElement();
+}
+
 void HTMLMediaElement::didAttachRenderers()
 {
-    if (RenderElement* renderer = this->renderer()) {
+    if (auto* renderer = this->renderer()) {
         renderer->updateFromElement();
         if (m_mediaSession->hasBehaviorRestriction(MediaElementSession::InvisibleAutoplayNotPermitted)
             || m_mediaSession->hasBehaviorRestriction(MediaElementSession::OverrideUserGestureRequirementForMainContent))
@@ -844,8 +852,8 @@ void HTMLMediaElement::didAttachRenderers()
 
 void HTMLMediaElement::willDetachRenderers()
 {
-    if (renderer())
-        renderer()->unregisterForVisibleInViewportCallback();
+    if (auto* renderer = this->renderer())
+        renderer->unregisterForVisibleInViewportCallback();
 }
 
 void HTMLMediaElement::didDetachRenderers()
@@ -855,8 +863,7 @@ void HTMLMediaElement::didDetachRenderers()
 
 void HTMLMediaElement::didRecalcStyle(Style::Change)
 {
-    if (renderer())
-        renderer()->updateFromElement();
+    updateRenderer();
 }
 
 void HTMLMediaElement::scheduleDelayedAction(DelayedActionType actionType)
@@ -1440,8 +1447,7 @@ void HTMLMediaElement::loadResource(const URL& initialURL, ContentType& contentT
     // they are available.
     updateDisplayState();
 
-    if (renderer())
-        renderer()->updateFromElement();
+    updateRenderer();
 }
 
 #if ENABLE(VIDEO_TRACK)
@@ -1924,9 +1930,7 @@ void HTMLMediaElement::waitForSourceChange()
     setShouldDelayLoadEvent(false);
 
     updateDisplayState();
-
-    if (renderer())
-        renderer()->updateFromElement();
+    updateRenderer();
 }
 
 void HTMLMediaElement::noneSupported()
@@ -1967,9 +1971,7 @@ void HTMLMediaElement::noneSupported()
     // the element won't attempt to load another resource.
 
     updateDisplayState();
-
-    if (renderer())
-        renderer()->updateFromElement();
+    updateRenderer();
 }
 
 void HTMLMediaElement::mediaLoadingFailedFatally(MediaPlayer::NetworkState error)
@@ -2256,8 +2258,7 @@ void HTMLMediaElement::setReadyState(MediaPlayer::ReadyState state)
 
         if (hasMediaControls())
             mediaControls()->loadedMetadata();
-        if (renderer())
-            renderer()->updateFromElement();
+        updateRenderer();
 
         if (is<MediaDocument>(document()))
             downcast<MediaDocument>(document()).mediaElementNaturalSizeChanged(expandedIntSize(m_player->naturalSize()));
@@ -2452,8 +2453,7 @@ void HTMLMediaElement::progressEventTimerFired()
         scheduleEvent(eventNames().progressEvent);
         m_previousProgressTime = time;
         m_sentStalledEvent = false;
-        if (renderer())
-            renderer()->updateFromElement();
+        updateRenderer();
         if (hasMediaControls())
             mediaControls()->bufferingProgressed();
     } else if (timedelta > 3.0 && !m_sentStalledEvent) {
@@ -4177,7 +4177,7 @@ URL HTMLMediaElement::selectNextSourceChild(ContentType* contentType, String* ke
             LOG(Media, "HTMLMediaElement::selectNextSourceChild(%p) - 'src' is %s", this, urlForLoggingMedia(mediaURL).utf8().data());
 #endif
         if (mediaURL.isEmpty())
-            goto check_again;
+            goto CheckAgain;
         
         if (source->fastHasAttribute(mediaAttr)) {
             auto media = source->mediaQuerySet();
@@ -4185,8 +4185,11 @@ URL HTMLMediaElement::selectNextSourceChild(ContentType* contentType, String* ke
             if (shouldLog)
                 LOG(Media, "HTMLMediaElement::selectNextSourceChild(%p) - 'media' is %s", this, source->media().utf8().data());
 #endif
-            if (media && !MediaQueryEvaluator { "screen", document(), renderer() ? &renderer()->style() : nullptr }.evaluate(*media))
-                goto check_again;
+            if (media) {
+                auto* renderer = this->renderer();
+                if (!MediaQueryEvaluator { "screen", document(), renderer ? &renderer->style() : nullptr }.evaluate(*media))
+                    goto CheckAgain;
+            }
         }
 
         type = source->type();
@@ -4213,7 +4216,7 @@ URL HTMLMediaElement::selectNextSourceChild(ContentType* contentType, String* ke
             parameters.isMediaStream = mediaURL.protocolIs(mediaStreamBlobProtocol);
 #endif
             if (!MediaPlayer::supportsType(parameters, this))
-                goto check_again;
+                goto CheckAgain;
         }
 
         // Is it safe to load this url?
@@ -4223,16 +4226,16 @@ URL HTMLMediaElement::selectNextSourceChild(ContentType* contentType, String* ke
         if (node.parentNode() != this) {
             LOG(Media, "HTMLMediaElement::selectNextSourceChild(%p) - 'beforeload' removed current element", this);
             source = 0;
-            goto check_again;
+            goto CheckAgain;
         }
 
         if (!okToLoadSourceURL)
-            goto check_again;
+            goto CheckAgain;
 
         // Making it this far means the <source> looks reasonable.
         canUseSourceElement = true;
 
-check_again:
+CheckAgain:
         if (!canUseSourceElement && actionIfInvalid == Complain && source)
             source->scheduleErrorEvent();
     }
@@ -4511,8 +4514,8 @@ void HTMLMediaElement::mediaPlayerRepaint(MediaPlayer*)
 {
     beginProcessingMediaPlayerCallback();
     updateDisplayState();
-    if (renderer())
-        renderer()->repaint();
+    if (auto* renderer = this->renderer())
+        renderer->repaint();
     endProcessingMediaPlayerCallback();
 }
 
@@ -4526,16 +4529,15 @@ void HTMLMediaElement::mediaPlayerSizeChanged(MediaPlayer*)
     beginProcessingMediaPlayerCallback();
     if (m_readyState > HAVE_NOTHING)
         scheduleResizeEventIfSizeChanged();
-    if (renderer())
-        renderer()->updateFromElement();
+    updateRenderer();
     endProcessingMediaPlayerCallback();
 }
 
 bool HTMLMediaElement::mediaPlayerRenderingCanBeAccelerated(MediaPlayer*)
 {
-    if (is<RenderVideo>(renderer()))
-        return renderer()->view().compositor().canAccelerateVideoRendering(downcast<RenderVideo>(*renderer()));
-    return false;
+    auto* renderer = this->renderer();
+    return is<RenderVideo>(renderer)
+        && downcast<RenderVideo>(*renderer).view().compositor().canAccelerateVideoRendering(downcast<RenderVideo>(*renderer));
 }
 
 void HTMLMediaElement::mediaPlayerRenderingModeChanged(MediaPlayer*)
@@ -4547,21 +4549,22 @@ void HTMLMediaElement::mediaPlayerRenderingModeChanged(MediaPlayer*)
 }
 
 #if PLATFORM(WIN) && USE(AVFOUNDATION)
+
 GraphicsDeviceAdapter* HTMLMediaElement::mediaPlayerGraphicsDeviceAdapter(const MediaPlayer*) const
 {
-    if (!document().page())
-        return 0;
-
-    return document().page()->chrome().client().graphicsDeviceAdapter();
+    auto* page = document().page();
+    if (!page)
+        return nullptr;
+    return page->chrome().client().graphicsDeviceAdapter();
 }
+
 #endif
 
 void HTMLMediaElement::mediaEngineWasUpdated()
 {
     LOG(Media, "HTMLMediaElement::mediaEngineWasUpdated(%p)", this);
     beginProcessingMediaPlayerCallback();
-    if (renderer())
-        renderer()->updateFromElement();
+    updateRenderer();
     endProcessingMediaPlayerCallback();
 
     m_mediaSession->mediaEngineUpdated(*this);
@@ -4630,8 +4633,7 @@ void HTMLMediaElement::mediaPlayerCharacteristicChanged(MediaPlayer*)
 
     if (hasMediaControls())
         mediaControls()->reset();
-    if (renderer())
-        renderer()->updateFromElement();
+    updateRenderer();
 
     if (isPlaying() && !m_mediaSession->playbackPermitted(*this))
         pauseInternal();
@@ -4895,9 +4897,7 @@ void HTMLMediaElement::updatePlayState()
     }
     
     updateMediaController();
-
-    if (renderer())
-        renderer()->updateFromElement();
+    updateRenderer();
 }
 
 void HTMLMediaElement::setPlaying(bool playing)
@@ -5058,9 +5058,8 @@ void HTMLMediaElement::stopWithoutDestroyingMediaPlayer()
 
     userCancelledLoad();
 
-    if (renderer())
-        renderer()->updateFromElement();
-    
+    updateRenderer();
+
     stopPeriodicTimers();
 
     updateSleepDisabling();
@@ -5141,8 +5140,7 @@ void HTMLMediaElement::resume()
         scheduleDelayedAction(LoadMediaResource);
     }
 
-    if (renderer())
-        renderer()->updateFromElement();
+    updateRenderer();
 }
 
 bool HTMLMediaElement::hasPendingActivity() const
@@ -6246,9 +6244,10 @@ bool HTMLMediaElement::mediaPlayerIsVideo() const
 
 LayoutRect HTMLMediaElement::mediaPlayerContentBoxRect() const
 {
-    if (renderer())
-        return renderer()->enclosingBox().contentBoxRect();
-    return LayoutRect();
+    auto* renderer = this->renderer();
+    if (!renderer)
+        return { };
+    return renderer->enclosingBox().contentBoxRect();
 }
 
 float HTMLMediaElement::mediaPlayerContentsScale() const
@@ -7010,7 +7009,7 @@ static bool mediaElementIsAllowedToAutoplay(const HTMLMediaElement& element)
     if (document.activeDOMObjectsAreSuspended())
         return false;
 
-    RenderElement* renderer = element.renderer();
+    auto* renderer = element.renderer();
     if (!renderer)
         return false;
     if (renderer->style().visibility() != VISIBLE)
index e44c2fb..91afa44 100644 (file)
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef HTMLMediaElement_h
-#define HTMLMediaElement_h
+#pragma once
 
 #if ENABLE(VIDEO)
+
 #include "HTMLElement.h"
 #include "ActiveDOMObject.h"
 #include "GenericEventQueue.h"
 
 namespace WebCore {
 
-#if ENABLE(WEB_AUDIO)
 class AudioSourceProvider;
-class MediaElementAudioSourceNode;
-#endif
+class AudioTrackList;
+class AudioTrackPrivate;
 class DOMError;
 class DisplaySleepDisabler;
 class Event;
 class HTMLSourceElement;
 class HTMLTrackElement;
-class URL;
+class InbandTextTrackPrivate;
 class MediaController;
 class MediaControls;
 class MediaControlsHost;
+class MediaElementAudioSourceNode;
 class MediaError;
-class MediaPlayer;
-class TimeRanges;
-#if ENABLE(ENCRYPTED_MEDIA_V2)
 class MediaKeys;
-#endif
-#if ENABLE(MEDIA_SESSION)
+class MediaPlayer;
 class MediaSession;
-#endif
-#if ENABLE(MEDIA_SOURCE)
 class MediaSource;
+class MediaStream;
+class RenderMedia;
+class ScriptExecutionContext;
 class SourceBuffer;
-class VideoPlaybackQuality;
-#endif
-
-#if ENABLE(VIDEO_TRACK)
-class AudioTrackList;
-class AudioTrackPrivate;
-class InbandTextTrackPrivate;
 class TextTrackList;
+class TimeRanges;
+class URL;
+class VideoPlaybackQuality;
 class VideoTrackList;
 class VideoTrackPrivate;
 
+#if ENABLE(VIDEO_TRACK)
 typedef PODIntervalTree<MediaTime, TextTrackCue*> CueIntervalTree;
 typedef CueIntervalTree::IntervalType CueInterval;
 typedef Vector<CueInterval> CueList;
 #endif
 
-#if ENABLE(MEDIA_STREAM)
-class MediaStream;
-class ScriptExecutionContext;
-#endif
-
 class HTMLMediaElement
     : public HTMLElement
-    , private MediaPlayerClient, public MediaPlayerSupportsTypeClient, private MediaCanStartListener, public ActiveDOMObject, public MediaControllerInterface , public PlatformMediaSessionClient, private MediaProducer
+    , public ActiveDOMObject
+    , public MediaControllerInterface
+    , public MediaPlayerSupportsTypeClient
+    , public PlatformMediaSessionClient
+    , private MediaCanStartListener
+    , private MediaPlayerClient
+    , private MediaProducer
 #if ENABLE(VIDEO_TRACK)
     , private AudioTrackClient
     , private TextTrackClient
@@ -466,8 +461,10 @@ public:
     void allowsMediaDocumentInlinePlaybackChanged();
     void updateShouldPlay();
 
+    RenderMedia* renderer() const;
+
 protected:
-    HTMLMediaElement(const QualifiedName&, Document&, bool);
+    HTMLMediaElement(const QualifiedName&, Document&, bool createdByParser);
     virtual ~HTMLMediaElement();
 
     void parseAttribute(const QualifiedName&, const AtomicString&) override;
@@ -656,7 +653,6 @@ private:
     virtual void scheduleResizeEvent() { }
     virtual void scheduleResizeEventIfSizeChanged() { }
 
-    // loading
     void selectMediaResource();
     void loadResource(const URL&, ContentType&, const String& keySystem);
     void scheduleNextSourceChild();
@@ -745,7 +741,6 @@ private:
     bool ensureMediaControlsInjectedScript();
 #endif
 
-    // PlatformMediaSessionClient Overrides
     PlatformMediaSession::MediaType mediaType() const override;
     PlatformMediaSession::MediaType presentationType() const override;
     PlatformMediaSession::DisplayType displayType() const override;
@@ -776,10 +771,7 @@ private:
     void prepareForDocumentSuspension() final;
     void resumeFromDocumentSuspension() final;
 
-    enum class UpdateMediaState {
-        Asynchronously,
-        Synchronously,
-    };
+    enum class UpdateMediaState { Asynchronously, Synchronously };
     void updateMediaState(UpdateMediaState updateState = UpdateMediaState::Synchronously);
     bool hasPlaybackTargetAvailabilityListeners() const { return m_hasPlaybackTargetAvailabilityListeners; }
 #endif
@@ -790,6 +782,8 @@ private:
     void pauseAfterDetachedTask();
     void updatePlaybackControlsManager();
 
+    void updateRenderer();
+
     Timer m_pendingActionTimer;
     Timer m_progressEventTimer;
     Timer m_playbackProgressTimer;
@@ -852,6 +846,7 @@ private:
     VideoFullscreenMode m_videoFullscreenMode;
     bool m_preparedForInline;
     std::function<void()> m_preparedForInlineCompletionHandler;
+
 #if PLATFORM(IOS) || (PLATFORM(MAC) && ENABLE(VIDEO_PRESENTATION_MODE))
     RetainPtr<PlatformLayer> m_videoFullscreenLayer;
     FloatRect m_videoFullscreenFrame;
@@ -1035,4 +1030,3 @@ SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::HTMLMediaElement)
 SPECIALIZE_TYPE_TRAITS_END()
 
 #endif
-#endif
index ff14153..0efd0f3 100644 (file)
@@ -391,11 +391,8 @@ void HTMLSelectElement::optionElementChildrenChanged()
 {
     setRecalcListItems();
     updateValidity();
-
-    if (renderer()) {
-        if (AXObjectCache* cache = renderer()->document().existingAXObjectCache())
-            cache->childrenChanged(this);
-    }
+    if (auto* cache = document().existingAXObjectCache())
+        cache->childrenChanged(this);
 }
 
 void HTMLSelectElement::accessKeyAction(bool sendMouseEvents)
@@ -469,7 +466,7 @@ void HTMLSelectElement::setLength(unsigned newLength, ExceptionCode& ec)
                 break;
         } while (++diff);
     } else {
-        const Vector<HTMLElement*>& items = listItems();
+        auto& items = listItems();
 
         // Removing children fires mutation events, which might mutate the DOM further, so we first copy out a list
         // of elements that we intend to remove then attempt to remove them one at a time.
@@ -511,7 +508,7 @@ bool HTMLSelectElement::willRespondToMouseClickEvents()
 int HTMLSelectElement::nextValidIndex(int listIndex, SkipDirection direction, int skip) const
 {
     ASSERT(direction == -1 || direction == 1);
-    const Vector<HTMLElement*>& listItems = this->listItems();
+    auto& listItems = this->listItems();
     int lastGoodIndex = listIndex;
     int size = listItems.size();
     for (listIndex += direction; listIndex >= 0 && listIndex < size; listIndex += direction) {
@@ -539,7 +536,7 @@ int HTMLSelectElement::previousSelectableListIndex(int startIndex) const
 
 int HTMLSelectElement::firstSelectableListIndex() const
 {
-    const Vector<HTMLElement*>& items = listItems();
+    auto& items = listItems();
     int index = nextValidIndex(items.size(), SkipBackwards, INT_MAX);
     if (static_cast<size_t>(index) == items.size())
         return -1;
@@ -554,11 +551,13 @@ int HTMLSelectElement::lastSelectableListIndex() const
 // Returns the index of the next valid item one page away from |startIndex| in direction |direction|.
 int HTMLSelectElement::nextSelectableListIndexPageAway(int startIndex, SkipDirection direction) const
 {
-    const Vector<HTMLElement*>& items = listItems();
+    auto& items = listItems();
+
     // Can't use m_size because renderer forces a minimum size.
     int pageSize = 0;
-    if (is<RenderListBox>(*renderer()))
-        pageSize = downcast<RenderListBox>(*renderer()).size() - 1; // -1 so we still show context.
+    auto* renderer = this->renderer();
+    if (is<RenderListBox>(*renderer))
+        pageSize = downcast<RenderListBox>(*renderer).size() - 1; // -1 so we still show context.
 
     // One page away, but not outside valid bounds.
     // If there is a valid option item one page away, the index is chosen.
@@ -620,28 +619,31 @@ void HTMLSelectElement::setActiveSelectionEndIndex(int index)
 
 void HTMLSelectElement::updateListBoxSelection(bool deselectOtherOptions)
 {
+    ASSERT(renderer());
+
 #if !PLATFORM(IOS)
-    ASSERT(renderer() && (renderer()->isListBox() || m_multiple));
+    ASSERT(renderer()->isListBox() || m_multiple);
 #else
-    ASSERT(renderer() && (renderer()->isMenuList() || m_multiple));
+    ASSERT(renderer()->isMenuList() || m_multiple);
 #endif
+
     ASSERT(!listItems().size() || m_activeSelectionAnchorIndex >= 0);
 
     unsigned start = std::min(m_activeSelectionAnchorIndex, m_activeSelectionEndIndex);
     unsigned end = std::max(m_activeSelectionAnchorIndex, m_activeSelectionEndIndex);
 
-    const Vector<HTMLElement*>& items = listItems();
+    auto& items = listItems();
     for (unsigned i = 0; i < items.size(); ++i) {
-        HTMLElement* element = items[i];
-        if (!is<HTMLOptionElement>(*element) || downcast<HTMLOptionElement>(*element).isDisabledFormControl())
+        auto& element = *items[i];
+        if (!is<HTMLOptionElement>(element) || downcast<HTMLOptionElement>(element).isDisabledFormControl())
             continue;
 
         if (i >= start && i <= end)
-            downcast<HTMLOptionElement>(*element).setSelectedState(m_activeSelectionState);
+            downcast<HTMLOptionElement>(element).setSelectedState(m_activeSelectionState);
         else if (deselectOtherOptions || i >= m_cachedStateForActiveSelection.size())
-            downcast<HTMLOptionElement>(*element).setSelectedState(false);
+            downcast<HTMLOptionElement>(element).setSelectedState(false);
         else
-            downcast<HTMLOptionElement>(*element).setSelectedState(m_cachedStateForActiveSelection[i]);
+            downcast<HTMLOptionElement>(element).setSelectedState(m_cachedStateForActiveSelection[i]);
     }
 
     scrollToSelection();
@@ -652,7 +654,7 @@ void HTMLSelectElement::listBoxOnChange()
 {
     ASSERT(!usesMenuList() || m_multiple);
 
-    const Vector<HTMLElement*>& items = listItems();
+    auto& items = listItems();
 
     // If the cached selection list is empty, or the size has changed, then fire
     // dispatchFormControlChangeEvent, and return early.
@@ -664,8 +666,8 @@ void HTMLSelectElement::listBoxOnChange()
     // Update m_lastOnChangeSelection and fire dispatchFormControlChangeEvent.
     bool fireOnChange = false;
     for (unsigned i = 0; i < items.size(); ++i) {
-        HTMLElement* element = items[i];
-        bool selected = is<HTMLOptionElement>(*element) && downcast<HTMLOptionElement>(*element).selected();
+        auto& element = *items[i];
+        bool selected = is<HTMLOptionElement>(element) && downcast<HTMLOptionElement>(element).selected();
         if (selected != m_lastOnChangeSelection[i])
             fireOnChange = true;
         m_lastOnChangeSelection[i] = selected;
@@ -754,11 +756,8 @@ void HTMLSelectElement::setRecalcListItems()
     }
     if (!inDocument())
         invalidateSelectedItems();
-    
-    if (renderer()) {
-        if (AXObjectCache* cache = renderer()->document().existingAXObjectCache())
-            cache->childrenChanged(this);
-    }
+    if (auto* cache = document().existingAXObjectCache())
+        cache->childrenChanged(this);
 }
 
 void HTMLSelectElement::recalcListItems(bool updateSelectedStates) const
@@ -857,13 +856,12 @@ void HTMLSelectElement::selectOption(int optionIndex, SelectOptionFlags flags)
 {
     bool shouldDeselect = !m_multiple || (flags & DeselectOtherOptions);
 
-    const Vector<HTMLElement*>& items = listItems();
+    auto& items = listItems();
     int listIndex = optionToListIndex(optionIndex);
 
     HTMLElement* element = nullptr;
-    if (listIndex >= 0) {
+    if (listIndex >= 0)
         element = items[listIndex];
-    }
 
     if (shouldDeselect)
         deselectItemsWithoutValidation(element);
@@ -899,7 +897,7 @@ void HTMLSelectElement::selectOption(int optionIndex, SelectOptionFlags flags)
 
 int HTMLSelectElement::optionToListIndex(int optionIndex) const
 {
-    const Vector<HTMLElement*>& items = listItems();
+    auto& items = listItems();
     int listSize = static_cast<int>(items.size());
     if (optionIndex < 0 || optionIndex >= listSize)
         return -1;
@@ -918,7 +916,7 @@ int HTMLSelectElement::optionToListIndex(int optionIndex) const
 
 int HTMLSelectElement::listToOptionIndex(int listIndex) const
 {
-    const Vector<HTMLElement*>& items = listItems();
+    auto& items = listItems();
     if (listIndex < 0 || listIndex >= static_cast<int>(items.size()) || !is<HTMLOptionElement>(*items[listIndex]))
         return -1;
 
@@ -977,7 +975,7 @@ FormControlState HTMLSelectElement::saveFormControlState() const
 
 size_t HTMLSelectElement::searchOptionsForValue(const String& value, size_t listIndexStart, size_t listIndexEnd) const
 {
-    const Vector<HTMLElement*>& items = listItems();
+    auto& items = listItems();
     size_t loopEndIndex = std::min(items.size(), listIndexEnd);
     for (size_t i = listIndexStart; i < loopEndIndex; ++i) {
         if (!is<HTMLOptionElement>(*items[i]))
@@ -992,7 +990,7 @@ void HTMLSelectElement::restoreFormControlState(const FormControlState& state)
 {
     recalcListItems();
 
-    const Vector<HTMLElement*>& items = listItems();
+    auto& items = listItems();
     size_t itemsSize = items.size();
     if (!itemsSize)
         return;
@@ -1085,6 +1083,7 @@ void HTMLSelectElement::reset()
 }
 
 #if !PLATFORM(WIN)
+
 bool HTMLSelectElement::platformHandleKeydownEvent(KeyboardEvent* event)
 {
     const Page* page = document().page();
@@ -1099,7 +1098,8 @@ bool HTMLSelectElement::platformHandleKeydownEvent(KeyboardEvent* event)
             // Calling focus() may cause us to lose our renderer. Return true so
             // that our caller doesn't process the event further, but don't set
             // the event as handled.
-            if (!is<RenderMenuList>(renderer()))
+            auto* renderer = this->renderer();
+            if (!is<RenderMenuList>(renderer))
                 return true;
 
             // Save the selection so it can be compared to the new selection
@@ -1107,7 +1107,7 @@ bool HTMLSelectElement::platformHandleKeydownEvent(KeyboardEvent* event)
             // gets called from RenderMenuList::valueChanged, which gets called
             // after the user makes a selection from the menu.
             saveLastSelection();
-            downcast<RenderMenuList>(*renderer()).showPopup();
+            downcast<RenderMenuList>(*renderer).showPopup();
             event->setDefaultHandled();
         }
         return true;
@@ -1115,11 +1115,13 @@ bool HTMLSelectElement::platformHandleKeydownEvent(KeyboardEvent* event)
 
     return false;
 }
+
 #endif
 
 void HTMLSelectElement::menuListDefaultEventHandler(Event* event)
 {
-    ASSERT(renderer() && renderer()->isMenuList());
+    ASSERT(renderer());
+    ASSERT(renderer()->isMenuList());
 
     const Page* page = document().page();
     RefPtr<RenderTheme> renderTheme = page ? &page->theme() : RenderTheme::defaultTheme();
@@ -1142,7 +1144,7 @@ void HTMLSelectElement::menuListDefaultEventHandler(Event* event)
 
         const String& keyIdentifier = keyboardEvent.keyIdentifier();
         bool handled = true;
-        const Vector<HTMLElement*>& listItems = this->listItems();
+        auto& listItems = this->listItems();
         int listIndex = optionToListIndex(selectedIndex());
 
         // When using caret browsing, we want to be able to move the focus
@@ -1196,9 +1198,9 @@ void HTMLSelectElement::menuListDefaultEventHandler(Event* event)
             if (keyCode == ' ' || keyCode == '\r') {
                 focus();
 
-                // Calling focus() may remove the renderer or change the
-                // renderer type.
-                if (!is<RenderMenuList>(renderer()))
+                // Calling focus() may remove the renderer or change the renderer type.
+                auto* renderer = this->renderer();
+                if (!is<RenderMenuList>(renderer))
                     return;
 
                 // Save the selection so it can be compared to the new selection
@@ -1206,16 +1208,16 @@ void HTMLSelectElement::menuListDefaultEventHandler(Event* event)
                 // gets called from RenderMenuList::valueChanged, which gets called
                 // after the user makes a selection from the menu.
                 saveLastSelection();
-                downcast<RenderMenuList>(*renderer()).showPopup();
+                downcast<RenderMenuList>(*renderer).showPopup();
                 handled = true;
             }
         } else if (renderTheme->popsMenuByArrowKeys()) {
             if (keyCode == ' ') {
                 focus();
 
-                // Calling focus() may remove the renderer or change the
-                // renderer type.
-                if (!is<RenderMenuList>(renderer()))
+                // Calling focus() may remove the renderer or change the renderer type.
+                auto* renderer = this->renderer();
+                if (!is<RenderMenuList>(renderer))
                     return;
 
                 // Save the selection so it can be compared to the new selection
@@ -1223,7 +1225,7 @@ void HTMLSelectElement::menuListDefaultEventHandler(Event* event)
                 // gets called from RenderMenuList::valueChanged, which gets called
                 // after the user makes a selection from the menu.
                 saveLastSelection();
-                downcast<RenderMenuList>(*renderer()).showPopup();
+                downcast<RenderMenuList>(*renderer).showPopup();
                 handled = true;
             } else if (keyCode == '\r') {
                 if (form())
@@ -1240,8 +1242,9 @@ void HTMLSelectElement::menuListDefaultEventHandler(Event* event)
     if (event->type() == eventNames().mousedownEvent && is<MouseEvent>(*event) && downcast<MouseEvent>(*event).button() == LeftButton) {
         focus();
 #if !PLATFORM(IOS)
-        if (is<RenderMenuList>(renderer())) {
-            auto& menuList = downcast<RenderMenuList>(*renderer());
+        auto* renderer = this->renderer();
+        if (is<RenderMenuList>(renderer)) {
+            auto& menuList = downcast<RenderMenuList>(*renderer);
             ASSERT(!menuList.popupIsVisible());
             // Save the selection so it can be compared to the new
             // selection when we call onChange during selectOption,
@@ -1277,21 +1280,21 @@ void HTMLSelectElement::updateSelectedState(int listIndex, bool multi, bool shif
     bool shiftSelect = m_multiple && shift;
     bool multiSelect = m_multiple && multi && !shift;
 
-    HTMLElement* clickedElement = listItems()[listIndex];
-    if (is<HTMLOptionElement>(*clickedElement)) {
+    auto& clickedElement = *listItems()[listIndex];
+    if (is<HTMLOptionElement>(clickedElement)) {
         // Keep track of whether an active selection (like during drag
         // selection), should select or deselect.
-        if (downcast<HTMLOptionElement>(*clickedElement).selected() && multiSelect)
+        if (downcast<HTMLOptionElement>(clickedElement).selected() && multiSelect)
             m_activeSelectionState = false;
         if (!m_activeSelectionState)
-            downcast<HTMLOptionElement>(*clickedElement).setSelectedState(false);
+            downcast<HTMLOptionElement>(clickedElement).setSelectedState(false);
     }
 
     // If we're not in any special multiple selection mode, then deselect all
     // other items, excluding the clicked option. If no option was clicked, then
     // this will deselect all items in the list.
     if (!shiftSelect && !multiSelect)
-        deselectItemsWithoutValidation(clickedElement);
+        deselectItemsWithoutValidation(&clickedElement);
 
     // If the anchor hasn't been set, and we're doing a single selection or a
     // shift selection, then initialize the anchor to the first selected index.
@@ -1299,8 +1302,8 @@ void HTMLSelectElement::updateSelectedState(int listIndex, bool multi, bool shif
         setActiveSelectionAnchorIndex(selectedIndex());
 
     // Set the selection state of the clicked option.
-    if (is<HTMLOptionElement>(*clickedElement) && !downcast<HTMLOptionElement>(*clickedElement).isDisabledFormControl())
-        downcast<HTMLOptionElement>(*clickedElement).setSelectedState(true);
+    if (is<HTMLOptionElement>(clickedElement) && !downcast<HTMLOptionElement>(clickedElement).isDisabledFormControl())
+        downcast<HTMLOptionElement>(clickedElement).setSelectedState(true);
 
     // If there was no selectedIndex() for the previous initialization, or If
     // we're doing a single selection, or a multiple selection (using cmd or
@@ -1315,18 +1318,21 @@ void HTMLSelectElement::updateSelectedState(int listIndex, bool multi, bool shif
 
 void HTMLSelectElement::listBoxDefaultEventHandler(Event* event)
 {
-    const Vector<HTMLElement*>& listItems = this->listItems();
+    auto& listItems = this->listItems();
 
     if (event->type() == eventNames().mousedownEvent && is<MouseEvent>(*event) && downcast<MouseEvent>(*event).button() == LeftButton) {
         focus();
+
         // Calling focus() may remove or change our renderer, in which case we don't want to handle the event further.
-        if (!is<RenderListBox>(renderer()))
+        auto* renderer = this->renderer();
+        if (!is<RenderListBox>(renderer))
             return;
+        auto& renderListBox = downcast<RenderListBox>(*renderer);
 
         // Convert to coords relative to the list box if needed.
         MouseEvent& mouseEvent = downcast<MouseEvent>(*event);
-        IntPoint localOffset = roundedIntPoint(renderer()->absoluteToLocal(mouseEvent.absoluteLocation(), UseTransforms));
-        int listIndex = downcast<RenderListBox>(*renderer()).listIndexAtOffset(toIntSize(localOffset));
+        IntPoint localOffset = roundedIntPoint(renderListBox.absoluteToLocal(mouseEvent.absoluteLocation(), UseTransforms));
+        int listIndex = renderListBox.listIndexAtOffset(toIntSize(localOffset));
         if (listIndex >= 0) {
             if (!isDisabledFormControl()) {
 #if PLATFORM(COCOA)
@@ -1340,13 +1346,14 @@ void HTMLSelectElement::listBoxDefaultEventHandler(Event* event)
 
             mouseEvent.setDefaultHandled();
         }
-    } else if (event->type() == eventNames().mousemoveEvent && is<MouseEvent>(*event) && !downcast<RenderBox>(*renderer()).canBeScrolledAndHasScrollableArea()) {
+    } else if (event->type() == eventNames().mousemoveEvent && is<MouseEvent>(*event) && !downcast<RenderListBox>(*renderer()).canBeScrolledAndHasScrollableArea()) {
         MouseEvent& mouseEvent = downcast<MouseEvent>(*event);
         if (mouseEvent.button() != LeftButton || !mouseEvent.buttonDown())
             return;
 
-        IntPoint localOffset = roundedIntPoint(renderer()->absoluteToLocal(mouseEvent.absoluteLocation(), UseTransforms));
-        int listIndex = downcast<RenderListBox>(*renderer()).listIndexAtOffset(toIntSize(localOffset));
+        auto& renderListBox = downcast<RenderListBox>(*renderer());
+        IntPoint localOffset = roundedIntPoint(renderListBox.absoluteToLocal(mouseEvent.absoluteLocation(), UseTransforms));
+        int listIndex = renderListBox.listIndexAtOffset(toIntSize(localOffset));
         if (listIndex >= 0) {
             if (!isDisabledFormControl()) {
                 if (m_multiple) {
@@ -1488,7 +1495,8 @@ void HTMLSelectElement::listBoxDefaultEventHandler(Event* event)
 
 void HTMLSelectElement::defaultEventHandler(Event* event)
 {
-    if (!renderer())
+    auto* renderer = this->renderer();
+    if (!renderer)
         return;
 
 #if !PLATFORM(IOS)
@@ -1497,7 +1505,7 @@ void HTMLSelectElement::defaultEventHandler(Event* event)
         return;
     }
 
-    if (renderer()->isMenuList())
+    if (renderer->isMenuList())
         menuListDefaultEventHandler(event);
     else 
         listBoxDefaultEventHandler(event);
@@ -1520,10 +1528,10 @@ void HTMLSelectElement::defaultEventHandler(Event* event)
 
 int HTMLSelectElement::lastSelectedListIndex() const
 {
-    const Vector<HTMLElement*>& items = listItems();
+    auto& items = listItems();
     for (size_t i = items.size(); i;) {
-        HTMLElement* element = items[--i];
-        if (is<HTMLOptionElement>(*element) && downcast<HTMLOptionElement>(*element).selected())
+        auto& element = *items[--i];
+        if (is<HTMLOptionElement>(element) && downcast<HTMLOptionElement>(element).selected())
             return i;
     }
     return -1;
@@ -1541,12 +1549,10 @@ int HTMLSelectElement::optionCount() const
 
 String HTMLSelectElement::optionAtIndex(int index) const
 {
-    const Vector<HTMLElement*>& items = listItems();
-    
-    HTMLElement* element = items[index];
-    if (!is<HTMLOptionElement>(*element) || downcast<HTMLOptionElement>(*element).isDisabledFormControl())
+    auto& element = *listItems()[index];
+    if (!is<HTMLOptionElement>(element) || downcast<HTMLOptionElement>(element).isDisabledFormControl())
         return String();
-    return downcast<HTMLOptionElement>(*element).textIndentedToRespectGroupLabel();
+    return downcast<HTMLOptionElement>(element).textIndentedToRespectGroupLabel();
 }
 
 void HTMLSelectElement::typeAheadFind(KeyboardEvent& event)
@@ -1575,13 +1581,13 @@ void HTMLSelectElement::accessKeySetSelectedIndex(int index)
         accessKeyAction(false);
     
     // If this index is already selected, unselect. otherwise update the selected index.
-    const Vector<HTMLElement*>& items = listItems();
+    auto& items = listItems();
     int listIndex = optionToListIndex(index);
     if (listIndex >= 0) {
-        HTMLElement* element = items[listIndex];
-        if (is<HTMLOptionElement>(*element)) {
-            if (downcast<HTMLOptionElement>(*element).selected())
-                downcast<HTMLOptionElement>(*element).setSelectedState(false);
+        auto& element = *items[listIndex];
+        if (is<HTMLOptionElement>(element)) {
+            if (downcast<HTMLOptionElement>(element).selected())
+                downcast<HTMLOptionElement>(element).setSelectedState(false);
             else
                 selectOption(index, DispatchChangeEvent | UserDriven);
         }
@@ -1599,7 +1605,7 @@ unsigned HTMLSelectElement::length() const
 {
     unsigned options = 0;
 
-    const Vector<HTMLElement*>& items = listItems();
+    auto& items = listItems();
     for (unsigned i = 0; i < items.size(); ++i) {
         if (is<HTMLOptionElement>(*items[i]))
             ++options;
index 0b5a61c..5517051 100644 (file)
  *
  */
 
-#ifndef HTMLTextAreaElement_h
-#define HTMLTextAreaElement_h
+#pragma once
 
 #include "HTMLTextFormControlElement.h"
 
 namespace WebCore {
 
 class BeforeTextInsertedEvent;
+class RenderTextControlMultiLine;
 class VisibleSelection;
 
 class HTMLTextAreaElement final : public HTMLTextFormControlElement {
@@ -63,6 +63,8 @@ public:
 
     bool willRespondToMouseClickEvents() override;
 
+    RenderTextControlMultiLine* renderer() const;
+
 private:
     HTMLTextAreaElement(const QualifiedName&, Document&, HTMLFormElement*);
 
@@ -132,5 +134,3 @@ private:
 };
 
 } //namespace
-
-#endif
index 1025736..d17cbe7 100644 (file)
@@ -24,7 +24,9 @@
  */
 
 #include "config.h"
+
 #if ENABLE(VIDEO)
+
 #include "HTMLVideoElement.h"
 
 #include "CSSPropertyNames.h"
@@ -87,8 +89,8 @@ void HTMLVideoElement::didAttachRenderers()
         if (!m_imageLoader)
             m_imageLoader = std::make_unique<HTMLImageLoader>(*this);
         m_imageLoader->updateFromElement();
-        if (renderer())
-            downcast<RenderImage>(*renderer()).imageResource().setCachedImage(m_imageLoader->image());
+        if (auto* renderer = this->renderer())
+            renderer->imageResource().setCachedImage(m_imageLoader->image());
     }
 }
 
@@ -121,8 +123,8 @@ void HTMLVideoElement::parseAttribute(const QualifiedName& name, const AtomicStr
                 m_imageLoader = std::make_unique<HTMLImageLoader>(*this);
             m_imageLoader->updateFromElementIgnoringPreviousError();
         } else {
-            if (renderer())
-                downcast<RenderImage>(*renderer()).imageResource().setCachedImage(nullptr);
+            if (auto* renderer = this->renderer())
+                renderer->imageResource().setCachedImage(nullptr);
         }
     }
 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
@@ -246,8 +248,10 @@ void HTMLVideoElement::setDisplayMode(DisplayMode mode)
             player()->setPoster(poster);
     }
 
-    if (renderer() && displayMode() != oldMode)
-        renderer()->updateFromElement();
+    if (auto* renderer = this->renderer()) {
+        if (displayMode() != oldMode)
+            renderer->updateFromElement();
+    }
 }
 
 void HTMLVideoElement::updateDisplayState()
index 9a1df7b..145eeb3 100644 (file)
 namespace WebCore {
 
 class HTMLImageLoader;
+class RenderVideo;
 
 class HTMLVideoElement final : public HTMLMediaElement {
 public:
-    static Ref<HTMLVideoElement> create(const QualifiedName&, Document&, bool);
+    static Ref<HTMLVideoElement> create(const QualifiedName&, Document&, bool createdByParser);
 
     WEBCORE_EXPORT unsigned videoWidth() const;
     WEBCORE_EXPORT unsigned videoHeight() const;
@@ -90,8 +91,10 @@ public:
     void exitToFullscreenModeWithoutAnimationIfPossible(HTMLMediaElementEnums::VideoFullscreenMode fromMode, HTMLMediaElementEnums::VideoFullscreenMode toMode);
 #endif
 
+    RenderVideo* renderer() const;
+
 private:
-    HTMLVideoElement(const QualifiedName&, Document&, bool);
+    HTMLVideoElement(const QualifiedName&, Document&, bool createdByParser);
 
     void scheduleResizeEvent() override;
     void scheduleResizeEventIfSizeChanged() override;
index 490b264..47d22b0 100644 (file)
  * THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef HTMLWBRElement_h
-#define HTMLWBRElement_h
+#pragma once
 
 #include "HTMLElement.h"
 
 namespace WebCore {
 
+class RenderLineBreak;
+
 class HTMLWBRElement final : public HTMLElement {
 public:
     static Ref<HTMLWBRElement> create(const QualifiedName&, Document&);
 
+    RenderLineBreak* renderer() const;
+
 private:
     HTMLWBRElement(const QualifiedName&, Document&);
 
@@ -41,6 +44,3 @@ private:
 };
 
 } // namespace WebCore
-
-#endif // HTMLWBRElement_h
-
index 2303545..4aa3285 100644 (file)
@@ -43,6 +43,7 @@
 #include "MainFrame.h"
 #include "Page.h"
 #include "PlatformMediaSessionManager.h"
+#include "RenderMedia.h"
 #include "RenderView.h"
 #include "ScriptController.h"
 #include "SourceBuffer.h"
@@ -228,8 +229,7 @@ bool MediaElementSession::canControlControlsManager(const HTMLMediaElement& elem
     if (!playbackPermitted(element))
         return false;
 
-    RenderBox* renderer = downcast<RenderBox>(element.renderer());
-    if (!renderer)
+    if (!element.renderer())
         return false;
 
     if (isElementLargeEnoughForMainContent(element))
@@ -510,7 +510,7 @@ static bool isMainContent(const HTMLMediaElement& element)
         return false;
 
     // Elements which have not yet been laid out, or which are not yet in the DOM, cannot be main content.
-    RenderBox* renderer = downcast<RenderBox>(element.renderer());
+    auto* renderer = element.renderer();
     if (!renderer)
         return false;
 
@@ -520,11 +520,10 @@ static bool isMainContent(const HTMLMediaElement& element)
     // Elements which are hidden by style, or have been scrolled out of view, cannot be main content.
     // But elements which have audio & video and are already playing should not stop playing because
     // they are scrolled off the page.
-    if (renderer->style().visibility() != VISIBLE
-        || (renderer->visibleInViewportState() != RenderElement::VisibleInViewport && !element.isPlaying())
-        ) {
+    if (renderer->style().visibility() != VISIBLE)
+        return false;
+    if (renderer->visibleInViewportState() != RenderElement::VisibleInViewport && !element.isPlaying())
         return false;
-    }
 
     // Main content elements must be in the main frame.
     Document& document = element.document();
@@ -561,7 +560,7 @@ static bool isElementLargeEnoughForMainContent(const HTMLMediaElement& element)
     static const double minimumAspectRatio = .5; // Slightly smaller than 16:9.
 
     // Elements which have not yet been laid out, or which are not yet in the DOM, cannot be main content.
-    RenderBox* renderer = downcast<RenderBox>(element.renderer());
+    auto* renderer = element.renderer();
     if (!renderer)
         return false;
 
index 4936156..7669416 100644 (file)
@@ -193,16 +193,16 @@ void TextFieldInputType::forwardEvent(Event* event)
     {
         element().document().updateStyleIfNeeded();
 
+        auto* renderer = element().renderer();
         if (element().renderer()) {
-            RenderTextControlSingleLine& renderTextControl = downcast<RenderTextControlSingleLine>(*element().renderer());
             if (event->type() == eventNames().blurEvent) {
-                if (RenderTextControlInnerBlock* innerTextRenderer = innerTextElement()->renderer()) {
-                    if (RenderLayer* innerLayer = innerTextRenderer->layer()) {
-                        ScrollOffset scrollOffset(!renderTextControl.style().isLeftToRightDirection() ? innerLayer->scrollWidth() : 0, 0);
+                if (auto* innerTextRenderer = innerTextElement()->renderer()) {
+                    if (auto* innerLayer = innerTextRenderer->layer()) {
+                        bool isLeftToRightDirection = downcast<RenderTextControlSingleLine>(*renderer).style().isLeftToRightDirection();
+                        ScrollOffset scrollOffset(isLeftToRightDirection ? 0 : innerLayer->scrollWidth(), 0);
                         innerLayer->scrollToOffset(scrollOffset, RenderLayer::ScrollOffsetClamped);
                     }
                 }
-
                 capsLockStateMayHaveChanged();
             } else if (event->type() == eventNames().focusEvent)
                 capsLockStateMayHaveChanged();
index a61087e..3bad9fd 100644 (file)
@@ -253,39 +253,46 @@ void SliderThumbElement::dragFrom(const LayoutPoint& point)
 void SliderThumbElement::setPositionFromPoint(const LayoutPoint& absolutePoint)
 {
     RefPtr<HTMLInputElement> input = hostInput();
-    if (!input || !input->renderer() || !renderBox())
+    if (!input)
         return;
 
-    HTMLElement* trackElement = input->sliderTrackElement();
-    if (!trackElement->renderBox())
+    auto* inputRenderer = input->renderBox();
+    if (!inputRenderer)
+        return;
+
+    auto* thumbRenderer = renderBox();
+    if (!thumbRenderer)
+        return;
+
+    ASSERT(input->sliderTrackElement());
+    auto* trackRenderer = input->sliderTrackElement()->renderBox();
+    if (!trackRenderer)
         return;
 
     // Do all the tracking math relative to the input's renderer's box.
-    RenderBox& inputRenderer = downcast<RenderBox>(*input->renderer());
-    RenderBox& trackRenderer = *trackElement->renderBox();
 
     bool isVertical = hasVerticalAppearance(*input);
-    bool isLeftToRightDirection = renderBox()->style().isLeftToRightDirection();
+    bool isLeftToRightDirection = thumbRenderer->style().isLeftToRightDirection();
     
-    LayoutPoint offset(inputRenderer.absoluteToLocal(absolutePoint, UseTransforms));
-    FloatRect trackBoundingBox = trackRenderer.localToContainerQuad(FloatRect(0, 0, trackRenderer.width(), trackRenderer.height()), &inputRenderer).enclosingBoundingBox();
+    auto offset = inputRenderer->absoluteToLocal(absolutePoint, UseTransforms);
+    auto trackBoundingBox = trackRenderer->localToContainerQuad(FloatRect { { }, trackRenderer->size() }, inputRenderer).enclosingBoundingBox();
 
     LayoutUnit trackLength;
     LayoutUnit position;
     if (isVertical) {
-        trackLength = trackRenderer.contentHeight() - renderBox()->height();
-        position = offset.y() - renderBox()->height() / 2 - trackBoundingBox.y() - renderBox()->marginBottom();
+        trackLength = trackRenderer->contentHeight() - thumbRenderer->height();
+        position = offset.y() - thumbRenderer->height() / 2 - trackBoundingBox.y() - thumbRenderer->marginBottom();
     } else {
-        trackLength = trackRenderer.contentWidth() - renderBox()->width();
-        position = offset.x() - renderBox()->width() / 2 - trackBoundingBox.x();
-        position -= isLeftToRightDirection ? renderBox()->marginLeft() : renderBox()->marginRight();
+        trackLength = trackRenderer->contentWidth() - thumbRenderer->width();
+        position = offset.x() - thumbRenderer->width() / 2 - trackBoundingBox.x();
+        position -= isLeftToRightDirection ? thumbRenderer->marginLeft() : thumbRenderer->marginRight();
     }
 
     position = std::max<LayoutUnit>(0, std::min(position, trackLength));
-    const Decimal ratio = Decimal::fromDouble(static_cast<double>(position) / trackLength);
-    const Decimal fraction = isVertical || !isLeftToRightDirection ? Decimal(1) - ratio : ratio;
-    StepRange stepRange(input->createStepRange(RejectAny));
-    Decimal value = stepRange.clampValue(stepRange.valueFromProportion(fraction));
+    auto ratio = Decimal::fromDouble(static_cast<double>(position) / trackLength);
+    auto fraction = isVertical || !isLeftToRightDirection ? Decimal(1) - ratio : ratio;
+    auto stepRange = input->createStepRange(RejectAny);
+    auto value = stepRange.clampValue(stepRange.valueFromProportion(fraction));
 
 #if ENABLE(DATALIST_ELEMENT)
     const LayoutUnit snappingThreshold = renderer()->theme().sliderTickSnappingThreshold();
index 398fe9a..4e74bfd 100644 (file)
@@ -178,13 +178,13 @@ Ref<SearchFieldResultsButtonElement> SearchFieldResultsButtonElement::create(Doc
 void SearchFieldResultsButtonElement::defaultEventHandler(Event* event)
 {
     // On mousedown, bring up a menu, if needed
-    HTMLInputElement* input = downcast<HTMLInputElement>(shadowHost());
+    auto* input = downcast<HTMLInputElement>(shadowHost());
     if (input && event->type() == eventNames().mousedownEvent && is<MouseEvent>(*event) && downcast<MouseEvent>(*event).button() == LeftButton) {
         input->focus();
         input->select();
 #if !PLATFORM(IOS)
-        if (RenderObject* renderer = input->renderer()) {
-            RenderSearchField& searchFieldRenderer = downcast<RenderSearchField>(*renderer);
+        if (auto* renderer = input->renderer()) {
+            auto& searchFieldRenderer = downcast<RenderSearchField>(*renderer);
             if (searchFieldRenderer.popupIsVisible())
                 searchFieldRenderer.hidePopup();
             else if (input->maxResults() > 0)
index 1d23390..f033989 100644 (file)
@@ -1775,14 +1775,11 @@ bool EventHandler::handleMouseDoubleClickEvent(const PlatformMouseEvent& platfor
 
 static ScrollableArea* enclosingScrollableArea(Node* node)
 {
-    if (!node)
-        return nullptr;
-
-    for (auto element = node; element; element = element->parentOrShadowHostNode()) {
-        if (is<HTMLIFrameElement>(*element) || is<HTMLHtmlElement>(*element) || is<HTMLDocument>(*element))
+    for (auto ancestor = node; ancestor; ancestor = ancestor->parentOrShadowHostNode()) {
+        if (is<HTMLIFrameElement>(*ancestor) || is<HTMLHtmlElement>(*ancestor) || is<HTMLDocument>(*ancestor))
             return nullptr;
 
-        auto renderer = element->renderer();
+        auto renderer = ancestor->renderer();
         if (!renderer)
             continue;
 
index a5a6f43..dba3c1e 100644 (file)
@@ -222,14 +222,11 @@ void PrintContext::end()
     m_frame->setPrinting(false, FloatSize(), FloatSize(), 0, AdjustViewSize);
 }
 
-static RenderBoxModelObject* enclosingBoxModelObject(RenderObject* object)
+static inline RenderBoxModelObject* enclosingBoxModelObject(RenderElement* renderer)
 {
-
-    while (object && !is<RenderBoxModelObject>(*object))
-        object = object->parent();
-    if (!object)
-        return nullptr;
-    return downcast<RenderBoxModelObject>(object);
+    while (renderer && !is<RenderBoxModelObject>(*renderer))
+        renderer = renderer->parent();
+    return downcast<RenderBoxModelObject>(renderer);
 }
 
 int PrintContext::pageNumberForElement(Element* element, const FloatSize& pageSizeInPixels)
@@ -238,7 +235,7 @@ int PrintContext::pageNumberForElement(Element* element, const FloatSize& pageSi
     RefPtr<Element> elementRef(element);
     element->document().updateLayout();
 
-    RenderBoxModelObject* box = enclosingBoxModelObject(element->renderer());
+    auto* box = enclosingBoxModelObject(element->renderer());
     if (!box)
         return -1;
 
index 52b3355..d38f043 100644 (file)
@@ -419,15 +419,11 @@ static void deflateIfOverlapped(LayoutRect& a, LayoutRect& b)
 
 bool isScrollableNode(const Node* node)
 {
-    ASSERT(!node->isDocumentNode());
-
     if (!node)
         return false;
-
-    if (RenderObject* renderer = node->renderer())
-        return is<RenderBox>(*renderer) && downcast<RenderBox>(*renderer).canBeScrolledAndHasScrollableArea() && node->hasChildNodes();
-
-    return false;
+    ASSERT(!node->isDocumentNode());
+    auto* renderer = node->renderer();
+    return is<RenderBox>(renderer) && downcast<RenderBox>(*renderer).canBeScrolledAndHasScrollableArea() && node->hasChildNodes();
 }
 
 Node* scrollableEnclosingBoxOrParentFrameForNodeInDirection(FocusDirection direction, Node* node)
index 6b0dbcf..d688505 100644 (file)
@@ -41,7 +41,7 @@
 #import <QuartzCore/CoreAnimation.h>
 #import <WebCore/FrameView.h>
 #import <WebCore/HTMLVideoElement.h>
-#import <WebCore/RenderElement.h>
+#import <WebCore/RenderVideo.h>
 #import <WebCore/WebCoreThreadRun.h>
 
 SOFT_LINK_FRAMEWORK(UIKit)
@@ -81,10 +81,13 @@ using namespace WebCore;
 
 static IntRect elementRectInWindow(HTMLVideoElement* videoElement)
 {
-    if (!videoElement || !videoElement->renderer() || !videoElement->document().view())
-        return IntRect();
-    
-    return videoElement->document().view()->convertToContainingWindow(videoElement->renderer()->absoluteBoundingBoxRect());
+    if (!videoElement)
+        return { };
+    auto* renderer = videoElement->renderer();
+    auto* view = videoElement->document().view();
+    if (!renderer || !view)
+        return { };
+    return view->convertToContainingWindow(renderer->absoluteBoundingBoxRect());
 }
 
 class WebVideoFullscreenControllerContext;
index 6afc62e..235586b 100644 (file)
  * THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef RenderAttachment_h
-#define RenderAttachment_h
+#pragma once
 
 #if ENABLE(ATTACHMENT_ELEMENT)
 
+#include "HTMLAttachmentElement.h"
 #include "RenderReplaced.h"
 
 namespace WebCore {
 
-class HTMLAttachmentElement;
-
 class RenderAttachment final : public RenderReplaced {
 public:
     RenderAttachment(HTMLAttachmentElement&, RenderStyle&&);
@@ -54,9 +52,13 @@ private:
     int baselinePosition(FontBaseline, bool, LineDirectionMode, LinePositionMode) const override;
 };
 
+inline RenderAttachment* HTMLAttachmentElement::renderer() const
+{
+    return downcast<RenderAttachment>(HTMLElement::renderer());
+}
+
 } // namespace WebCore
 
 SPECIALIZE_TYPE_TRAITS_RENDER_OBJECT(RenderAttachment, isAttachment())
 
 #endif // ENABLE(ATTACHMENT_ELEMENT)
-#endif // RenderAttachment_h
index 1f26286..052b4ff 100644 (file)
@@ -25,6 +25,7 @@
 #include "RenderFrame.h"
 
 #include "HTMLFrameElement.h"
+#include "RenderFrameSet.h"
 
 namespace WebCore {
 
index 61931bc..7cb6b67 100644 (file)
  *
  */
 
-#ifndef RenderFrame_h
-#define RenderFrame_h
+#pragma once
 
+#include "HTMLFrameElement.h"
 #include "RenderFrameBase.h"
-#include "RenderFrameSet.h"
 
 namespace WebCore {
 
-class HTMLFrameElement;
+struct FrameEdgeInfo;
 
 class RenderFrame final : public RenderFrameBase {
 public:
@@ -37,17 +36,20 @@ public:
     HTMLFrameElement& frameElement() const;
     FrameEdgeInfo edgeInfo() const;
 
+    void updateFromElement() final;
+
 private:
     void frameOwnerElement() const = delete;
 
-    const char* renderName() const override { return "RenderFrame"; }
-    bool isFrame() const override { return true; }
-
-    void updateFromElement() override;
+    const char* renderName() const final { return "RenderFrame"; }
+    bool isFrame() const final { return true; }
 };
 
+inline RenderFrame* HTMLFrameElement::renderer() const
+{
+    return downcast<RenderFrame>(HTMLFrameElementBase::renderer());
+}
+
 } // namespace WebCore
 
 SPECIALIZE_TYPE_TRAITS_RENDER_OBJECT(RenderFrame, isFrame())
-
-#endif // RenderFrame_h
index 59cc1a3..56b138d 100644 (file)
@@ -106,10 +106,13 @@ void RenderLayer::FilterInfo::updateReferenceFilterClients(const FilterOperation
             m_externalSVGReferences.append(cachedSVGDocument);
         } else {
             // Reference is internal; add layer as a client so we can trigger filter repaint on SVG attribute change.
-            Element* filter = m_layer.renderer().document().getElementById(referenceOperation.fragment());
-            if (!filter || !is<RenderSVGResourceFilter>(filter->renderer()))
+            auto* filter = m_layer.renderer().document().getElementById(referenceOperation.fragment());
+            if (!filter)
                 continue;
-            downcast<RenderSVGResourceFilter>(*filter->renderer()).addClientRenderLayer(&m_layer);
+            auto* renderer = filter->renderer();
+            if (!is<RenderSVGResourceFilter>(renderer))
+                continue;
+            downcast<RenderSVGResourceFilter>(*renderer).addClientRenderLayer(&m_layer);
             m_internalSVGReferences.append(filter);
         }
     }
index 67ab5cb..7457d48 100644 (file)
@@ -23,8 +23,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
  */
 
-#ifndef RenderMedia_h
-#define RenderMedia_h
+#pragma once
 
 #if ENABLE(VIDEO)
 
@@ -60,10 +59,13 @@ private:
     void styleDidChange(StyleDifference, const RenderStyle* oldStyle) final;
 };
 
+inline RenderMedia* HTMLMediaElement::renderer() const
+{
+    return downcast<RenderMedia>(HTMLElement::renderer());
+}
+
 } // namespace WebCore
 
 SPECIALIZE_TYPE_TRAITS_RENDER_OBJECT(RenderMedia, isMedia())
 
 #endif // ENABLE(VIDEO)
-
-#endif // RenderMedia_h
index dd49bcf..aaf7aa7 100644 (file)
  *
  */
 
-#ifndef RenderTextControlMultiLine_h
-#define RenderTextControlMultiLine_h
+#pragma once
 
+#include "HTMLTextAreaElement.h"
 #include "RenderTextControl.h"
 
 namespace WebCore {
 
-class HTMLTextAreaElement;
-
 class RenderTextControlMultiLine final : public RenderTextControl {
 public:
     RenderTextControlMultiLine(HTMLTextAreaElement&, RenderStyle&&);
@@ -50,8 +48,11 @@ private:
     RenderObject* layoutSpecialExcludedChild(bool relayoutChildren) override;
 };
 
+inline RenderTextControlMultiLine* HTMLTextAreaElement::renderer() const
+{
+    return downcast<RenderTextControlMultiLine>(HTMLTextFormControlElement::renderer());
+}
+
 } // namespace WebCore
 
 SPECIALIZE_TYPE_TRAITS_RENDER_OBJECT(RenderTextControlMultiLine, isTextArea())
-
-#endif // RenderTextControlMultiLine_h
index 0edef5b..caf58e8 100644 (file)
@@ -277,39 +277,41 @@ bool RenderVideo::requiresImmediateCompositing() const
 }
 
 #if ENABLE(FULLSCREEN_API)
-static const RenderBlock* rendererPlaceholder(const RenderObject* renderer)
+
+static const RenderBlock* placeholder(const RenderVideo& renderer)
 {
-    RenderObject* parent = renderer->parent();
+    auto* parent = renderer.parent();
     return is<RenderFullScreen>(parent) ? downcast<RenderFullScreen>(*parent).placeholder() : nullptr;
 }
 
 LayoutUnit RenderVideo::offsetLeft() const
 {
-    if (const RenderBlock* block = rendererPlaceholder(this))
+    if (auto* block = placeholder(*this))
         return block->offsetLeft();
     return RenderMedia::offsetLeft();
 }
 
 LayoutUnit RenderVideo::offsetTop() const
 {
-    if (const RenderBlock* block = rendererPlaceholder(this))
+    if (auto* block = placeholder(*this))
         return block->offsetTop();
     return RenderMedia::offsetTop();
 }
 
 LayoutUnit RenderVideo::offsetWidth() const
 {
-    if (const RenderBlock* block = rendererPlaceholder(this))
+    if (auto* block = placeholder(*this))
         return block->offsetWidth();
     return RenderMedia::offsetWidth();
 }
 
 LayoutUnit RenderVideo::offsetHeight() const
 {
-    if (const RenderBlock* block = rendererPlaceholder(this))
+    if (auto* block = placeholder(*this))
         return block->offsetHeight();
     return RenderMedia::offsetHeight();
 }
+
 #endif
 
 bool RenderVideo::foregroundIsKnownToBeOpaqueInRect(const LayoutRect& localRect, unsigned maxDepthToTest) const
index 5b304ae..4dae609 100644 (file)
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
  */
 
-#ifndef RenderVideo_h
-#define RenderVideo_h
+#pragma once
 
 #if ENABLE(VIDEO)
 
+#include "HTMLVideoElement.h"
 #include "RenderMedia.h"
 
 namespace WebCore {
 
-class HTMLVideoElement;
-
 class RenderVideo final : public RenderMedia {
 public:
     RenderVideo(HTMLVideoElement&, RenderStyle&&);
@@ -52,47 +50,51 @@ public:
 
     bool shouldDisplayVideo() const;
 
+    void updateFromElement() final;
+
 private:
     void mediaElement() const = delete;
 
-    void updateFromElement() override;
-
-    void intrinsicSizeChanged() override;
+    void intrinsicSizeChanged() final;
     LayoutSize calculateIntrinsicSize();
     bool updateIntrinsicSize();
 
-    void imageChanged(WrappedImagePtr, const IntRect*) override;
+    void imageChanged(WrappedImagePtr, const IntRect*) final;
 
-    const char* renderName() const override { return "RenderVideo"; }
+    const char* renderName() const final { return "RenderVideo"; }
 
-    bool requiresLayer() const override { return true; }
-    bool isVideo() const override { return true; }
+    bool requiresLayer() const final { return true; }
+    bool isVideo() const final { return true; }
 
-    void paintReplaced(PaintInfo&, const LayoutPoint&) override;
+    void paintReplaced(PaintInfo&, const LayoutPoint&) final;
 
-    void layout() override;
+    void layout() final;
 
-    LayoutUnit computeReplacedLogicalWidth(ShouldComputePreferred  = ComputeActual) const override;
-    LayoutUnit computeReplacedLogicalHeight() const override;
-    LayoutUnit minimumReplacedHeight() const override;
+    LayoutUnit computeReplacedLogicalWidth(ShouldComputePreferred  = ComputeActual) const final;
+    LayoutUnit computeReplacedLogicalHeight() const final;
+    LayoutUnit minimumReplacedHeight() const final;
 
 #if ENABLE(FULLSCREEN_API)
-    LayoutUnit offsetLeft() const override;
-    LayoutUnit offsetTop() const override;
-    LayoutUnit offsetWidth() const override;
-    LayoutUnit offsetHeight() const override;
+    LayoutUnit offsetLeft() const final;
+    LayoutUnit offsetTop() const final;
+    LayoutUnit offsetWidth() const final;
+    LayoutUnit offsetHeight() const final;
 #endif
 
     void updatePlayer();
 
-    bool foregroundIsKnownToBeOpaqueInRect(const LayoutRect& localRect, unsigned maxDepthToTest) const override;
+    bool foregroundIsKnownToBeOpaqueInRect(const LayoutRect& localRect, unsigned maxDepthToTest) const final;
 
     LayoutSize m_cachedImageSize;
 };
 
+inline RenderVideo* HTMLVideoElement::renderer() const
+{
+    return downcast<RenderVideo>(HTMLMediaElement::renderer());
+}
+
 } // namespace WebCore
 
 SPECIALIZE_TYPE_TRAITS_RENDER_OBJECT(RenderVideo, isVideo())
 
 #endif // ENABLE(VIDEO)
-#endif // RenderVideo_h
index 470d7c1..94cf836 100644 (file)
@@ -85,7 +85,7 @@ void SVGGElement::svgAttributeChanged(const QualifiedName& attrName)
 
 RenderPtr<RenderElement> SVGGElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
 {
-    // SVG 1.1 testsuite explicitely uses constructs like <g display="none"><linearGradient>
+    // SVG 1.1 testsuite explicitly uses constructs like <g display="none"><linearGradient>
     // We still have to create renderers for the <g> & <linearGradient> element, though the
     // subtree may be hidden - we only want the resource renderers to exist so they can be
     // referenced from somewhere else.
index 87dcd87..ddb2aa0 100644 (file)
@@ -163,7 +163,6 @@ FloatRect SVGGraphicsElement::getBBox(StyleUpdateStrategy styleUpdateStrategy)
 
 RenderPtr<RenderElement> SVGGraphicsElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
 {
-    // By default, any subclass is expected to do path-based drawing
     return createRenderer<RenderSVGPath>(*this, WTFMove(style));
 }
 
index 7cdbab4..badf88c 100644 (file)
@@ -414,7 +414,6 @@ FloatRect SVGPathElement::getBBox(StyleUpdateStrategy styleUpdateStrategy)
 
 RenderPtr<RenderElement> SVGPathElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
 {
-    // By default, any subclass is expected to do path-based drawing
     return createRenderer<RenderSVGPath>(*this, WTFMove(style));
 }
 
index 9d1f17d..ffd9c2b 100644 (file)
@@ -1,3 +1,27 @@
+2016-05-31  Darin Adler  <darin@apple.com>
+
+        Audit RenderObject casts and fix problems and style issues found
+        https://bugs.webkit.org/show_bug.cgi?id=158221
+
+        Reviewed by Chris Dumez.
+
+        * Misc/WebNSPasteboardExtras.mm:
+        (imageFromElement): Use auto and tighten the logic a bit.
+        (-[NSPasteboard _web_declareAndWriteDragImageForElement:URL:title:archive:source:]):
+        Use auto and added a comment about this not using imageFromElement.
+
+        * Plugins/WebBaseNetscapePluginView.mm:
+        (-[WebBaseNetscapePluginView _windowClipRect]): Consistently cast to
+        RenderEmbeddedObject, which is the class used for renderers for plug-ins.
+        (-[WebBaseNetscapePluginView inFlatteningPaint]): Ditto.
+        (-[WebBaseNetscapePluginView invalidatePluginContentRect:]): Ditto.
+        (-[WebBaseNetscapePluginView actualVisibleRectInWindow]): Ditto.
+
+        * WebCoreSupport/WebFrameLoaderClient.mm:
+        (WebFrameLoaderClient::createPlugin): Changed code so it does a null check
+        rather than assuming the renderer is non-null.
+        (WebFrameLoaderClient::createJavaAppletWidget): Ditto.
+
 2016-05-31  Yusuke Suzuki  <utatane.tea@gmail.com>
 
         Unreviewed, roll out r201481, r201523: 0.3% regression in Octane code-load
index d083b6b..f382736 100644 (file)
@@ -219,15 +219,16 @@ static NSArray *_writableTypesForImageWithArchive (void)
 
 static CachedImage* imageFromElement(DOMElement *domElement)
 {
-    Element* element = core(domElement);
+    auto* element = core(domElement);
     if (!element)
         return nullptr;
-    
-    ASSERT(element->renderer());
-    auto& imageRenderer = downcast<RenderImage>(*element->renderer());
-    if (!imageRenderer.cachedImage() || imageRenderer.cachedImage()->errorOccurred())
+    auto* renderer = element->renderer();
+    if (!is<RenderImage>(renderer))
+        return nullptr;
+    auto* image = downcast<RenderImage>(*renderer).cachedImage();
+    if (!image || image->errorOccurred())
         return nullptr;
-    return imageRenderer.cachedImage();
+    return image;
 }
 
 - (void)_web_writeImage:(NSImage *)image
@@ -275,7 +276,8 @@ static CachedImage* imageFromElement(DOMElement *domElement)
     RetainPtr<NSMutableArray> types = adoptNS([[NSMutableArray alloc] initWithObjects:NSFilesPromisePboardType, nil]);
     if (auto* renderer = core(element)->renderer()) {
         if (is<RenderImage>(*renderer)) {
-            if (CachedImage* image = downcast<RenderImage>(*renderer).cachedImage()) {
+            if (auto* image = downcast<RenderImage>(*renderer).cachedImage()) {
+                // FIXME: This doesn't check errorOccured the way imageFromElement does.
                 extension = image->image()->filenameExtension();
                 if (![extension length])
                     return nullptr;
index 038a1f2..0e6fffe 100644 (file)
@@ -40,7 +40,6 @@
 #import "WebNSURLRequestExtras.h"
 #import "WebView.h"
 #import "WebViewInternal.h"
-
 #import <WebCore/AuthenticationCF.h>
 #import <WebCore/AuthenticationMac.h>
 #import <WebCore/BitmapImage.h>
@@ -53,8 +52,8 @@
 #import <WebCore/HTMLPlugInElement.h>
 #import <WebCore/Page.h>
 #import <WebCore/ProtectionSpace.h>
+#import <WebCore/RenderEmbeddedObject.h>
 #import <WebCore/RenderView.h>
-#import <WebCore/RenderWidget.h>
 #import <WebCore/SecurityOrigin.h>
 #import <WebCore/WebCoreObjCExtras.h>
 #import <WebKitLegacy/DOMPrivate.h>
@@ -282,10 +281,9 @@ using namespace WebCore;
 - (NSRect)_windowClipRect
 {
     auto* renderer = _element->renderer();
-    if (!renderer)
+    if (!is<RenderEmbeddedObject>(renderer))
         return NSZeroRect;
-
-    return downcast<RenderWidget>(*renderer).windowClipRect();
+    return downcast<RenderEmbeddedObject>(*renderer).windowClipRect();
 }
 
 - (NSRect)visibleRect
@@ -444,11 +442,10 @@ using namespace WebCore;
 
 - (BOOL)inFlatteningPaint
 {
-    RenderObject* renderer = _element->renderer();
-    if (renderer)
-        return renderer->view().frameView().paintBehavior() & PaintBehaviorFlattenCompositingLayers;
-
-    return NO;
+    auto* renderer = _element->renderer();
+    if (!is<RenderEmbeddedObject>(renderer))
+        return NO;
+    return !!(downcast<RenderEmbeddedObject>(*renderer).view().frameView().paintBehavior() & PaintBehaviorFlattenCompositingLayers);
 }
 
 - (BOOL)supportsSnapshotting
@@ -855,23 +852,23 @@ using namespace WebCore;
 
 - (void)invalidatePluginContentRect:(NSRect)rect
 {
-    if (RenderBoxModelObject* renderer = downcast<RenderBoxModelObject>(_element->renderer())) {
-        IntRect contentRect(rect);
-        contentRect.move(renderer->borderLeft() + renderer->paddingLeft(), renderer->borderTop() + renderer->paddingTop());
-        
-        renderer->repaintRectangle(contentRect);
-    }
+    auto* renderer = _element->renderer();
+    if (!is<RenderEmbeddedObject>(renderer))
+        return;
+    auto& object = downcast<RenderEmbeddedObject>(*renderer);
+    IntRect contentRect(rect);
+    contentRect.move(object.borderLeft() + object.paddingLeft(), object.borderTop() + object.paddingTop());
+    object.repaintRectangle(contentRect);
 }
 
 - (NSRect)actualVisibleRectInWindow
 {
     auto* renderer = _element->renderer();
-    if (!renderer)
+    if (!is<RenderEmbeddedObject>(renderer))
         return NSZeroRect;
-
-    IntRect widgetRect = renderer->pixelSnappedAbsoluteClippedOverflowRect();
-    widgetRect = renderer->view().frameView().contentsToWindow(widgetRect);
-    return intersection(downcast<RenderWidget>(*renderer).windowClipRect(), widgetRect);
+    auto& object = downcast<RenderEmbeddedObject>(*renderer);
+    auto widgetRect = object.view().frameView().contentsToWindow(object.pixelSnappedAbsoluteClippedOverflowRect());
+    return intersection(object.windowClipRect(), widgetRect);
 }
 
 - (CALayer *)pluginLayer
index 5884c12..2e5f304 100644 (file)
@@ -2000,7 +2000,7 @@ RefPtr<Widget> WebFrameLoaderClient::createPlugin(const IntSize& size, HTMLPlugI
     if (pluginPackage) {
         if (WKShouldBlockPlugin([pluginPackage bundleIdentifier], [pluginPackage bundleVersion])) {
             errorCode = WebKitErrorBlockedPlugInVersion;
-            if (is<RenderEmbeddedObject>(*element->renderer()))
+            if (is<RenderEmbeddedObject>(element->renderer()))
                 downcast<RenderEmbeddedObject>(*element->renderer()).setPluginUnavailabilityReason(RenderEmbeddedObject::InsecurePluginVersion);
         } else {
             if ([pluginPackage isKindOfClass:[WebPluginPackage class]])
@@ -2105,7 +2105,7 @@ PassRefPtr<Widget> WebFrameLoaderClient::createJavaAppletWidget(const IntSize& s
     if (pluginPackage) {
         if (WKShouldBlockPlugin([pluginPackage bundleIdentifier], [pluginPackage bundleVersion])) {
             errorCode = WebKitErrorBlockedPlugInVersion;
-            if (is<RenderEmbeddedObject>(*element->renderer()))
+            if (is<RenderEmbeddedObject>(element->renderer()))
                 downcast<RenderEmbeddedObject>(*element->renderer()).setPluginUnavailabilityReason(RenderEmbeddedObject::InsecurePluginVersion);
         } else {
 #if ENABLE(NETSCAPE_PLUGIN_API)
@@ -2183,10 +2183,9 @@ void WebFrameLoaderClient::dispatchDidClearWindowObjectInWorld(DOMWrapperWorld&
     if (implementations->didCreateJavaScriptContextForFrameFunc) {
         CallFrameLoadDelegate(implementations->didCreateJavaScriptContextForFrameFunc, webView, @selector(webView:didCreateJavaScriptContext:forFrame:),
             script.javaScriptContext(), m_webFrame.get());
-    } else if (implementations->didClearWindowObjectForFrameFunc) {
-#else
-    if (implementations->didClearWindowObjectForFrameFunc) {
+    } else
 #endif
+    if (implementations->didClearWindowObjectForFrameFunc) {
         CallFrameLoadDelegate(implementations->didClearWindowObjectForFrameFunc, webView, @selector(webView:didClearWindowObject:forFrame:),
             script.windowScriptObject(), m_webFrame.get());
     } else if (implementations->windowScriptObjectAvailableFunc) {
index 3fd7e8f..e49bf33 100644 (file)
@@ -1,3 +1,27 @@
+2016-05-31  Darin Adler  <darin@apple.com>
+
+        Audit RenderObject casts and fix problems and style issues found
+        https://bugs.webkit.org/show_bug.cgi?id=158221
+
+        Reviewed by Chris Dumez.
+
+        * Shared/WebRenderObject.cpp:
+        (WebKit::WebRenderObject::WebRenderObject): Tightened up the code that
+        builds the tree of objects; fewer local variables.
+
+        * WebProcess/Plugins/PluginView.cpp:
+        (WebKit::PluginView::invalidateRect): Cast to RenderEmbeddedObject since
+        that is the class used for plug-ins.
+        (WebKit::PluginView::pluginProcessCrashed): Ditto.
+        * WebProcess/WebPage/WebPage.cpp:
+        (WebKit::WebPage::createPlugin): Ditto.
+        (WebKit::WebPage::plugInIsPrimarySize): Check the renderer for null here.
+        Did not change this to RenderEmbeddedObject, though, because I wasn't
+        absolute certain this is only called with that type of renderer.
+
+        * WebProcess/WebPage/ios/WebPageIOS.mm:
+        (WebKit::WebPage::rangeForWebSelectionAtPosition): Tweaked.
+
 2016-06-01  Brady Eidson  <beidson@apple.com>
 
         Modernize lambda usage for all callers of RunLoop::dispatch() (take 2).
index c3cdee6..afc4336 100644 (file)
@@ -113,21 +113,14 @@ WebRenderObject::WebRenderObject(RenderObject* renderer, bool shouldIncludeDesce
 
     Vector<RefPtr<API::Object>> children;
 
-    for (RenderObject* coreChild = renderer->firstChildSlow(); coreChild; coreChild = coreChild->nextSibling()) {
-        RefPtr<WebRenderObject> child = adoptRef(new WebRenderObject(coreChild, shouldIncludeDescendants));
-        children.append(WTFMove(child));
-    }
+    for (auto* coreChild = renderer->firstChildSlow(); coreChild; coreChild = coreChild->nextSibling())
+        children.append(adoptRef(*new WebRenderObject(coreChild, shouldIncludeDescendants)));
 
     if (is<RenderWidget>(*renderer)) {
-        if (Widget* widget = downcast<RenderWidget>(*renderer).widget()) {
-            if (is<FrameView>(*widget)) {
-                FrameView& frameView = downcast<FrameView>(*widget);
-                if (RenderView* coreContentRenderer = frameView.frame().contentRenderer()) {
-                    RefPtr<WebRenderObject> contentRenderer = adoptRef(new WebRenderObject(coreContentRenderer, shouldIncludeDescendants));
-
-                    children.append(WTFMove(contentRenderer));
-                }
-            }
+        auto* widget = downcast<RenderWidget>(*renderer).widget();
+        if (is<FrameView>(widget)) {
+            if (auto* coreContentRenderer = downcast<FrameView>(*widget).frame().contentRenderer())
+                children.append(adoptRef(*new WebRenderObject(coreContentRenderer, shouldIncludeDescendants)));
         }
     }
 
index 88214af..53726ec 100644 (file)
@@ -1363,12 +1363,13 @@ void PluginView::invalidateRect(const IntRect& dirtyRect)
     if (m_pluginElement->displayState() < HTMLPlugInElement::Restarting)
         return;
 
-    RenderBoxModelObject* renderer = downcast<RenderBoxModelObject>(m_pluginElement->renderer());
-    if (!renderer)
+    auto* renderer = m_pluginElement->renderer();
+    if (!is<RenderEmbeddedObject>(renderer))
         return;
+    auto& object = downcast<RenderEmbeddedObject>(*renderer);
 
     IntRect contentRect(dirtyRect);
-    contentRect.move(renderer->borderLeft() + renderer->paddingLeft(), renderer->borderTop() + renderer->paddingTop());
+    contentRect.move(object.borderLeft() + object.paddingLeft(), object.borderTop() + object.paddingTop());
     renderer->repaintRectangle(contentRect);
 }
 
@@ -1564,13 +1565,14 @@ void PluginView::pluginProcessCrashed()
 {
     m_pluginProcessHasCrashed = true;
 
-    if (!is<RenderEmbeddedObject>(m_pluginElement->renderer()))
+    auto* renderer = m_pluginElement->renderer();
+    if (!is<RenderEmbeddedObject>(renderer))
         return;
 
     m_pluginElement->setNeedsStyleRecalc(SyntheticStyleChange);
 
-    downcast<RenderEmbeddedObject>(*m_pluginElement->renderer()).setPluginUnavailabilityReason(RenderEmbeddedObject::PluginCrashed);
-    
+    downcast<RenderEmbeddedObject>(*renderer).setPluginUnavailabilityReason(RenderEmbeddedObject::PluginCrashed);
+
     Widget::invalidate();
 }
 
index f0a0943..798cdbf 100644 (file)
@@ -762,8 +762,9 @@ PassRefPtr<Plugin> WebPage::createPlugin(WebFrame* frame, HTMLPlugInElement* plu
 
     if (isBlockedPlugin) {
         bool replacementObscured = false;
-        if (is<RenderEmbeddedObject>(*pluginElement->renderer())) {
-            auto& renderObject = downcast<RenderEmbeddedObject>(*pluginElement->renderer());
+        auto* renderer = pluginElement->renderer();
+        if (is<RenderEmbeddedObject>(renderer)) {
+            auto& renderObject = downcast<RenderEmbeddedObject>(*renderer);
             renderObject.setPluginUnavailabilityReasonWithDescription(RenderEmbeddedObject::InsecurePluginVersion, unavailabilityDescription);
             replacementObscured = renderObject.isReplacementObscured();
             renderObject.setUnavailablePluginIndicatorIsHidden(replacementObscured);
@@ -5128,17 +5129,23 @@ bool WebPage::plugInIntersectsSearchRect(HTMLPlugInImageElement& plugInImageElem
 
 bool WebPage::plugInIsPrimarySize(WebCore::HTMLPlugInImageElement& plugInImageElement, unsigned& candidatePlugInArea)
 {
-    auto& pluginRenderBox = downcast<RenderBox>(*plugInImageElement.renderer());
-    if (pluginRenderBox.contentWidth() < primarySnapshottedPlugInMinimumWidth || pluginRenderBox.contentHeight() < primarySnapshottedPlugInMinimumHeight)
+    auto* renderer = plugInImageElement.renderer();
+    if (!is<RenderBox>(renderer))
         return false;
 
-    LayoutUnit contentArea = pluginRenderBox.contentWidth() * pluginRenderBox.contentHeight();
+    auto& box = downcast<RenderBox>(*renderer);
+    if (box.contentWidth() < primarySnapshottedPlugInMinimumWidth || box.contentHeight() < primarySnapshottedPlugInMinimumHeight)
+        return false;
+
+    LayoutUnit contentArea = box.contentWidth() * box.contentHeight();
     if (contentArea > candidatePlugInArea * primarySnapshottedPlugInSearchBucketSize) {
         candidatePlugInArea = contentArea.toUnsigned();
         return true;
     }
+
     return false;
 }
+
 #endif // ENABLE(PRIMARY_SNAPSHOTTED_PLUGIN_HEURISTIC)
 
 PassRefPtr<Range> WebPage::currentSelectionAsRange()
index f8cc72a..76b8632 100644 (file)
@@ -914,7 +914,7 @@ PassRefPtr<Range> WebPage::rangeForWebSelectionAtPosition(const IntPoint& point,
     if (!currentNode->isTextNode() && !canShrinkToTextSelection(currentNode) && hasCustomLineHeight(*currentNode)) {
         auto* renderer = currentNode->renderer();
         if (is<RenderBlockFlow>(renderer)) {
-            auto *renderText = downcast<RenderBlockFlow>(renderer)->findClosestTextAtAbsolutePoint(point);
+            auto* renderText = downcast<RenderBlockFlow>(*renderer).findClosestTextAtAbsolutePoint(point);
             if (renderText && renderText->textNode())
                 currentNode = renderText->textNode();
         }