Changeset 201588 in webkit


Ignore:
Timestamp:
Jun 1, 2016, 9:01:35 PM (9 years ago)
Author:
Darin Adler
Message:

Audit RenderObject casts and fix problems and style issues found
​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.

Location:
trunk/Source
Files:
52 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r201585 r201588  
     12016-05-31  Darin Adler  <darin@apple.com>
     2
     3        Audit RenderObject casts and fix problems and style issues found
     4        https://bugs.webkit.org/show_bug.cgi?id=158221
     5
     6        Reviewed by Chris Dumez.
     7
     8        * bindings/objc/DOM.mm:
     9        (-[DOMElement image]): Use auto to get more specific types in code getting
     10        the renderer for an element instead of dumbing down the type to RenderObject.
     11
     12        * dom/Element.cpp:
     13        (WebCore::Element::scrollByUnits): Call renderer only once. The comment in
     14        Node advises we should do this since it has a branch in it.
     15        (WebCore::Element::absoluteEventBounds): Call renderer only once. Also use
     16        auto for a rect type to clarify that we are not changing the type of the
     17        rect returned by the fucntion.
     18        (WebCore::Element::webkitGetRegionFlowRanges): Call renderer only once.
     19
     20        * editing/CompositeEditCommand.cpp:
     21        (WebCore::CompositeEditCommand::addBlockPlaceholderIfNeeded): Use auto
     22        to get a mroe specific renderer type.
     23
     24        * editing/SimplifyMarkupCommand.cpp:
     25        (WebCore::SimplifyMarkupCommand::doApply): Call renderer only once.
     26
     27        * editing/cocoa/HTMLConverter.mm:
     28        (HTMLConverter::_addAttachmentForElement): Add an obviously missing
     29        null check for something that is null checked elsewhere.
     30        (fileWrapperForURL): Ditto.
     31        (fileWrapperForElement): Changed argument type to HTMLImageElement& since
     32        the call site already checks the type of the object. Use HTMLImageElement::src
     33        instead of repeating the code here. Check the type of the renderer instead of
     34        assuming it's a RenderImage.
     35        (WebCore::editingAttributedStringFromRange): Pass a reference, not a pointer.
     36
     37        * html/HTMLAnchorElement.cpp:
     38        (WebCore::appendServerMapMousePosition): Take a reference to an event rather
     39        than a "known to be non-null" pointer. Call renderer only once. Round the
     40        floating point values rather than truncating them.
     41        (WebCore::HTMLAnchorElement::handleClick): Pass a reference.
     42
     43        * html/HTMLAttachmentElement.cpp:
     44        (WebCore::HTMLAttachmentElement::setFile): Removed the now-unneeded cast since
     45        the renderer function returns a pointer of a more specific type now.
     46        (WebCore::HTMLAttachmentElement::parseAttribute): Ditto.
     47        (WebCore::HTMLAttachmentElement::attachmentTitle): Use auto& to avoid a bit of
     48        reference count churn.
     49
     50        * html/HTMLAttachmentElement.h: Override renderer to return a more specific type.
     51        This follows the pattern that ContainerNode::renderer uses.
     52
     53        * html/HTMLButtonElement.h: Ditto.
     54
     55        * html/HTMLCanvasElement.cpp: Gave the constants at the top of the file more
     56        normal names. Removed unneeded "static" from them. Moved the
     57        defaultInterpolationQuality constant here from the header because it doesn't
     58        need to be there.
     59        (WebCore::HTMLCanvasElement::HTMLCanvasElement): Updated for name changes.
     60        (WebCore::HTMLCanvasElement::createElementRenderer): Removed unneeded code to
     61        set m_rendererIsCanvas to record renderer type; we can just check the type.
     62        (WebCore::HTMLCanvasElement::setHeight): Updated for name changes.
     63        (WebCore::HTMLCanvasElement::setWidth): Ditto.
     64        (WebCore::HTMLCanvasElement::reset): Check the type of the renderer directly
     65        instead of calling m_rendererIsCanvas. This helped make it clear we were
     66        do extra unneeded checks since a renderer can't both be a RenderCanvas and
     67        not be a RenderBox.
     68        (WebCore::HTMLCanvasElement::createImageBuffer): Updated for name changes.
     69
     70        * html/HTMLCanvasElement.h: Moved DefaultInterpolationQuality into the cpp file.
     71        Use nullptr instead of 0. Removed m_rendererIsCanvas.
     72
     73        * html/HTMLFieldSetElement.cpp:
     74        (WebCore::HTMLFieldSetElement::HTMLFieldSetElement): Initialize m_documentVersion
     75        in the class definition.
     76        (WebCore::HTMLFieldSetElement::~HTMLFieldSetElement): Use m_hasDisabledAttribute.
     77        (WebCore::updateFromControlElementsAncestorDisabledStateUnder): Fixed typo.
     78        (WebCore::HTMLFieldSetElement::disabledAttributeChanged): Fixed mistake in this
     79        function that would cause the number of disabled fieldset elements to be too high
     80        if the disabled attribute's value was changed from one value to another. Use a
     81        boolean to track the old value; can't think of a solution that works without that.
     82        (WebCore::HTMLFieldSetElement::childrenChanged): Fixed typo.
     83        (WebCore::HTMLFieldSetElement::didMoveToNewDocument): Use m_hasDisabledAttribute.
     84        (WebCore::HTMLFieldSetElement::updateAssociatedElements): Changed name to make it
     85        clearer what this function does. Tweaked a bit without changing behavior.
     86        (WebCore::HTMLFieldSetElement::associatedElements): Updated for name change.
     87        (WebCore::HTMLFieldSetElement::length): Changed to call associatedElements instead of
     88        repeating that it does.
     89
     90        * html/HTMLFieldSetElement.h: Override renderer to return a more specific type.
     91        Also updated for other changes mentioned above.
     92
     93        * html/HTMLFrameElement.cpp:
     94        (WebCore::HTMLFrameElement::HTMLFrameElement): Initialize booleans in the class
     95        definition rather than doing it here.
     96        (WebCore::HTMLFrameElement::parseAttribute): Call renderer only once.
     97
     98        * html/HTMLFrameElement.h: Override renderer to return a more specific type.
     99        Also initialize some booleans in the class definition.
     100
     101        * html/HTMLIFrameElement.h: Override renderer to return a more specific type.
     102
     103        * html/HTMLMediaElement.cpp:
     104        (WebCore::HTMLMediaElement::updateRenderer): Added. Helper for a common idiom.
     105        (WebCore::HTMLMediaElement::didAttachRenderers): Use auto to get a more specific
     106        type for the renderer.
     107        (WebCore::HTMLMediaElement::willDetachRenderers): Call renderer only once.
     108        (WebCore::HTMLMediaElement::didRecalcStyle): Use updateRenderer to call renderer
     109        only once.
     110        (WebCore::HTMLMediaElement::loadResource): Ditto.
     111        (WebCore::HTMLMediaElement::waitForSourceChange): Ditto.
     112        (WebCore::HTMLMediaElement::noneSupported): Ditto.
     113        (WebCore::HTMLMediaElement::setReadyState): Ditto.
     114        (WebCore::HTMLMediaElement::progressEventTimerFired): Ditto.
     115        (WebCore::HTMLMediaElement::selectNextSourceChild): Renamed goto label to use a style
     116        that fits WebKit coding style. Call renderer only once in MediaQuery code.
     117        (WebCore::HTMLMediaElement::mediaPlayerRepaint): Call renderer only once.
     118        (WebCore::HTMLMediaElement::mediaPlayerSizeChanged): Use updateRenderer to call
     119        renderer only once.
     120        (WebCore::HTMLMediaElement::mediaPlayerRenderingCanBeAccelerated): Call renderer
     121        only once.
     122        (WebCore::HTMLMediaElement::mediaPlayerGraphicsDeviceAdapter): Call page only once.
     123        (WebCore::HTMLMediaElement::mediaEngineWasUpdated): Use updateRenderer to call
     124        renderer only once.
     125        (WebCore::HTMLMediaElement::mediaPlayerCharacteristicChanged): Ditto.
     126        (WebCore::HTMLMediaElement::updatePlayState): Ditto.
     127        (WebCore::HTMLMediaElement::stopWithoutDestroyingMediaPlayer): Ditto.
     128        (WebCore::HTMLMediaElement::resume): Ditto.
     129        (WebCore::HTMLMediaElement::mediaPlayerContentBoxRect): Call renderer only once.
     130        (WebCore::mediaElementIsAllowedToAutoplay): Use auto to get a more specific type.
     131
     132        * html/HTMLMediaElement.h: Removed conditionals around forward declarations.
     133        Tweaked formatting a bit. Added the updateRender function. Override renderer to
     134        return a more specific type.
     135
     136        * html/HTMLSelectElement.cpp:
     137        (WebCore::HTMLSelectElement::optionElementChildrenChanged): Don't use the renderer
     138        just to get to the document for the AXObjectCache.
     139        (WebCore::HTMLSelectElement::setLength): Use auto for the list items vector.
     140        (WebCore::HTMLSelectElement::nextValidIndex): Ditto.
     141        (WebCore::HTMLSelectElement::firstSelectableListIndex): Ditto.
     142        (WebCore::HTMLSelectElement::nextSelectableListIndexPageAway): Ditto. Also add a
     143        null check for the renderer.
     144        (WebCore::HTMLSelectElement::updateListBoxSelection): Split an assertion with &&
     145        in it into two separate assertions. Use auto for the list items vector and use
     146        a reference for the list items.
     147        (WebCore::HTMLSelectElement::listBoxOnChange): Use auto for the list items vector
     148        and use a reference for the list items.
     149        (WebCore::HTMLSelectElement::setRecalcListItems): Don't use the renderer
     150        just to get to the document for the AXObjectCache.
     151        (WebCore::HTMLSelectElement::selectOption): Use auto for the list items vector.
     152        (WebCore::HTMLSelectElement::optionToListIndex): Ditto.
     153        (WebCore::HTMLSelectElement::listToOptionIndex): Ditto.
     154        (WebCore::HTMLSelectElement::searchOptionsForValue): Ditto.
     155        (WebCore::HTMLSelectElement::restoreFormControlState): Ditto.
     156        (WebCore::HTMLSelectElement::platformHandleKeydownEvent): Call renderer only once.
     157        (WebCore::HTMLSelectElement::menuListDefaultEventHandler): Split an assertion with
     158        && in it into two separate assertions. Use auto for the list items vector. Call
     159        renderer only once.
     160        (WebCore::HTMLSelectElement::updateSelectedState): Use a reference for the list
     161        item.
     162        (WebCore::HTMLSelectElement::listBoxDefaultEventHandler): Use auto for the list
     163        items vvector. Call renderer less often; could not quite get it down to once.
     164        (WebCore::HTMLSelectElement::defaultEventHandler): Call renderer only once.
     165        (WebCore::HTMLSelectElement::lastSelectedListIndex): Use auto for the list items
     166        vector and use a reference for the list items.
     167        (WebCore::HTMLSelectElement::optionAtIndex): Use a reference for the list item.
     168        (WebCore::HTMLSelectElement::accessKeySetSelectedIndex): Use auto for the list
     169        items vector and use a reference for the list items.
     170        (WebCore::HTMLSelectElement::length): Use auto for the list items vector.
     171
     172        * html/HTMLTextAreaElement.h: Override renderer to return a more specific type.
     173
     174        * html/HTMLVideoElement.cpp:
     175        (WebCore::HTMLVideoElement::didAttachRenderers): Call renderer only once and
     176        don't downcast it. There was no obvious type check because the renderer has a
     177        guaranteed type, but this is now clearer because it's the renderer function
     178        that returns a more specific type.
     179        (WebCore::HTMLVideoElement::parseAttribute): Ditto.
     180        (WebCore::HTMLVideoElement::setDisplayMode): Ditto.
     181
     182        * html/HTMLVideoElement.h: Override renderer to return a more specific type.
     183        * html/HTMLWBRElement.h: Ditto.
     184
     185        * html/MediaElementSession.cpp:
     186        (WebCore::MediaElementSession::canControlControlsManager): Removed
     187        unneeded typecast in code that null checks a renderer.
     188        (WebCore::isMainContent): Remove now-unneeded downcast of a renderer
     189        obtained from an HTMLMediaElement. Fixed awkward formatting by splitting
     190        an if statement into two.
     191        (WebCore::isElementLargeEnoughForMainContent): Remove now unneeded downcast
     192        of a renderer obtained from an HTMLMediaElement.
     193
     194        * html/TextFieldInputType.cpp:
     195        (WebCore::TextFieldInputType::forwardEvent): Call renderer only once.
     196        Also use auto more in the code rather than writing out types.
     197
     198        * html/shadow/SliderThumbElement.cpp:
     199        (WebCore::SliderThumbElement::setPositionFromPoint): Used the renderBox
     200        function more consistently for all the renderers used here; before,
     201        some had null checks and others did not.
     202
     203        * html/shadow/TextControlInnerElements.cpp:
     204        (WebCore::SearchFieldResultsButtonElement::defaultEventHandler): Use auto
     205        a bit more.
     206
     207        * page/EventHandler.cpp:
     208        (WebCore::enclosingScrollableArea): Removed a redundant null check and
     209        stopped using the name "element" for a local variable that was not
     210        always an element.
     211
     212        * page/PrintContext.cpp:
     213        (WebCore::enclosingBoxModelObject): Rewrote loop to be simpler and tighter.
     214        Also marked this inline since it's used only one place.
     215        (WebCore::PrintContext::pageNumberForElement): Use auto for the return
     216        value rather than writing out the type.
     217
     218        * page/SpatialNavigation.cpp:
     219        (WebCore::isScrollableNode): Tighten the code and use auto a bit.
     220
     221        * platform/ios/WebVideoFullscreenControllerAVKit.mm: Add an include of
     222        RenderVideo.h since this gets at the renderer for a video.
     223
     224        * rendering/RenderAttachment.h:
     225        (WebCore::HTMLAttachmentElement::renderer): Added. Function is here because
     226        it can only be called by code that includes this header. This matches the
     227        pattern of RenderElement.h and ContainerNode::renderer.
     228
     229        * rendering/RenderFrame.cpp: Added now-needed include.
     230
     231        * rendering/RenderFrame.h:
     232        (WebCore::HTMLFrameElement::renderer): Added. Same logic as above.
     233
     234        * rendering/RenderLayerFilterInfo.cpp:
     235        (WebCore::RenderLayer::FilterInfo::updateReferenceFilterClients): Use auto
     236        a bit and call rendeer only once.
     237
     238        * rendering/RenderMedia.h:
     239        (WebCore::HTMLMediaElement::renderer): Added. Same logic as above.
     240        * rendering/RenderTextControlMultiLine.h:
     241        (WebCore::HTMLTextAreaElement::renderer): Ditto.
     242
     243        * rendering/RenderVideo.cpp:
     244        (WebCore::placeholder): Renamed. Tightened up argument type to match what
     245        is passed at all the call sites. Use auto instead of RenderObject.
     246        (WebCore::RenderVideo::offsetLeft): Use auto and the renamed function above.
     247        (WebCore::RenderVideo::offsetTop): Ditto.
     248        (WebCore::RenderVideo::offsetWidth): Ditto.
     249        (WebCore::RenderVideo::offsetHeight): Ditto.
     250
     251        * rendering/RenderVideo.h:
     252        (WebCore::HTMLVideoElement::renderer): Added. Same logic as above.
     253
     254        * svg/SVGGElement.cpp:
     255        (WebCore::SVGGElement::createElementRenderer): Fixed typo.
     256
     257        * svg/SVGGraphicsElement.cpp:
     258        (WebCore::SVGGraphicsElement::createElementRenderer): Removed
     259        non-helpful oblique comment.
     260        * svg/SVGPathElement.cpp:
     261        (WebCore::SVGPathElement::createElementRenderer): Ditto.
     262
    12632016-06-01  Chris Fleizach  <cfleizach@apple.com>
    2264

  • trunk/Source/WebCore/bindings/objc/DOM.mm

    r201441 r201588  
    708708{
    709709    // FIXME: Could we move this function to WebCore::Node and autogenerate?
    710     WebCore::RenderObject* renderer = core(self)->renderer();
     710    auto* renderer = core(self)->renderer();
    711711    if (!is<RenderImage>(renderer))
    712712        return nil;
    713     WebCore::CachedImage* cachedImage = downcast<RenderImage>(*renderer).cachedImage();
     713    auto* cachedImage = downcast<RenderImage>(*renderer).cachedImage();
    714714    if (!cachedImage || cachedImage->errorOccurred())
    715715        return nil;

  • trunk/Source/WebCore/dom/Element.cpp

    r201333 r201588  
    676676    document().updateLayoutIgnorePendingStylesheets();
    677677
    678     if (!renderer())
    679         return;
    680 
    681     if (!renderer()->hasOverflowClip())
     678    auto* renderer = this->renderer();
     679    if (!renderer)
     680        return;
     681
     682    if (!renderer->hasOverflowClip())
    682683        return;
    683684
    … …  
    688689    }
    689690    Element* stopElement = this;
    690     downcast<RenderBox>(*renderer()).scroll(direction, granularity, units, &stopElement);
     691    downcast<RenderBox>(*renderer).scroll(direction, granularity, units, &stopElement);
    691692}
    692693
    … …  
    10101011            result = LayoutRect(renderer()->localToAbsoluteQuad(localRect, UseTransforms, &includesFixedPositionElements).boundingBox());
    10111012    } else {
    1012         if (is<RenderBox>(renderer())) {
    1013             RenderBox& box = *downcast<RenderBox>(renderer());
     1013        auto* renderer = this->renderer();
     1014        if (is<RenderBox>(renderer)) {
     1015            auto& box = downcast<RenderBox>(*renderer);
    10141016
    10151017            bool computedBounds = false;
    … …  
    10311033                    RenderElement* multicolContainer = flowThread->parent();
    10321034                    if (multicolContainer && is<RenderBox>(multicolContainer)) {
    1033                         LayoutRect overflowRect = downcast<RenderBox>(multicolContainer)->layoutOverflowRect();
     1035                        auto overflowRect = downcast<RenderBox>(*multicolContainer).layoutOverflowRect();
    10341036                        result = LayoutRect(multicolContainer->localToAbsoluteQuad(FloatRect(overflowRect), UseTransforms, &includesFixedPositionElements).boundingBox());
    10351037                        computedBounds = true;
    … …  
    10441046            }
    10451047        } else
    1046             result = LayoutRect(renderer()->absoluteBoundingBoxRect(true /* useTransforms */, &includesFixedPositionElements));
     1048            result = LayoutRect(renderer->absoluteBoundingBoxRect(true /* useTransforms */, &includesFixedPositionElements));
    10471049    }
    10481050
    … …  
    29682970    Vector<RefPtr<Range>> rangeObjects;
    29692971    document().updateLayoutIgnorePendingStylesheets();
    2970     if (renderer() && renderer()->isRenderNamedFlowFragmentContainer()) {
    2971         RenderNamedFlowFragment& namedFlowFragment = *downcast<RenderBlockFlow>(*renderer()).renderNamedFlowFragment();
     2972    auto* renderer = this->renderer();
     2973    if (renderer && renderer->isRenderNamedFlowFragmentContainer()) {
     2974        auto& namedFlowFragment = *downcast<RenderBlockFlow>(*renderer).renderNamedFlowFragment();
    29722975        if (namedFlowFragment.isValid())
    29732976            namedFlowFragment.getRanges(rangeObjects);
    29742977    }
    2975 
    29762978    return rangeObjects;
    29772979}

  • trunk/Source/WebCore/editing/CompositeEditCommand.cpp

    r200931 r201588  
    10601060    document().updateLayoutIgnorePendingStylesheets();
    10611061
    1062     RenderObject* renderer = container->renderer();
     1062    auto* renderer = container->renderer();
    10631063    if (!is<RenderBlockFlow>(renderer))
    10641064        return nullptr;
    10651065   
    1066     // append the placeholder to make sure it follows
    1067     // any unrendered blocks
    1068     RenderBlockFlow& blockFlow = downcast<RenderBlockFlow>(*renderer);
     1066    // Append the placeholder to make sure it follows any unrendered blocks.
     1067    auto& blockFlow = downcast<RenderBlockFlow>(*renderer);
    10691068    if (!blockFlow.height() || (blockFlow.isListItem() && blockFlow.isEmpty()))
    10701069        return appendBlockPlaceholder(container);

  • trunk/Source/WebCore/editing/SimplifyMarkupCommand.cpp

    r200098 r201588  
    7171                break;
    7272
    73             if (!is<RenderInline>(currentNode->renderer()) || downcast<RenderInline>(*currentNode->renderer()).alwaysCreateLineBoxes())
     73            auto* renderer = currentNode->renderer();
     74            if (!is<RenderInline>(renderer) || downcast<RenderInline>(*renderer).alwaysCreateLineBoxes())
    7475                continue;
    7576           

  • trunk/Source/WebCore/editing/cocoa/HTMLConverter.mm

    r201205 r201588  
    318318#else
    319319static NSFileWrapper *fileWrapperForURL(DocumentLoader *, NSURL *);
    320 static NSFileWrapper *fileWrapperForElement(Element*);
     320static NSFileWrapper *fileWrapperForElement(HTMLImageElement&);
    321321
    322322@interface NSTextAttachment (WebCoreNSTextAttachment)
    … …  
    13941394            fileWrapper = [[[NSFileWrapper alloc] initWithURL:url options:0 error:NULL] autorelease];
    13951395    }
    1396     if (!fileWrapper) {
     1396    if (!fileWrapper && dataSource) {
    13971397        RefPtr<ArchiveResource> resource = dataSource->subresource(url);
    13981398        if (!resource)
    … …  
    24242424#if !PLATFORM(IOS)
    24252425
    2426 static NSFileWrapper *fileWrapperForURL(DocumentLoader *dataSource, NSURL *URL)
     2426static NSFileWrapper *fileWrapperForURL(DocumentLoader* dataSource, NSURL *URL)
    24272427{
    24282428    if ([URL isFileURL])
    24292429        return [[[NSFileWrapper alloc] initWithURL:[URL URLByResolvingSymlinksInPath] options:0 error:nullptr] autorelease];
    24302430
    2431     RefPtr<ArchiveResource> resource = dataSource->subresource(URL);
    2432     if (resource) {
    2433         NSFileWrapper *wrapper = [[[NSFileWrapper alloc] initRegularFileWithContents:resource->data().createNSData().get()] autorelease];
    2434         NSString *filename = resource->response().suggestedFilename();
    2435         if (!filename || ![filename length])
    2436             filename = suggestedFilenameWithMIMEType(resource->url(), resource->mimeType());
    2437         [wrapper setPreferredFilename:filename];
    2438         return wrapper;
     2431    if (dataSource) {
     2432        if (RefPtr<ArchiveResource> resource = dataSource->subresource(URL)) {
     2433            NSFileWrapper *wrapper = [[[NSFileWrapper alloc] initRegularFileWithContents:resource->data().createNSData().get()] autorelease];
     2434            NSString *filename = resource->response().suggestedFilename();
     2435            if (!filename || ![filename length])
     2436                filename = suggestedFilenameWithMIMEType(resource->url(), resource->mimeType());
     2437            [wrapper setPreferredFilename:filename];
     2438            return wrapper;
     2439        }
    24392440    }
    24402441   
    … …  
    24532454}
    24542455
    2455 static NSFileWrapper *fileWrapperForElement(Element* element)
    2456 {
    2457     NSFileWrapper *wrapper = nil;
    2458    
    2459     const AtomicString& attr = element->getAttribute(srcAttr);
    2460     if (!attr.isEmpty()) {
    2461         NSURL *URL = element->document().completeURL(attr);
    2462         if (DocumentLoader* loader = element->document().loader())
    2463             wrapper = fileWrapperForURL(loader, URL);
    2464     }
     2456static NSFileWrapper *fileWrapperForElement(HTMLImageElement& element)
     2457{
     2458    // FIXME: Should this use currentSrc instead of src?
     2459    auto src = element.src();
     2460    NSFileWrapper *wrapper = src.isEmpty() ? nil : fileWrapperForURL(element.document().loader(), src);
     2461
    24652462    if (!wrapper) {
    2466         auto& renderer = downcast<RenderImage>(*element->renderer());
    2467         if (renderer.cachedImage() && !renderer.cachedImage()->errorOccurred()) {
    2468             wrapper = [[NSFileWrapper alloc] initRegularFileWithContents:(NSData *)(renderer.cachedImage()->imageForRenderer(&renderer)->getTIFFRepresentation())];
    2469             [wrapper setPreferredFilename:@"image.tiff"];
    2470             [wrapper autorelease];
     2463        auto* renderer = element.renderer();
     2464        if (is<RenderImage>(renderer)) {
     2465            auto* image = downcast<RenderImage>(*renderer).cachedImage();
     2466            if (image && !image->errorOccurred()) {
     2467                wrapper = [[[NSFileWrapper alloc] initRegularFileWithContents:(NSData *)image->imageForRenderer(renderer)->getTIFFRepresentation()] autorelease];
     2468                [wrapper setPreferredFilename:@"image.tiff"];
     2469            }
    24712470        }
    24722471    }
    … …  
    24872486   
    24882487#if !PLATFORM(IOS)
     2488
    24892489// This function uses TextIterator, which makes offsets in its result compatible with HTML editing.
    24902490NSAttributedString *editingAttributedStringFromRange(Range& range, IncludeImagesInAttributedString includeOrSkipImages)
    … …  
    25062506                Node* node = startContainer.traverseToChildAt(startOffset);
    25072507                if (is<HTMLImageElement>(node)) {
    2508                     NSFileWrapper* fileWrapper = fileWrapperForElement(downcast<HTMLImageElement>(node));
    2509                     NSTextAttachment* attachment = [[NSTextAttachment alloc] initWithFileWrapper:fileWrapper];
     2508                    auto fileWrapper = fileWrapperForElement(downcast<HTMLImageElement>(*node));
     2509                    NSTextAttachment *attachment = [[NSTextAttachment alloc] initWithFileWrapper:fileWrapper];
    25102510                    [string appendAttributedString:[NSAttributedString attributedStringWithAttachment:attachment]];
    25112511                    [attachment release];
    … …  
    25472547    return [string autorelease];
    25482548}
    2549 #endif
    2550    
    2551 }
     2549
     2550#endif
     2551   
     2552}

  • trunk/Source/WebCore/html/HTMLAnchorElement.cpp

    r199571 r201588  
    139139}
    140140
    141 static void appendServerMapMousePosition(StringBuilder& url, Event* event)
    142 {
    143     ASSERT(event);
    144     if (!is<MouseEvent>(*event))
    145         return;
    146 
    147     ASSERT(event->target());
    148     Node* target = event->target()->toNode();
     141static void appendServerMapMousePosition(StringBuilder& url, Event& event)
     142{
     143    if (!is<MouseEvent>(event))
     144        return;
     145    auto& mouseEvent = downcast<MouseEvent>(event);
     146
     147    ASSERT(mouseEvent.target());
     148    auto* target = mouseEvent.target()->toNode();
    149149    ASSERT(target);
    150150    if (!is<HTMLImageElement>(*target))
    151151        return;
    152152
    153     HTMLImageElement& imageElement = downcast<HTMLImageElement>(*target);
     153    auto& imageElement = downcast<HTMLImageElement>(*target);
    154154    if (!imageElement.isServerMap())
    155155        return;
    156156
    157     if (!is<RenderImage>(imageElement.renderer()))
    158         return;
    159     auto& renderer = downcast<RenderImage>(*imageElement.renderer());
    160 
    161     // FIXME: This should probably pass true for useTransforms.
    162     FloatPoint absolutePosition = renderer.absoluteToLocal(FloatPoint(downcast<MouseEvent>(*event).pageX(), downcast<MouseEvent>(*event).pageY()));
    163     int x = absolutePosition.x();
    164     int y = absolutePosition.y();
     157    auto* renderer = imageElement.renderer();
     158    if (!is<RenderImage>(renderer))
     159        return;
     160
     161    // FIXME: This should probably pass UseTransforms in the MapCoordinatesFlags.
     162    auto absolutePosition = downcast<RenderImage>(*renderer).absoluteToLocal(FloatPoint(mouseEvent.pageX(), mouseEvent.pageY()));
    165163    url.append('?');
    166     url.appendNumber(x);
     164    url.appendNumber(std::lround(absolutePosition.x()));
    167165    url.append(',');
    168     url.appendNumber(y);
     166    url.appendNumber(std::lround(absolutePosition.y()));
    169167}
    170168
    … …  
    552550    StringBuilder url;
    553551    url.append(stripLeadingAndTrailingHTMLSpaces(fastGetAttribute(hrefAttr)));
    554     appendServerMapMousePosition(url, event);
     552    appendServerMapMousePosition(url, *event);
    555553    URL kurl = document().completeURL(url.toString());
    556554

  • trunk/Source/WebCore/html/HTMLAttachmentElement.cpp

    r200041 r201588  
    6666    m_file = file;
    6767
    68     auto* renderer = this->renderer();
    69     if (!is<RenderAttachment>(renderer))
    70         return;
    71 
    72     downcast<RenderAttachment>(*renderer).invalidate();
     68    if (auto* renderer = this->renderer())
     69        renderer->invalidate();
    7370}
    7471
    7572void HTMLAttachmentElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
    7673{
    77     if ((name == progressAttr || name == titleAttr || name == subtitleAttr || name == typeAttr) && is<RenderAttachment>(renderer())) {
    78         downcast<RenderAttachment>(*renderer()).invalidate();
    79         return;
     74    if (name == progressAttr || name == subtitleAttr || name == titleAttr || name == typeAttr) {
     75        if (auto* renderer = this->renderer())
     76            renderer->invalidate();
    8077    }
    8178
    … …  
    8582String HTMLAttachmentElement::attachmentTitle() const
    8683{
    87     String title = fastGetAttribute(titleAttr);
     84    auto& title = fastGetAttribute(titleAttr);
    8885    if (!title.isEmpty())
    8986        return title;

  • trunk/Source/WebCore/html/HTMLAttachmentElement.h

    r200041 r201588  
    2424 */
    2525
    26 #ifndef HTMLAttachmentElement_h
    27 #define HTMLAttachmentElement_h
     26#pragma once
    2827
    2928#if ENABLE(ATTACHMENT_ELEMENT)
    … …  
    3433
    3534class File;
     35class RenderAttachment;
    3636
    3737class HTMLAttachmentElement final : public HTMLElement {
    3838public:
    3939    static Ref<HTMLAttachmentElement> create(const QualifiedName&, Document&);
     40
    4041    WEBCORE_EXPORT File* file() const;
    4142    void setFile(File*);
    … …  
    4344    WEBCORE_EXPORT String attachmentTitle() const;
    4445    String attachmentType() const;
     46
     47    RenderAttachment* renderer() const;
    4548
    4649private:
    … …  
    6063
    6164#endif // ENABLE(ATTACHMENT_ELEMENT)
    62 #endif // HTMLAttachmentElement_h

  • trunk/Source/WebCore/html/HTMLButtonElement.h

    r200041 r201588  
    2222 */
    2323
    24 #ifndef HTMLButtonElement_h
    25 #define HTMLButtonElement_h
     24#pragma once
    2625
    2726#include "HTMLFormControlElement.h"
    2827
    2928namespace WebCore {
     29
     30class RenderButton;
    3031
    3132class HTMLButtonElement final : public HTMLFormControlElement {
    … …  
    3839
    3940    bool willRespondToMouseClickEvents() override;
     41
     42    RenderButton* renderer() const;
    4043
    4144private:
    … …  
    7881
    7982} // namespace
    80 
    81 #endif

  • trunk/Source/WebCore/html/HTMLCanvasElement.cpp

    r200041 r201588  
    4949#include "Settings.h"
    5050#include <math.h>
    51 #include <wtf/RAMSize.h>
    52 
    5351#include <runtime/JSCInlines.h>
    5452#include <runtime/JSLock.h>
     53#include <wtf/RAMSize.h>
    5554
    5655#if ENABLE(WEBGL)   
    … …  
    6463
    6564// These values come from the WhatWG/W3C HTML spec.
    66 static const int DefaultWidth = 300;
    67 static const int DefaultHeight = 150;
     65const int defaultWidth = 300;
     66const int defaultHeight = 150;
    6867
    6968// Firefox limits width/height to 32767 pixels, but slows down dramatically before it
    … …  
    7170// in exchange for a smaller maximum canvas size. The maximum canvas size is in device pixels.
    7271#if PLATFORM(IOS)
    73 static const unsigned MaxCanvasArea = 4096 * 4096;
     72const unsigned maxCanvasArea = 4096 * 4096;
    7473#elif PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101100
    75 static const unsigned MaxCanvasArea = 8192 * 8192;
     74const unsigned maxCanvasArea = 8192 * 8192;
    7675#else
    77 static const unsigned MaxCanvasArea = 16384 * 16384;
     76const unsigned maxCanvasArea = 16384 * 16384;
     77#endif
     78
     79#if USE(CG)
     80// FIXME: It seems strange that the default quality is not the one that is literally named "default".
     81// Should fix names to make this easier to understand, or write an excellent comment here explaining why not.
     82const InterpolationQuality defaultInterpolationQuality = InterpolationLow;
     83#else
     84const InterpolationQuality defaultInterpolationQuality = InterpolationDefault;
    7885#endif
    7986
    … …  
    8289HTMLCanvasElement::HTMLCanvasElement(const QualifiedName& tagName, Document& document)
    8390    : HTMLElement(tagName, document)
    84     , m_size(DefaultWidth, DefaultHeight)
     91    , m_size(defaultWidth, defaultHeight)
    8592{
    8693    ASSERT(hasTagName(canvasTag));
    … …  
    128135{
    129136    Frame* frame = document().frame();
    130     if (frame && frame->script().canExecuteScripts(NotAboutToExecuteScript)) {
    131         m_rendererIsCanvas = true;
     137    if (frame && frame->script().canExecuteScripts(NotAboutToExecuteScript))
    132138        return createRenderer<RenderHTMLCanvas>(*this, WTFMove(style));
    133     }
    134 
    135     m_rendererIsCanvas = false;
    136139    return HTMLElement::createElementRenderer(WTFMove(style), insertionPosition);
    137140}
    … …  
    159162void HTMLCanvasElement::setHeight(unsigned value)
    160163{
    161     setAttributeWithoutSynchronization(heightAttr, AtomicString::number(limitToOnlyHTMLNonNegative(value, DefaultHeight)));
     164    setAttributeWithoutSynchronization(heightAttr, AtomicString::number(limitToOnlyHTMLNonNegative(value, defaultHeight)));
    162165}
    163166
    164167void HTMLCanvasElement::setWidth(unsigned value)
    165168{
    166     setAttributeWithoutSynchronization(widthAttr, AtomicString::number(limitToOnlyHTMLNonNegative(value, DefaultWidth)));
     169    setAttributeWithoutSynchronization(widthAttr, AtomicString::number(limitToOnlyHTMLNonNegative(value, defaultWidth)));
    167170}
    168171
    … …  
    337340    bool hadImageBuffer = hasCreatedImageBuffer();
    338341
    339     int w = limitToOnlyHTMLNonNegative(fastGetAttribute(widthAttr), DefaultWidth);
    340     int h = limitToOnlyHTMLNonNegative(fastGetAttribute(heightAttr), DefaultHeight);
     342    int w = limitToOnlyHTMLNonNegative(fastGetAttribute(widthAttr), defaultWidth);
     343    int h = limitToOnlyHTMLNonNegative(fastGetAttribute(heightAttr), defaultHeight);
    341344
    342345    if (m_contextStateSaver) {
    … …  
    368371#endif
    369372
    370     if (auto renderer = this->renderer()) {
    371         if (m_rendererIsCanvas) {
    372             if (oldSize != size()) {
    373                 downcast<RenderHTMLCanvas>(*renderer).canvasSizeChanged();
    374                 if (renderBox() && renderBox()->hasAcceleratedCompositing())
    375                     renderBox()->contentChanged(CanvasChanged);
    376             }
    377             if (hadImageBuffer)
    378                 renderer->repaint();
     373    auto renderer = this->renderer();
     374    if (is<RenderHTMLCanvas>(renderer)) {
     375        auto& canvasRenderer = downcast<RenderHTMLCanvas>(*renderer);
     376        if (oldSize != size()) {
     377            canvasRenderer.canvasSizeChanged();
     378            if (canvasRenderer.hasAcceleratedCompositing())
     379                canvasRenderer.contentChanged(CanvasChanged);
    379380        }
     381        if (hadImageBuffer)
     382            canvasRenderer.repaint();
    380383    }
    381384
    … …  
    637640        return;
    638641
    639     if (deviceSize.width() * deviceSize.height() > MaxCanvasArea) {
     642    if (deviceSize.width() * deviceSize.height() > maxCanvasArea) {
    640643        StringBuilder stringBuilder;
    641644        stringBuilder.appendLiteral("Canvas area exceeds the maximum limit (width * height > ");
    642         stringBuilder.appendNumber(MaxCanvasArea);
     645        stringBuilder.appendNumber(maxCanvasArea);
    643646        stringBuilder.appendLiteral(").");
    644647        document().addConsoleMessage(MessageSource::JS, MessageLevel::Warning, stringBuilder.toString());
    … …  
    667670        return;
    668671    m_imageBuffer->context().setShadowsIgnoreTransforms(true);
    669     m_imageBuffer->context().setImageInterpolationQuality(DefaultInterpolationQuality);
     672    m_imageBuffer->context().setImageInterpolationQuality(defaultInterpolationQuality);
    670673    if (document().settings() && !document().settings()->antialiased2dCanvasEnabled())
    671674        m_imageBuffer->context().setShouldAntialias(false);

  • trunk/Source/WebCore/html/HTMLCanvasElement.h

    r200041 r201588  
    2626 */
    2727
    28 #ifndef HTMLCanvasElement_h
    29 #define HTMLCanvasElement_h
     28#pragma once
    3029
    3130#include "FloatRect.h"
    … …  
    3433#include <memory>
    3534#include <wtf/Forward.h>
    36 
    37 #if USE(CG)
    38 #define DefaultInterpolationQuality InterpolationLow
    39 #else
    40 #define DefaultInterpolationQuality InterpolationDefault
    41 #endif
    4235
    4336namespace WebCore {
    … …  
    4942class HTMLCanvasElement;
    5043class Image;
     44class ImageBuffer;
    5145class ImageData;
    52 class ImageBuffer;
    53 class IntSize;
    5446
    5547namespace DisplayList {
    … …  
    7567    void removeObserver(CanvasObserver&);
    7668
    77     // Attributes and functions exposed to script
    7869    unsigned width() const { return size().width(); }
    7970    unsigned height() const { return size().height(); }
    … …  
    9586    }
    9687
    97     CanvasRenderingContext* getContext(const String&, CanvasContextAttributes* attributes = 0);
    98     bool probablySupportsContext(const String&, CanvasContextAttributes* = 0);
     88    CanvasRenderingContext* getContext(const String&, CanvasContextAttributes* = nullptr);
     89    bool probablySupportsContext(const String&, CanvasContextAttributes* = nullptr);
    9990    static bool is2dType(const String&);
    10091#if ENABLE(WEBGL)
    … …  
    10495    static String toEncodingMimeType(const String& mimeType);
    10596    String toDataURL(const String& mimeType, const double* quality, ExceptionCode&);
    106     String toDataURL(const String& mimeType, ExceptionCode& ec) { return toDataURL(mimeType, 0, ec); }
     97    String toDataURL(const String& mimeType, ExceptionCode& ec) { return toDataURL(mimeType, nullptr, ec); }
    10798
    10899    // Used for rendering
    … …  
    178169
    179170    bool m_originClean { true };
    180     bool m_rendererIsCanvas { false };
    181171    bool m_ignoreReset { false };
    182172
    … …  
    194184};
    195185
    196 } //namespace
    197 
    198 #endif
     186} // namespace WebCore

  • trunk/Source/WebCore/html/HTMLFieldSetElement.cpp

    r200041 r201588  
    4141inline HTMLFieldSetElement::HTMLFieldSetElement(const QualifiedName& tagName, Document& document, HTMLFormElement* form)
    4242    : HTMLFormControlElement(tagName, document, form)
    43     , m_documentVersion(0)
    4443{
    4544    ASSERT(hasTagName(fieldsetTag));
    … …  
    4847HTMLFieldSetElement::~HTMLFieldSetElement()
    4948{
    50     if (fastHasAttribute(disabledAttr))
     49    if (m_hasDisabledAttribute)
    5150        document().removeDisabledFieldsetElement();
    5251}
    … …  
    6665    while (control) {
    6766        control->setAncestorDisabled(isDisabled);
    68         // Don't call setAncestorDisabled(false) on form contorls inside disabled fieldsets.
     67        // Don't call setAncestorDisabled(false) on form controls inside disabled fieldsets.
    6968        if (is<HTMLFieldSetElement>(*control) && control->fastHasAttribute(disabledAttr))
    7069            control = Traversal<HTMLFormControlElement>::nextSkippingChildren(*control, &startNode);
    … …  
    7675void HTMLFieldSetElement::disabledAttributeChanged()
    7776{
    78     if (fastHasAttribute(disabledAttr))
    79         document().addDisabledFieldsetElement();
    80     else
    81         document().removeDisabledFieldsetElement();
     77    bool hasDisabledAttribute = fastHasAttribute(disabledAttr);
     78    if (m_hasDisabledAttribute != hasDisabledAttribute) {
     79        m_hasDisabledAttribute = hasDisabledAttribute;
     80        if (hasDisabledAttribute)
     81            document().addDisabledFieldsetElement();
     82        else
     83            document().removeDisabledFieldsetElement();
     84    }
    8285
    8386    HTMLFormControlElement::disabledAttributeChanged();
    … …  
    114117        return;
    115118
    116     // We only care about the first legend element (in which form contorls are not disabled by this element) changing here.
     119    // We only care about the first legend element (in which form controls are not disabled by this element) changing here.
    117120    updateFromControlElementsAncestorDisabledStateUnder(*legend, false /* isDisabled */);
    118121    while ((legend = Traversal<HTMLLegendElement>::nextSibling(*legend)))
    … …  
    123126{
    124127    HTMLFormControlElement::didMoveToNewDocument(oldDocument);
    125     if (fastHasAttribute(disabledAttr)) {
     128    if (m_hasDisabledAttribute) {
    126129        if (oldDocument)
    127130            oldDocument->removeDisabledFieldsetElement();
    … …  
    171174}
    172175
    173 void HTMLFieldSetElement::refreshElementsIfNeeded() const
     176void HTMLFieldSetElement::updateAssociatedElements() const
    174177{
    175178    uint64_t documentVersion = document().domTreeVersion();
    … …  
    181184    m_associatedElements.clear();
    182185
    183     for (auto& element : descendantsOfType<Element>(const_cast<HTMLFieldSetElement&>(*this))) {
    184         if (element.hasTagName(objectTag))
     186    for (auto& element : descendantsOfType<HTMLElement>(const_cast<HTMLFieldSetElement&>(*this))) {
     187        if (is<HTMLObjectElement>(element))
    185188            m_associatedElements.append(&downcast<HTMLObjectElement>(element));
    186189        else if (is<HTMLFormControlElement>(element))
    … …  
    191194const Vector<FormAssociatedElement*>& HTMLFieldSetElement::associatedElements() const
    192195{
    193     refreshElementsIfNeeded();
     196    updateAssociatedElements();
    194197    return m_associatedElements;
    195198}
    … …  
    197200unsigned HTMLFieldSetElement::length() const
    198201{
    199     refreshElementsIfNeeded();
    200202    unsigned length = 0;
    201     for (auto& element : m_associatedElements) {
     203    for (auto* element : associatedElements()) {
    202204        if (element->isEnumeratable())
    203205            ++length;

  • trunk/Source/WebCore/html/HTMLFieldSetElement.h

    r200041 r201588  
    2222 */
    2323
    24 #ifndef HTMLFieldSetElement_h
    25 #define HTMLFieldSetElement_h
     24#pragma once
    2625
    2726#include "HTMLFormControlElement.h"
    … …  
    3231class FormAssociatedElement;
    3332class HTMLFormControlsCollection;
     33class RenderFieldSet;
    3434
    3535class HTMLFieldSetElement final : public HTMLFormControlElement {
    … …  
    4747    void addInvalidDescendant(const HTMLFormControlElement&);
    4848    void removeInvalidDescendant(const HTMLFormControlElement&);
     49
     50    RenderFieldSet* renderer() const;
    4951
    5052private:
    … …  
    6567    bool matchesInvalidPseudoClass() const override;
    6668
    67     void refreshElementsIfNeeded() const;
     69    void updateAssociatedElements() const;
    6870
    6971    mutable Vector<FormAssociatedElement*> m_associatedElements;
    70     // When dom tree is modified, we have to refresh the m_associatedElements array.
    71     mutable uint64_t m_documentVersion;
     72    // When the DOM tree is modified, we have to refresh the m_associatedElements array.
     73    mutable uint64_t m_documentVersion { 0 };
    7274    HashSet<const HTMLFormControlElement*> m_invalidDescendants;
     75    bool m_hasDisabledAttribute { false };
    7376};
    7477
    7578} // namespace
    76 
    77 #endif

  • trunk/Source/WebCore/html/HTMLFrameElement.cpp

    r200041 r201588  
    3636inline HTMLFrameElement::HTMLFrameElement(const QualifiedName& tagName, Document& document)
    3737    : HTMLFrameElementBase(tagName, document)
    38     , m_frameBorder(true)
    39     , m_frameBorderSet(false)
    4038{
    4139    ASSERT(hasTagName(frameTag));
    … …  
    8179        // FIXME: If we are already attached, this has no effect.
    8280    } else if (name == noresizeAttr) {
    83         if (renderer())
    84             renderer()->updateFromElement();
     81        if (auto* renderer = this->renderer())
     82            renderer->updateFromElement();
    8583    } else
    8684        HTMLFrameElementBase::parseAttribute(name, value);

  • trunk/Source/WebCore/html/HTMLFrameElement.h

    r200041 r201588  
    2222 */
    2323
    24 #ifndef HTMLFrameElement_h
    25 #define HTMLFrameElement_h
     24#pragma once
    2625
    2726#include "HTMLFrameElementBase.h"
    2827
    2928namespace WebCore {
     29
     30class RenderFrame;
    3031
    3132class HTMLFrameElement final : public HTMLFrameElementBase {
    … …  
    3435
    3536    bool hasFrameBorder() const { return m_frameBorder; }
     37    bool noResize() const;
    3638
    37     bool noResize() const;
     39    RenderFrame* renderer() const;
    3840
    3941private:
    4042    HTMLFrameElement(const QualifiedName&, Document&);
    4143
    42     void didAttachRenderers() override;
     44    void didAttachRenderers() final;
     45    bool rendererIsNeeded(const RenderStyle&) final;
     46    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) final;
     47    void parseAttribute(const QualifiedName&, const AtomicString&) final;
    4348
    44     bool rendererIsNeeded(const RenderStyle&) override;
    45     RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    46    
    47     void parseAttribute(const QualifiedName&, const AtomicString&) override;
    48 
    49     bool m_frameBorder;
    50     bool m_frameBorderSet;
     49    bool m_frameBorder { true };
     50    bool m_frameBorderSet { false };
    5151};
    5252
    5353} // namespace WebCore
    54 
    55 #endif // HTMLFrameElement_h

  • trunk/Source/WebCore/html/HTMLIFrameElement.h

    r200041 r201588  
    2222 */
    2323
    24 #ifndef HTMLIFrameElement_h
    25 #define HTMLIFrameElement_h
     24#pragma once
    2625
    2726#include "HTMLFrameElementBase.h"
    … …  
    3029
    3130class DOMTokenList;
     31class RenderIFrame;
    3232
    3333class HTMLIFrameElement final : public HTMLFrameElementBase {
    … …  
    3737    DOMTokenList& sandbox();
    3838
     39    RenderIFrame* renderer() const;
     40
    3941private:
    4042    HTMLIFrameElement(const QualifiedName&, Document&);
    4143
    4244#if PLATFORM(IOS)
    43     bool isKeyboardFocusable(KeyboardEvent*) const override { return false; }
     45    bool isKeyboardFocusable(KeyboardEvent*) const final { return false; }
    4446#endif
    4547
    46     void parseAttribute(const QualifiedName&, const AtomicString&) override;
    47     bool isPresentationAttribute(const QualifiedName&) const override;
    48     void collectStyleForPresentationAttribute(const QualifiedName&, const AtomicString&, MutableStyleProperties&) override;
     48    void parseAttribute(const QualifiedName&, const AtomicString&) final;
     49    bool isPresentationAttribute(const QualifiedName&) const final;
     50    void collectStyleForPresentationAttribute(const QualifiedName&, const AtomicString&, MutableStyleProperties&) final;
    4951
    50     bool rendererIsNeeded(const RenderStyle&) override;
    51     RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
     52    bool rendererIsNeeded(const RenderStyle&) final;
     53    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) final;
    5254
    5355    std::unique_ptr<DOMTokenList> m_sandbox;
    … …  
    5557
    5658} // namespace WebCore
    57 
    58 #endif // HTMLIFrameElement_h

  • trunk/Source/WebCore/html/HTMLMediaElement.cpp

    r201574 r201588  
    2525
    2626#include "config.h"
     27
    2728#if ENABLE(VIDEO)
     29
    2830#include "HTMLMediaElement.h"
    2931
    … …  
    832834}
    833835
     836inline void HTMLMediaElement::updateRenderer()
     837{
     838    if (auto* renderer = this->renderer())
     839        renderer->updateFromElement();
     840}
     841
    834842void HTMLMediaElement::didAttachRenderers()
    835843{
    836     if (RenderElement* renderer = this->renderer()) {
     844    if (auto* renderer = this->renderer()) {
    837845        renderer->updateFromElement();
    838846        if (m_mediaSession->hasBehaviorRestriction(MediaElementSession::InvisibleAutoplayNotPermitted)
    … …  
    845853void HTMLMediaElement::willDetachRenderers()
    846854{
    847     if (renderer())
    848         renderer()->unregisterForVisibleInViewportCallback();
     855    if (auto* renderer = this->renderer())
     856        renderer->unregisterForVisibleInViewportCallback();
    849857}
    850858
    … …  
    856864void HTMLMediaElement::didRecalcStyle(Style::Change)
    857865{
    858     if (renderer())
    859         renderer()->updateFromElement();
     866    updateRenderer();
    860867}
    861868
    … …  
    14411448    updateDisplayState();
    14421449
    1443     if (renderer())
    1444         renderer()->updateFromElement();
     1450    updateRenderer();
    14451451}
    14461452
    … …  
    19251931
    19261932    updateDisplayState();
    1927 
    1928     if (renderer())
    1929         renderer()->updateFromElement();
     1933    updateRenderer();
    19301934}
    19311935
    … …  
    19681972
    19691973    updateDisplayState();
    1970 
    1971     if (renderer())
    1972         renderer()->updateFromElement();
     1974    updateRenderer();
    19731975}
    19741976
    … …  
    22572259        if (hasMediaControls())
    22582260            mediaControls()->loadedMetadata();
    2259         if (renderer())
    2260             renderer()->updateFromElement();
     2261        updateRenderer();
    22612262
    22622263        if (is<MediaDocument>(document()))
    … …  
    24532454        m_previousProgressTime = time;
    24542455        m_sentStalledEvent = false;
    2455         if (renderer())
    2456             renderer()->updateFromElement();
     2456        updateRenderer();
    24572457        if (hasMediaControls())
    24582458            mediaControls()->bufferingProgressed();
    … …  
    41784178#endif
    41794179        if (mediaURL.isEmpty())
    4180             goto check_again;
     4180            goto CheckAgain;
    41814181       
    41824182        if (source->fastHasAttribute(mediaAttr)) {
    … …  
    41864186                LOG(Media, "HTMLMediaElement::selectNextSourceChild(%p) - 'media' is %s", this, source->media().utf8().data());
    41874187#endif
    4188             if (media && !MediaQueryEvaluator { "screen", document(), renderer() ? &renderer()->style() : nullptr }.evaluate(*media))
    4189                 goto check_again;
     4188            if (media) {
     4189                auto* renderer = this->renderer();
     4190                if (!MediaQueryEvaluator { "screen", document(), renderer ? &renderer->style() : nullptr }.evaluate(*media))
     4191                    goto CheckAgain;
     4192            }
    41904193        }
    41914194
    … …  
    42144217#endif
    42154218            if (!MediaPlayer::supportsType(parameters, this))
    4216                 goto check_again;
     4219                goto CheckAgain;
    42174220        }
    42184221
    … …  
    42244227            LOG(Media, "HTMLMediaElement::selectNextSourceChild(%p) - 'beforeload' removed current element", this);
    42254228            source = 0;
    4226             goto check_again;
     4229            goto CheckAgain;
    42274230        }
    42284231
    42294232        if (!okToLoadSourceURL)
    4230             goto check_again;
     4233            goto CheckAgain;
    42314234
    42324235        // Making it this far means the <source> looks reasonable.
    42334236        canUseSourceElement = true;
    42344237
    4235 check_again:
     4238CheckAgain:
    42364239        if (!canUseSourceElement && actionIfInvalid == Complain && source)
    42374240            source->scheduleErrorEvent();
    … …  
    45124515    beginProcessingMediaPlayerCallback();
    45134516    updateDisplayState();
    4514     if (renderer())
    4515         renderer()->repaint();
     4517    if (auto* renderer = this->renderer())
     4518        renderer->repaint();
    45164519    endProcessingMediaPlayerCallback();
    45174520}
    … …  
    45274530    if (m_readyState > HAVE_NOTHING)
    45284531        scheduleResizeEventIfSizeChanged();
    4529     if (renderer())
    4530         renderer()->updateFromElement();
     4532    updateRenderer();
    45314533    endProcessingMediaPlayerCallback();
    45324534}
    … …  
    45344536bool HTMLMediaElement::mediaPlayerRenderingCanBeAccelerated(MediaPlayer*)
    45354537{
    4536     if (is<RenderVideo>(renderer()))
    4537         return renderer()->view().compositor().canAccelerateVideoRendering(downcast<RenderVideo>(*renderer()));
    4538     return false;
     4538    auto* renderer = this->renderer();
     4539    return is<RenderVideo>(renderer)
     4540        && downcast<RenderVideo>(*renderer).view().compositor().canAccelerateVideoRendering(downcast<RenderVideo>(*renderer));
    45394541}
    45404542
    … …  
    45484550
    45494551#if PLATFORM(WIN) && USE(AVFOUNDATION)
     4552
    45504553GraphicsDeviceAdapter* HTMLMediaElement::mediaPlayerGraphicsDeviceAdapter(const MediaPlayer*) const
    45514554{
    4552     if (!document().page())
    4553         return 0;
    4554 
    4555     return document().page()->chrome().client().graphicsDeviceAdapter();
    4556 }
     4555    auto* page = document().page();
     4556    if (!page)
     4557        return nullptr;
     4558    return page->chrome().client().graphicsDeviceAdapter();
     4559}
     4560
    45574561#endif
    45584562
    … …  
    45614565    LOG(Media, "HTMLMediaElement::mediaEngineWasUpdated(%p)", this);
    45624566    beginProcessingMediaPlayerCallback();
    4563     if (renderer())
    4564         renderer()->updateFromElement();
     4567    updateRenderer();
    45654568    endProcessingMediaPlayerCallback();
    45664569
    … …  
    46314634    if (hasMediaControls())
    46324635        mediaControls()->reset();
    4633     if (renderer())
    4634         renderer()->updateFromElement();
     4636    updateRenderer();
    46354637
    46364638    if (isPlaying() && !m_mediaSession->playbackPermitted(*this))
    … …  
    48964898   
    48974899    updateMediaController();
    4898 
    4899     if (renderer())
    4900         renderer()->updateFromElement();
     4900    updateRenderer();
    49014901}
    49024902
    … …  
    50595059    userCancelledLoad();
    50605060
    5061     if (renderer())
    5062         renderer()->updateFromElement();
    5063    
     5061    updateRenderer();
     5062
    50645063    stopPeriodicTimers();
    50655064
    … …  
    51425141    }
    51435142
    5144     if (renderer())
    5145         renderer()->updateFromElement();
     5143    updateRenderer();
    51465144}
    51475145
    … …  
    62476245LayoutRect HTMLMediaElement::mediaPlayerContentBoxRect() const
    62486246{
    6249     if (renderer())
    6250         return renderer()->enclosingBox().contentBoxRect();
    6251     return LayoutRect();
     6247    auto* renderer = this->renderer();
     6248    if (!renderer)
     6249        return { };
     6250    return renderer->enclosingBox().contentBoxRect();
    62526251}
    62536252
    … …  
    70117010        return false;
    70127011
    7013     RenderElement* renderer = element.renderer();
     7012    auto* renderer = element.renderer();
    70147013    if (!renderer)
    70157014        return false;

  • trunk/Source/WebCore/html/HTMLMediaElement.h

    r201474 r201588  
    2424 */
    2525
    26 #ifndef HTMLMediaElement_h
    27 #define HTMLMediaElement_h
     26#pragma once
    2827
    2928#if ENABLE(VIDEO)
     29
    3030#include "HTMLElement.h"
    3131#include "ActiveDOMObject.h"
    … …  
    5656namespace WebCore {
    5757
    58 #if ENABLE(WEB_AUDIO)
    5958class AudioSourceProvider;
    60 class MediaElementAudioSourceNode;
    61 #endif
     59class AudioTrackList;
     60class AudioTrackPrivate;
    6261class DOMError;
    6362class DisplaySleepDisabler;
    … …  
    6564class HTMLSourceElement;
    6665class HTMLTrackElement;
    67 class URL;
     66class InbandTextTrackPrivate;
    6867class MediaController;
    6968class MediaControls;
    7069class MediaControlsHost;
     70class MediaElementAudioSourceNode;
    7171class MediaError;
     72class MediaKeys;
    7273class MediaPlayer;
     74class MediaSession;
     75class MediaSource;
     76class MediaStream;
     77class RenderMedia;
     78class ScriptExecutionContext;
     79class SourceBuffer;
     80class TextTrackList;
    7381class TimeRanges;
    74 #if ENABLE(ENCRYPTED_MEDIA_V2)
    75 class MediaKeys;
    76 #endif
    77 #if ENABLE(MEDIA_SESSION)
    78 class MediaSession;
    79 #endif
    80 #if ENABLE(MEDIA_SOURCE)
    81 class MediaSource;
    82 class SourceBuffer;
     82class URL;
    8383class VideoPlaybackQuality;
    84 #endif
    85 
    86 #if ENABLE(VIDEO_TRACK)
    87 class AudioTrackList;
    88 class AudioTrackPrivate;
    89 class InbandTextTrackPrivate;
    90 class TextTrackList;
    9184class VideoTrackList;
    9285class VideoTrackPrivate;
    9386
     87#if ENABLE(VIDEO_TRACK)
    9488typedef PODIntervalTree<MediaTime, TextTrackCue*> CueIntervalTree;
    9589typedef CueIntervalTree::IntervalType CueInterval;
    … …  
    9791#endif
    9892
    99 #if ENABLE(MEDIA_STREAM)
    100 class MediaStream;
    101 class ScriptExecutionContext;
    102 #endif
    103 
    10493class HTMLMediaElement
    10594    : public HTMLElement
    106     , private MediaPlayerClient, public MediaPlayerSupportsTypeClient, private MediaCanStartListener, public ActiveDOMObject, public MediaControllerInterface , public PlatformMediaSessionClient, private MediaProducer
     95    , public ActiveDOMObject
     96    , public MediaControllerInterface
     97    , public MediaPlayerSupportsTypeClient
     98    , public PlatformMediaSessionClient
     99    , private MediaCanStartListener
     100    , private MediaPlayerClient
     101    , private MediaProducer
    107102#if ENABLE(VIDEO_TRACK)
    108103    , private AudioTrackClient
    … …  
    467462    void updateShouldPlay();
    468463
     464    RenderMedia* renderer() const;
     465
    469466protected:
    470     HTMLMediaElement(const QualifiedName&, Document&, bool);
     467    HTMLMediaElement(const QualifiedName&, Document&, bool createdByParser);
    471468    virtual ~HTMLMediaElement();
    472469
    … …  
    657654    virtual void scheduleResizeEventIfSizeChanged() { }
    658655
    659     // loading
    660656    void selectMediaResource();
    661657    void loadResource(const URL&, ContentType&, const String& keySystem);
    … …  
    746742#endif
    747743
    748     // PlatformMediaSessionClient Overrides
    749744    PlatformMediaSession::MediaType mediaType() const override;
    750745    PlatformMediaSession::MediaType presentationType() const override;
    … …  
    777772    void resumeFromDocumentSuspension() final;
    778773
    779     enum class UpdateMediaState {
    780         Asynchronously,
    781         Synchronously,
    782     };
     774    enum class UpdateMediaState { Asynchronously, Synchronously };
    783775    void updateMediaState(UpdateMediaState updateState = UpdateMediaState::Synchronously);
    784776    bool hasPlaybackTargetAvailabilityListeners() const { return m_hasPlaybackTargetAvailabilityListeners; }
    … …  
    790782    void pauseAfterDetachedTask();
    791783    void updatePlaybackControlsManager();
     784
     785    void updateRenderer();
    792786
    793787    Timer m_pendingActionTimer;
    … …  
    853847    bool m_preparedForInline;
    854848    std::function<void()> m_preparedForInlineCompletionHandler;
     849
    855850#if PLATFORM(IOS) || (PLATFORM(MAC) && ENABLE(VIDEO_PRESENTATION_MODE))
    856851    RetainPtr<PlatformLayer> m_videoFullscreenLayer;
    … …  
    10361031
    10371032#endif
    1038 #endif

  • trunk/Source/WebCore/html/HTMLSelectElement.cpp

    r201205 r201588  
    392392    setRecalcListItems();
    393393    updateValidity();
    394 
    395     if (renderer()) {
    396         if (AXObjectCache* cache = renderer()->document().existingAXObjectCache())
    397             cache->childrenChanged(this);
    398     }
     394    if (auto* cache = document().existingAXObjectCache())
     395        cache->childrenChanged(this);
    399396}
    400397
    … …  
    470467        } while (++diff);
    471468    } else {
    472         const Vector<HTMLElement*>& items = listItems();
     469        auto& items = listItems();
    473470
    474471        // Removing children fires mutation events, which might mutate the DOM further, so we first copy out a list
    … …  
    512509{
    513510    ASSERT(direction == -1 || direction == 1);
    514     const Vector<HTMLElement*>& listItems = this->listItems();
     511    auto& listItems = this->listItems();
    515512    int lastGoodIndex = listIndex;
    516513    int size = listItems.size();
    … …  
    540537int HTMLSelectElement::firstSelectableListIndex() const
    541538{
    542     const Vector<HTMLElement*>& items = listItems();
     539    auto& items = listItems();
    543540    int index = nextValidIndex(items.size(), SkipBackwards, INT_MAX);
    544541    if (static_cast<size_t>(index) == items.size())
    … …  
    555552int HTMLSelectElement::nextSelectableListIndexPageAway(int startIndex, SkipDirection direction) const
    556553{
    557     const Vector<HTMLElement*>& items = listItems();
     554    auto& items = listItems();
     555
    558556    // Can't use m_size because renderer forces a minimum size.
    559557    int pageSize = 0;
    560     if (is<RenderListBox>(*renderer()))
    561         pageSize = downcast<RenderListBox>(*renderer()).size() - 1; // -1 so we still show context.
     558    auto* renderer = this->renderer();
     559    if (is<RenderListBox>(*renderer))
     560        pageSize = downcast<RenderListBox>(*renderer).size() - 1; // -1 so we still show context.
    562561
    563562    // One page away, but not outside valid bounds.
    … …  
    621620void HTMLSelectElement::updateListBoxSelection(bool deselectOtherOptions)
    622621{
     622    ASSERT(renderer());
     623
    623624#if !PLATFORM(IOS)
    624     ASSERT(renderer() && (renderer()->isListBox() || m_multiple));
     625    ASSERT(renderer()->isListBox() || m_multiple);
    625626#else
    626     ASSERT(renderer() && (renderer()->isMenuList() || m_multiple));
     627    ASSERT(renderer()->isMenuList() || m_multiple);
    627628#endif
     629
    628630    ASSERT(!listItems().size() || m_activeSelectionAnchorIndex >= 0);
    629631
    … …  
    631633    unsigned end = std::max(m_activeSelectionAnchorIndex, m_activeSelectionEndIndex);
    632634
    633     const Vector<HTMLElement*>& items = listItems();
     635    auto& items = listItems();
    634636    for (unsigned i = 0; i < items.size(); ++i) {
    635         HTMLElement* element = items[i];
    636         if (!is<HTMLOptionElement>(*element) || downcast<HTMLOptionElement>(*element).isDisabledFormControl())
     637        auto& element = *items[i];
     638        if (!is<HTMLOptionElement>(element) || downcast<HTMLOptionElement>(element).isDisabledFormControl())
    637639            continue;
    638640
    639641        if (i >= start && i <= end)
    640             downcast<HTMLOptionElement>(*element).setSelectedState(m_activeSelectionState);
     642            downcast<HTMLOptionElement>(element).setSelectedState(m_activeSelectionState);
    641643        else if (deselectOtherOptions || i >= m_cachedStateForActiveSelection.size())
    642             downcast<HTMLOptionElement>(*element).setSelectedState(false);
     644            downcast<HTMLOptionElement>(element).setSelectedState(false);
    643645        else
    644             downcast<HTMLOptionElement>(*element).setSelectedState(m_cachedStateForActiveSelection[i]);
     646            downcast<HTMLOptionElement>(element).setSelectedState(m_cachedStateForActiveSelection[i]);
    645647    }
    646648
    … …  
    653655    ASSERT(!usesMenuList() || m_multiple);
    654656
    655     const Vector<HTMLElement*>& items = listItems();
     657    auto& items = listItems();
    656658
    657659    // If the cached selection list is empty, or the size has changed, then fire
    … …  
    665667    bool fireOnChange = false;
    666668    for (unsigned i = 0; i < items.size(); ++i) {
    667         HTMLElement* element = items[i];
    668         bool selected = is<HTMLOptionElement>(*element) && downcast<HTMLOptionElement>(*element).selected();
     669        auto& element = *items[i];
     670        bool selected = is<HTMLOptionElement>(element) && downcast<HTMLOptionElement>(element).selected();
    669671        if (selected != m_lastOnChangeSelection[i])
    670672            fireOnChange = true;
    … …  
    755757    if (!inDocument())
    756758        invalidateSelectedItems();
    757    
    758     if (renderer()) {
    759         if (AXObjectCache* cache = renderer()->document().existingAXObjectCache())
    760             cache->childrenChanged(this);
    761     }
     759    if (auto* cache = document().existingAXObjectCache())
     760        cache->childrenChanged(this);
    762761}
    763762
    … …  
    858857    bool shouldDeselect = !m_multiple || (flags & DeselectOtherOptions);
    859858
    860     const Vector<HTMLElement*>& items = listItems();
     859    auto& items = listItems();
    861860    int listIndex = optionToListIndex(optionIndex);
    862861
    863862    HTMLElement* element = nullptr;
    864     if (listIndex >= 0) {
     863    if (listIndex >= 0)
    865864        element = items[listIndex];
    866     }
    867865
    868866    if (shouldDeselect)
    … …  
    900898int HTMLSelectElement::optionToListIndex(int optionIndex) const
    901899{
    902     const Vector<HTMLElement*>& items = listItems();
     900    auto& items = listItems();
    903901    int listSize = static_cast<int>(items.size());
    904902    if (optionIndex < 0 || optionIndex >= listSize)
    … …  
    919917int HTMLSelectElement::listToOptionIndex(int listIndex) const
    920918{
    921     const Vector<HTMLElement*>& items = listItems();
     919    auto& items = listItems();
    922920    if (listIndex < 0 || listIndex >= static_cast<int>(items.size()) || !is<HTMLOptionElement>(*items[listIndex]))
    923921        return -1;
    … …  
    978976size_t HTMLSelectElement::searchOptionsForValue(const String& value, size_t listIndexStart, size_t listIndexEnd) const
    979977{
    980     const Vector<HTMLElement*>& items = listItems();
     978    auto& items = listItems();
    981979    size_t loopEndIndex = std::min(items.size(), listIndexEnd);
    982980    for (size_t i = listIndexStart; i < loopEndIndex; ++i) {
    … …  
    993991    recalcListItems();
    994992
    995     const Vector<HTMLElement*>& items = listItems();
     993    auto& items = listItems();
    996994    size_t itemsSize = items.size();
    997995    if (!itemsSize)
    … …  
    10861084
    10871085#if !PLATFORM(WIN)
     1086
    10881087bool HTMLSelectElement::platformHandleKeydownEvent(KeyboardEvent* event)
    10891088{
    … …  
    11001099            // that our caller doesn't process the event further, but don't set
    11011100            // the event as handled.
    1102             if (!is<RenderMenuList>(renderer()))
     1101            auto* renderer = this->renderer();
     1102            if (!is<RenderMenuList>(renderer))
    11031103                return true;
    11041104
    … …  
    11081108            // after the user makes a selection from the menu.
    11091109            saveLastSelection();
    1110             downcast<RenderMenuList>(*renderer()).showPopup();
     1110            downcast<RenderMenuList>(*renderer).showPopup();
    11111111            event->setDefaultHandled();
    11121112        }
    … …  
    11161116    return false;
    11171117}
     1118
    11181119#endif
    11191120
    11201121void HTMLSelectElement::menuListDefaultEventHandler(Event* event)
    11211122{
    1122     ASSERT(renderer() && renderer()->isMenuList());
     1123    ASSERT(renderer());
     1124    ASSERT(renderer()->isMenuList());
    11231125
    11241126    const Page* page = document().page();
    … …  
    11431145        const String& keyIdentifier = keyboardEvent.keyIdentifier();
    11441146        bool handled = true;
    1145         const Vector<HTMLElement*>& listItems = this->listItems();
     1147        auto& listItems = this->listItems();
    11461148        int listIndex = optionToListIndex(selectedIndex());
    11471149
    … …  
    11971199                focus();
    11981200
    1199                 // Calling focus() may remove the renderer or change the
    1200                 // renderer type.
    1201                 if (!is<RenderMenuList>(renderer()))
     1201                // Calling focus() may remove the renderer or change the renderer type.
     1202                auto* renderer = this->renderer();
     1203                if (!is<RenderMenuList>(renderer))
    12021204                    return;
    12031205
    … …  
    12071209                // after the user makes a selection from the menu.
    12081210                saveLastSelection();
    1209                 downcast<RenderMenuList>(*renderer()).showPopup();
     1211                downcast<RenderMenuList>(*renderer).showPopup();
    12101212                handled = true;
    12111213            }
    … …  
    12141216                focus();
    12151217
    1216                 // Calling focus() may remove the renderer or change the
    1217                 // renderer type.
    1218                 if (!is<RenderMenuList>(renderer()))
     1218                // Calling focus() may remove the renderer or change the renderer type.
     1219                auto* renderer = this->renderer();
     1220                if (!is<RenderMenuList>(renderer))
    12191221                    return;
    12201222
    … …  
    12241226                // after the user makes a selection from the menu.
    12251227                saveLastSelection();
    1226                 downcast<RenderMenuList>(*renderer()).showPopup();
     1228                downcast<RenderMenuList>(*renderer).showPopup();
    12271229                handled = true;
    12281230            } else if (keyCode == '\r') {
    … …  
    12411243        focus();
    12421244#if !PLATFORM(IOS)
    1243         if (is<RenderMenuList>(renderer())) {
    1244             auto& menuList = downcast<RenderMenuList>(*renderer());
     1245        auto* renderer = this->renderer();
     1246        if (is<RenderMenuList>(renderer)) {
     1247            auto& menuList = downcast<RenderMenuList>(*renderer);
    12451248            ASSERT(!menuList.popupIsVisible());
    12461249            // Save the selection so it can be compared to the new
    … …  
    12781281    bool multiSelect = m_multiple && multi && !shift;
    12791282
    1280     HTMLElement* clickedElement = listItems()[listIndex];
    1281     if (is<HTMLOptionElement>(*clickedElement)) {
     1283    auto& clickedElement = *listItems()[listIndex];
     1284    if (is<HTMLOptionElement>(clickedElement)) {
    12821285        // Keep track of whether an active selection (like during drag
    12831286        // selection), should select or deselect.
    1284         if (downcast<HTMLOptionElement>(*clickedElement).selected() && multiSelect)
     1287        if (downcast<HTMLOptionElement>(clickedElement).selected() && multiSelect)
    12851288            m_activeSelectionState = false;
    12861289        if (!m_activeSelectionState)
    1287             downcast<HTMLOptionElement>(*clickedElement).setSelectedState(false);
     1290            downcast<HTMLOptionElement>(clickedElement).setSelectedState(false);
    12881291    }
    12891292
    … …  
    12921295    // this will deselect all items in the list.
    12931296    if (!shiftSelect && !multiSelect)
    1294         deselectItemsWithoutValidation(clickedElement);
     1297        deselectItemsWithoutValidation(&clickedElement);
    12951298
    12961299    // If the anchor hasn't been set, and we're doing a single selection or a
    … …  
    13001303
    13011304    // Set the selection state of the clicked option.
    1302     if (is<HTMLOptionElement>(*clickedElement) && !downcast<HTMLOptionElement>(*clickedElement).isDisabledFormControl())
    1303         downcast<HTMLOptionElement>(*clickedElement).setSelectedState(true);
     1305    if (is<HTMLOptionElement>(clickedElement) && !downcast<HTMLOptionElement>(clickedElement).isDisabledFormControl())
     1306        downcast<HTMLOptionElement>(clickedElement).setSelectedState(true);
    13041307
    13051308    // If there was no selectedIndex() for the previous initialization, or If
    … …  
    13161319void HTMLSelectElement::listBoxDefaultEventHandler(Event* event)
    13171320{
    1318     const Vector<HTMLElement*>& listItems = this->listItems();
     1321    auto& listItems = this->listItems();
    13191322
    13201323    if (event->type() == eventNames().mousedownEvent && is<MouseEvent>(*event) && downcast<MouseEvent>(*event).button() == LeftButton) {
    13211324        focus();
     1325
    13221326        // Calling focus() may remove or change our renderer, in which case we don't want to handle the event further.
    1323         if (!is<RenderListBox>(renderer()))
     1327        auto* renderer = this->renderer();
     1328        if (!is<RenderListBox>(renderer))
    13241329            return;
     1330        auto& renderListBox = downcast<RenderListBox>(*renderer);
    13251331
    13261332        // Convert to coords relative to the list box if needed.
    13271333        MouseEvent& mouseEvent = downcast<MouseEvent>(*event);
    1328         IntPoint localOffset = roundedIntPoint(renderer()->absoluteToLocal(mouseEvent.absoluteLocation(), UseTransforms));
    1329         int listIndex = downcast<RenderListBox>(*renderer()).listIndexAtOffset(toIntSize(localOffset));
     1334        IntPoint localOffset = roundedIntPoint(renderListBox.absoluteToLocal(mouseEvent.absoluteLocation(), UseTransforms));
     1335        int listIndex = renderListBox.listIndexAtOffset(toIntSize(localOffset));
    13301336        if (listIndex >= 0) {
    13311337            if (!isDisabledFormControl()) {
    … …  
    13411347            mouseEvent.setDefaultHandled();
    13421348        }
    1343     } else if (event->type() == eventNames().mousemoveEvent && is<MouseEvent>(*event) && !downcast<RenderBox>(*renderer()).canBeScrolledAndHasScrollableArea()) {
     1349    } else if (event->type() == eventNames().mousemoveEvent && is<MouseEvent>(*event) && !downcast<RenderListBox>(*renderer()).canBeScrolledAndHasScrollableArea()) {
    13441350        MouseEvent& mouseEvent = downcast<MouseEvent>(*event);
    13451351        if (mouseEvent.button() != LeftButton || !mouseEvent.buttonDown())
    13461352            return;
    13471353
    1348         IntPoint localOffset = roundedIntPoint(renderer()->absoluteToLocal(mouseEvent.absoluteLocation(), UseTransforms));
    1349         int listIndex = downcast<RenderListBox>(*renderer()).listIndexAtOffset(toIntSize(localOffset));
     1354        auto& renderListBox = downcast<RenderListBox>(*renderer());
     1355        IntPoint localOffset = roundedIntPoint(renderListBox.absoluteToLocal(mouseEvent.absoluteLocation(), UseTransforms));
     1356        int listIndex = renderListBox.listIndexAtOffset(toIntSize(localOffset));
    13501357        if (listIndex >= 0) {
    13511358            if (!isDisabledFormControl()) {
    … …  
    14891496void HTMLSelectElement::defaultEventHandler(Event* event)
    14901497{
    1491     if (!renderer())
     1498    auto* renderer = this->renderer();
     1499    if (!renderer)
    14921500        return;
    14931501
    … …  
    14981506    }
    14991507
    1500     if (renderer()->isMenuList())
     1508    if (renderer->isMenuList())
    15011509        menuListDefaultEventHandler(event);
    15021510    else
    … …  
    15211529int HTMLSelectElement::lastSelectedListIndex() const
    15221530{
    1523     const Vector<HTMLElement*>& items = listItems();
     1531    auto& items = listItems();
    15241532    for (size_t i = items.size(); i;) {
    1525         HTMLElement* element = items[--i];
    1526         if (is<HTMLOptionElement>(*element) && downcast<HTMLOptionElement>(*element).selected())
     1533        auto& element = *items[--i];
     1534        if (is<HTMLOptionElement>(element) && downcast<HTMLOptionElement>(element).selected())
    15271535            return i;
    15281536    }
    … …  
    15421550String HTMLSelectElement::optionAtIndex(int index) const
    15431551{
    1544     const Vector<HTMLElement*>& items = listItems();
    1545    
    1546     HTMLElement* element = items[index];
    1547     if (!is<HTMLOptionElement>(*element) || downcast<HTMLOptionElement>(*element).isDisabledFormControl())
     1552    auto& element = *listItems()[index];
     1553    if (!is<HTMLOptionElement>(element) || downcast<HTMLOptionElement>(element).isDisabledFormControl())
    15481554        return String();
    1549     return downcast<HTMLOptionElement>(*element).textIndentedToRespectGroupLabel();
     1555    return downcast<HTMLOptionElement>(element).textIndentedToRespectGroupLabel();
    15501556}
    15511557
    … …  
    15761582   
    15771583    // If this index is already selected, unselect. otherwise update the selected index.
    1578     const Vector<HTMLElement*>& items = listItems();
     1584    auto& items = listItems();
    15791585    int listIndex = optionToListIndex(index);
    15801586    if (listIndex >= 0) {
    1581         HTMLElement* element = items[listIndex];
    1582         if (is<HTMLOptionElement>(*element)) {
    1583             if (downcast<HTMLOptionElement>(*element).selected())
    1584                 downcast<HTMLOptionElement>(*element).setSelectedState(false);
     1587        auto& element = *items[listIndex];
     1588        if (is<HTMLOptionElement>(element)) {
     1589            if (downcast<HTMLOptionElement>(element).selected())
     1590                downcast<HTMLOptionElement>(element).setSelectedState(false);
    15851591            else
    15861592                selectOption(index, DispatchChangeEvent | UserDriven);
    … …  
    16001606    unsigned options = 0;
    16011607
    1602     const Vector<HTMLElement*>& items = listItems();
     1608    auto& items = listItems();
    16031609    for (unsigned i = 0; i < items.size(); ++i) {
    16041610        if (is<HTMLOptionElement>(*items[i]))

  • trunk/Source/WebCore/html/HTMLTextAreaElement.h

    r200041 r201588  
    2222 */
    2323
    24 #ifndef HTMLTextAreaElement_h
    25 #define HTMLTextAreaElement_h
     24#pragma once
    2625
    2726#include "HTMLTextFormControlElement.h"
    … …  
    3029
    3130class BeforeTextInsertedEvent;
     31class RenderTextControlMultiLine;
    3232class VisibleSelection;
    3333
    … …  
    6363
    6464    bool willRespondToMouseClickEvents() override;
     65
     66    RenderTextControlMultiLine* renderer() const;
    6567
    6668private:
    … …  
    133135
    134136} //namespace
    135 
    136 #endif

  • trunk/Source/WebCore/html/HTMLVideoElement.cpp

    r200361 r201588  
    2525
    2626#include "config.h"
     27
    2728#if ENABLE(VIDEO)
     29
    2830#include "HTMLVideoElement.h"
    2931
    … …  
    8890            m_imageLoader = std::make_unique<HTMLImageLoader>(*this);
    8991        m_imageLoader->updateFromElement();
    90         if (renderer())
    91             downcast<RenderImage>(*renderer()).imageResource().setCachedImage(m_imageLoader->image());
     92        if (auto* renderer = this->renderer())
     93            renderer->imageResource().setCachedImage(m_imageLoader->image());
    9294    }
    9395}
    … …  
    122124            m_imageLoader->updateFromElementIgnoringPreviousError();
    123125        } else {
    124             if (renderer())
    125                 downcast<RenderImage>(*renderer()).imageResource().setCachedImage(nullptr);
     126            if (auto* renderer = this->renderer())
     127                renderer->imageResource().setCachedImage(nullptr);
    126128        }
    127129    }
    … …  
    247249    }
    248250
    249     if (renderer() && displayMode() != oldMode)
    250         renderer()->updateFromElement();
     251    if (auto* renderer = this->renderer()) {
     252        if (displayMode() != oldMode)
     253            renderer->updateFromElement();
     254    }
    251255}
    252256

  • trunk/Source/WebCore/html/HTMLVideoElement.h

    r200361 r201588  
    3434
    3535class HTMLImageLoader;
     36class RenderVideo;
    3637
    3738class HTMLVideoElement final : public HTMLMediaElement {
    3839public:
    39     static Ref<HTMLVideoElement> create(const QualifiedName&, Document&, bool);
     40    static Ref<HTMLVideoElement> create(const QualifiedName&, Document&, bool createdByParser);
    4041
    4142    WEBCORE_EXPORT unsigned videoWidth() const;
    … …  
    9192#endif
    9293
     94    RenderVideo* renderer() const;
     95
    9396private:
    94     HTMLVideoElement(const QualifiedName&, Document&, bool);
     97    HTMLVideoElement(const QualifiedName&, Document&, bool createdByParser);
    9598
    9699    void scheduleResizeEvent() override;

  • trunk/Source/WebCore/html/HTMLWBRElement.h

    r200041 r201588  
    2424 */
    2525
    26 #ifndef HTMLWBRElement_h
    27 #define HTMLWBRElement_h
     26#pragma once
    2827
    2928#include "HTMLElement.h"
    … …  
    3130namespace WebCore {
    3231
     32class RenderLineBreak;
     33
    3334class HTMLWBRElement final : public HTMLElement {
    3435public:
    3536    static Ref<HTMLWBRElement> create(const QualifiedName&, Document&);
     37
     38    RenderLineBreak* renderer() const;
    3639
    3740private:
    … …  
    4245
    4346} // namespace WebCore
    44 
    45 #endif // HTMLWBRElement_h
    46 

  • trunk/Source/WebCore/html/MediaElementSession.cpp

    r201167 r201588  
    4444#include "Page.h"
    4545#include "PlatformMediaSessionManager.h"
     46#include "RenderMedia.h"
    4647#include "RenderView.h"
    4748#include "ScriptController.h"
    … …  
    229230        return false;
    230231
    231     RenderBox* renderer = downcast<RenderBox>(element.renderer());
    232     if (!renderer)
     232    if (!element.renderer())
    233233        return false;
    234234
    … …  
    511511
    512512    // Elements which have not yet been laid out, or which are not yet in the DOM, cannot be main content.
    513     RenderBox* renderer = downcast<RenderBox>(element.renderer());
     513    auto* renderer = element.renderer();
    514514    if (!renderer)
    515515        return false;
    … …  
    521521    // But elements which have audio & video and are already playing should not stop playing because
    522522    // they are scrolled off the page.
    523     if (renderer->style().visibility() != VISIBLE
    524         || (renderer->visibleInViewportState() != RenderElement::VisibleInViewport && !element.isPlaying())
    525         ) {
    526         return false;
    527     }
     523    if (renderer->style().visibility() != VISIBLE)
     524        return false;
     525    if (renderer->visibleInViewportState() != RenderElement::VisibleInViewport && !element.isPlaying())
     526        return false;
    528527
    529528    // Main content elements must be in the main frame.
    … …  
    562561
    563562    // Elements which have not yet been laid out, or which are not yet in the DOM, cannot be main content.
    564     RenderBox* renderer = downcast<RenderBox>(element.renderer());
     563    auto* renderer = element.renderer();
    565564    if (!renderer)
    566565        return false;

  • trunk/Source/WebCore/html/TextFieldInputType.cpp

    r200041 r201588  
    194194        element().document().updateStyleIfNeeded();
    195195
     196        auto* renderer = element().renderer();
    196197        if (element().renderer()) {
    197             RenderTextControlSingleLine& renderTextControl = downcast<RenderTextControlSingleLine>(*element().renderer());
    198198            if (event->type() == eventNames().blurEvent) {
    199                 if (RenderTextControlInnerBlock* innerTextRenderer = innerTextElement()->renderer()) {
    200                     if (RenderLayer* innerLayer = innerTextRenderer->layer()) {
    201                         ScrollOffset scrollOffset(!renderTextControl.style().isLeftToRightDirection() ? innerLayer->scrollWidth() : 0, 0);
     199                if (auto* innerTextRenderer = innerTextElement()->renderer()) {
     200                    if (auto* innerLayer = innerTextRenderer->layer()) {
     201                        bool isLeftToRightDirection = downcast<RenderTextControlSingleLine>(*renderer).style().isLeftToRightDirection();
     202                        ScrollOffset scrollOffset(isLeftToRightDirection ? 0 : innerLayer->scrollWidth(), 0);
    202203                        innerLayer->scrollToOffset(scrollOffset, RenderLayer::ScrollOffsetClamped);
    203204                    }
    204205                }
    205 
    206206                capsLockStateMayHaveChanged();
    207207            } else if (event->type() == eventNames().focusEvent)

  • trunk/Source/WebCore/html/shadow/SliderThumbElement.cpp

    r200895 r201588  
    254254{
    255255    RefPtr<HTMLInputElement> input = hostInput();
    256     if (!input || !input->renderer() || !renderBox())
    257         return;
    258 
    259     HTMLElement* trackElement = input->sliderTrackElement();
    260     if (!trackElement->renderBox())
     256    if (!input)
     257        return;
     258
     259    auto* inputRenderer = input->renderBox();
     260    if (!inputRenderer)
     261        return;
     262
     263    auto* thumbRenderer = renderBox();
     264    if (!thumbRenderer)
     265        return;
     266
     267    ASSERT(input->sliderTrackElement());
     268    auto* trackRenderer = input->sliderTrackElement()->renderBox();
     269    if (!trackRenderer)
    261270        return;
    262271
    263272    // Do all the tracking math relative to the input's renderer's box.
    264     RenderBox& inputRenderer = downcast<RenderBox>(*input->renderer());
    265     RenderBox& trackRenderer = *trackElement->renderBox();
    266273
    267274    bool isVertical = hasVerticalAppearance(*input);
    268     bool isLeftToRightDirection = renderBox()->style().isLeftToRightDirection();
     275    bool isLeftToRightDirection = thumbRenderer->style().isLeftToRightDirection();
    269276   
    270     LayoutPoint offset(inputRenderer.absoluteToLocal(absolutePoint, UseTransforms));
    271     FloatRect trackBoundingBox = trackRenderer.localToContainerQuad(FloatRect(0, 0, trackRenderer.width(), trackRenderer.height()), &inputRenderer).enclosingBoundingBox();
     277    auto offset = inputRenderer->absoluteToLocal(absolutePoint, UseTransforms);
     278    auto trackBoundingBox = trackRenderer->localToContainerQuad(FloatRect { { }, trackRenderer->size() }, inputRenderer).enclosingBoundingBox();
    272279
    273280    LayoutUnit trackLength;
    274281    LayoutUnit position;
    275282    if (isVertical) {
    276         trackLength = trackRenderer.contentHeight() - renderBox()->height();
    277         position = offset.y() - renderBox()->height() / 2 - trackBoundingBox.y() - renderBox()->marginBottom();
     283        trackLength = trackRenderer->contentHeight() - thumbRenderer->height();
     284        position = offset.y() - thumbRenderer->height() / 2 - trackBoundingBox.y() - thumbRenderer->marginBottom();
    278285    } else {
    279         trackLength = trackRenderer.contentWidth() - renderBox()->width();
    280         position = offset.x() - renderBox()->width() / 2 - trackBoundingBox.x();
    281         position -= isLeftToRightDirection ? renderBox()->marginLeft() : renderBox()->marginRight();
     286        trackLength = trackRenderer->contentWidth() - thumbRenderer->width();
     287        position = offset.x() - thumbRenderer->width() / 2 - trackBoundingBox.x();
     288        position -= isLeftToRightDirection ? thumbRenderer->marginLeft() : thumbRenderer->marginRight();
    282289    }
    283290
    284291    position = std::max<LayoutUnit>(0, std::min(position, trackLength));
    285     const Decimal ratio = Decimal::fromDouble(static_cast<double>(position) / trackLength);
    286     const Decimal fraction = isVertical || !isLeftToRightDirection ? Decimal(1) - ratio : ratio;
    287     StepRange stepRange(input->createStepRange(RejectAny));
    288     Decimal value = stepRange.clampValue(stepRange.valueFromProportion(fraction));
     292    auto ratio = Decimal::fromDouble(static_cast<double>(position) / trackLength);
     293    auto fraction = isVertical || !isLeftToRightDirection ? Decimal(1) - ratio : ratio;
     294    auto stepRange = input->createStepRange(RejectAny);
     295    auto value = stepRange.clampValue(stepRange.valueFromProportion(fraction));
    289296
    290297#if ENABLE(DATALIST_ELEMENT)

  • trunk/Source/WebCore/html/shadow/TextControlInnerElements.cpp

    r200098 r201588  
    179179{
    180180    // On mousedown, bring up a menu, if needed
    181     HTMLInputElement* input = downcast<HTMLInputElement>(shadowHost());
     181    auto* input = downcast<HTMLInputElement>(shadowHost());
    182182    if (input && event->type() == eventNames().mousedownEvent && is<MouseEvent>(*event) && downcast<MouseEvent>(*event).button() == LeftButton) {
    183183        input->focus();
    184184        input->select();
    185185#if !PLATFORM(IOS)
    186         if (RenderObject* renderer = input->renderer()) {
    187             RenderSearchField& searchFieldRenderer = downcast<RenderSearchField>(*renderer);
     186        if (auto* renderer = input->renderer()) {
     187            auto& searchFieldRenderer = downcast<RenderSearchField>(*renderer);
    188188            if (searchFieldRenderer.popupIsVisible())
    189189                searchFieldRenderer.hidePopup();

  • trunk/Source/WebCore/page/EventHandler.cpp

    r201384 r201588  
    17761776static ScrollableArea* enclosingScrollableArea(Node* node)
    17771777{
    1778     if (!node)
    1779         return nullptr;
    1780 
    1781     for (auto element = node; element; element = element->parentOrShadowHostNode()) {
    1782         if (is<HTMLIFrameElement>(*element) || is<HTMLHtmlElement>(*element) || is<HTMLDocument>(*element))
     1778    for (auto ancestor = node; ancestor; ancestor = ancestor->parentOrShadowHostNode()) {
     1779        if (is<HTMLIFrameElement>(*ancestor) || is<HTMLHtmlElement>(*ancestor) || is<HTMLDocument>(*ancestor))
    17831780            return nullptr;
    17841781
    1785         auto renderer = element->renderer();
     1782        auto renderer = ancestor->renderer();
    17861783        if (!renderer)
    17871784            continue;

  • trunk/Source/WebCore/page/PrintContext.cpp

    r199964 r201588  
    223223}
    224224
    225 static RenderBoxModelObject* enclosingBoxModelObject(RenderObject* object)
    226 {
    227 
    228     while (object && !is<RenderBoxModelObject>(*object))
    229         object = object->parent();
    230     if (!object)
    231         return nullptr;
    232     return downcast<RenderBoxModelObject>(object);
     225static inline RenderBoxModelObject* enclosingBoxModelObject(RenderElement* renderer)
     226{
     227    while (renderer && !is<RenderBoxModelObject>(*renderer))
     228        renderer = renderer->parent();
     229    return downcast<RenderBoxModelObject>(renderer);
    233230}
    234231
    … …  
    239236    element->document().updateLayout();
    240237
    241     RenderBoxModelObject* box = enclosingBoxModelObject(element->renderer());
     238    auto* box = enclosingBoxModelObject(element->renderer());
    242239    if (!box)
    243240        return -1;

  • trunk/Source/WebCore/page/SpatialNavigation.cpp

    r201205 r201588  
    420420bool isScrollableNode(const Node* node)
    421421{
     422    if (!node)
     423        return false;
    422424    ASSERT(!node->isDocumentNode());
    423 
    424     if (!node)
    425         return false;
    426 
    427     if (RenderObject* renderer = node->renderer())
    428         return is<RenderBox>(*renderer) && downcast<RenderBox>(*renderer).canBeScrolledAndHasScrollableArea() && node->hasChildNodes();
    429 
    430     return false;
     425    auto* renderer = node->renderer();
     426    return is<RenderBox>(renderer) && downcast<RenderBox>(*renderer).canBeScrolledAndHasScrollableArea() && node->hasChildNodes();
    431427}
    432428

  • trunk/Source/WebCore/platform/ios/WebVideoFullscreenControllerAVKit.mm

    r201474 r201588  
    4242#import <WebCore/FrameView.h>
    4343#import <WebCore/HTMLVideoElement.h>
    44 #import <WebCore/RenderElement.h>
     44#import <WebCore/RenderVideo.h>
    4545#import <WebCore/WebCoreThreadRun.h>
    4646
    … …  
    8282static IntRect elementRectInWindow(HTMLVideoElement* videoElement)
    8383{
    84     if (!videoElement || !videoElement->renderer() || !videoElement->document().view())
    85         return IntRect();
    86    
    87     return videoElement->document().view()->convertToContainingWindow(videoElement->renderer()->absoluteBoundingBoxRect());
     84    if (!videoElement)
     85        return { };
     86    auto* renderer = videoElement->renderer();
     87    auto* view = videoElement->document().view();
     88    if (!renderer || !view)
     89        return { };
     90    return view->convertToContainingWindow(renderer->absoluteBoundingBoxRect());
    8891}
    8992

  • trunk/Source/WebCore/rendering/RenderAttachment.h

    r200041 r201588  
    2424 */
    2525
    26 #ifndef RenderAttachment_h
    27 #define RenderAttachment_h
     26#pragma once
    2827
    2928#if ENABLE(ATTACHMENT_ELEMENT)
    3029
     30#include "HTMLAttachmentElement.h"
    3131#include "RenderReplaced.h"
    3232
    3333namespace WebCore {
    34 
    35 class HTMLAttachmentElement;
    3634
    3735class RenderAttachment final : public RenderReplaced {
    … …  
    5553};
    5654
     55inline RenderAttachment* HTMLAttachmentElement::renderer() const
     56{
     57    return downcast<RenderAttachment>(HTMLElement::renderer());
     58}
     59
    5760} // namespace WebCore
    5861
    … …  
    6063
    6164#endif // ENABLE(ATTACHMENT_ELEMENT)
    62 #endif // RenderAttachment_h

  • trunk/Source/WebCore/rendering/RenderFrame.cpp

    r200041 r201588  
    2626
    2727#include "HTMLFrameElement.h"
     28#include "RenderFrameSet.h"
    2829
    2930namespace WebCore {

  • trunk/Source/WebCore/rendering/RenderFrame.h

    r200041 r201588  
    2121 */
    2222
    23 #ifndef RenderFrame_h
    24 #define RenderFrame_h
     23#pragma once
    2524
     25#include "HTMLFrameElement.h"
    2626#include "RenderFrameBase.h"
    27 #include "RenderFrameSet.h"
    2827
    2928namespace WebCore {
    3029
    31 class HTMLFrameElement;
     30struct FrameEdgeInfo;
    3231
    3332class RenderFrame final : public RenderFrameBase {
    … …  
    3837    FrameEdgeInfo edgeInfo() const;
    3938
     39    void updateFromElement() final;
     40
    4041private:
    4142    void frameOwnerElement() const = delete;
    4243
    43     const char* renderName() const override { return "RenderFrame"; }
    44     bool isFrame() const override { return true; }
     44    const char* renderName() const final { return "RenderFrame"; }
     45    bool isFrame() const final { return true; }
     46};
    4547
    46     void updateFromElement() override;
    47 };
     48inline RenderFrame* HTMLFrameElement::renderer() const
     49{
     50    return downcast<RenderFrame>(HTMLFrameElementBase::renderer());
     51}
    4852
    4953} // namespace WebCore
    5054
    5155SPECIALIZE_TYPE_TRAITS_RENDER_OBJECT(RenderFrame, isFrame())
    52 
    53 #endif // RenderFrame_h

  • trunk/Source/WebCore/rendering/RenderLayerFilterInfo.cpp

    r186392 r201588  
    107107        } else {
    108108            // Reference is internal; add layer as a client so we can trigger filter repaint on SVG attribute change.
    109             Element* filter = m_layer.renderer().document().getElementById(referenceOperation.fragment());
    110             if (!filter || !is<RenderSVGResourceFilter>(filter->renderer()))
     109            auto* filter = m_layer.renderer().document().getElementById(referenceOperation.fragment());
     110            if (!filter)
    111111                continue;
    112             downcast<RenderSVGResourceFilter>(*filter->renderer()).addClientRenderLayer(&m_layer);
     112            auto* renderer = filter->renderer();
     113            if (!is<RenderSVGResourceFilter>(renderer))
     114                continue;
     115            downcast<RenderSVGResourceFilter>(*renderer).addClientRenderLayer(&m_layer);
    113116            m_internalSVGReferences.append(filter);
    114117        }

  • trunk/Source/WebCore/rendering/RenderMedia.h

    r200041 r201588  
    2424 */
    2525
    26 #ifndef RenderMedia_h
    27 #define RenderMedia_h
     26#pragma once
    2827
    2928#if ENABLE(VIDEO)
    … …  
    6160};
    6261
     62inline RenderMedia* HTMLMediaElement::renderer() const
     63{
     64    return downcast<RenderMedia>(HTMLElement::renderer());
     65}
     66
    6367} // namespace WebCore
    6468
    … …  
    6670
    6771#endif // ENABLE(VIDEO)
    68 
    69 #endif // RenderMedia_h

  • trunk/Source/WebCore/rendering/RenderTextControlMultiLine.h

    r200041 r201588  
    2020 */
    2121
    22 #ifndef RenderTextControlMultiLine_h
    23 #define RenderTextControlMultiLine_h
     22#pragma once
    2423
     24#include "HTMLTextAreaElement.h"
    2525#include "RenderTextControl.h"
    2626
    2727namespace WebCore {
    28 
    29 class HTMLTextAreaElement;
    3028
    3129class RenderTextControlMultiLine final : public RenderTextControl {
    … …  
    5149};
    5250
     51inline RenderTextControlMultiLine* HTMLTextAreaElement::renderer() const
     52{
     53    return downcast<RenderTextControlMultiLine>(HTMLTextFormControlElement::renderer());
     54}
     55
    5356} // namespace WebCore
    5457
    5558SPECIALIZE_TYPE_TRAITS_RENDER_OBJECT(RenderTextControlMultiLine, isTextArea())
    56 
    57 #endif // RenderTextControlMultiLine_h

  • trunk/Source/WebCore/rendering/RenderVideo.cpp

    r200041 r201588  
    278278
    279279#if ENABLE(FULLSCREEN_API)
    280 static const RenderBlock* rendererPlaceholder(const RenderObject* renderer)
    281 {
    282     RenderObject* parent = renderer->parent();
     280
     281static const RenderBlock* placeholder(const RenderVideo& renderer)
     282{
     283    auto* parent = renderer.parent();
    283284    return is<RenderFullScreen>(parent) ? downcast<RenderFullScreen>(*parent).placeholder() : nullptr;
    284285}
    … …  
    286287LayoutUnit RenderVideo::offsetLeft() const
    287288{
    288     if (const RenderBlock* block = rendererPlaceholder(this))
     289    if (auto* block = placeholder(*this))
    289290        return block->offsetLeft();
    290291    return RenderMedia::offsetLeft();
    … …  
    293294LayoutUnit RenderVideo::offsetTop() const
    294295{
    295     if (const RenderBlock* block = rendererPlaceholder(this))
     296    if (auto* block = placeholder(*this))
    296297        return block->offsetTop();
    297298    return RenderMedia::offsetTop();
    … …  
    300301LayoutUnit RenderVideo::offsetWidth() const
    301302{
    302     if (const RenderBlock* block = rendererPlaceholder(this))
     303    if (auto* block = placeholder(*this))
    303304        return block->offsetWidth();
    304305    return RenderMedia::offsetWidth();
    … …  
    307308LayoutUnit RenderVideo::offsetHeight() const
    308309{
    309     if (const RenderBlock* block = rendererPlaceholder(this))
     310    if (auto* block = placeholder(*this))
    310311        return block->offsetHeight();
    311312    return RenderMedia::offsetHeight();
    312313}
     314
    313315#endif
    314316

  • trunk/Source/WebCore/rendering/RenderVideo.h

    r200041 r201588  
    2424 */
    2525
    26 #ifndef RenderVideo_h
    27 #define RenderVideo_h
     26#pragma once
    2827
    2928#if ENABLE(VIDEO)
    3029
     30#include "HTMLVideoElement.h"
    3131#include "RenderMedia.h"
    3232
    3333namespace WebCore {
    34 
    35 class HTMLVideoElement;
    3634
    3735class RenderVideo final : public RenderMedia {
    … …  
    5351    bool shouldDisplayVideo() const;
    5452
     53    void updateFromElement() final;
     54
    5555private:
    5656    void mediaElement() const = delete;
    5757
    58     void updateFromElement() override;
    59 
    60     void intrinsicSizeChanged() override;
     58    void intrinsicSizeChanged() final;
    6159    LayoutSize calculateIntrinsicSize();
    6260    bool updateIntrinsicSize();
    6361
    64     void imageChanged(WrappedImagePtr, const IntRect*) override;
     62    void imageChanged(WrappedImagePtr, const IntRect*) final;
    6563
    66     const char* renderName() const override { return "RenderVideo"; }
     64    const char* renderName() const final { return "RenderVideo"; }
    6765
    68     bool requiresLayer() const override { return true; }
    69     bool isVideo() const override { return true; }
     66    bool requiresLayer() const final { return true; }
     67    bool isVideo() const final { return true; }
    7068
    71     void paintReplaced(PaintInfo&, const LayoutPoint&) override;
     69    void paintReplaced(PaintInfo&, const LayoutPoint&) final;
    7270
    73     void layout() override;
     71    void layout() final;
    7472
    75     LayoutUnit computeReplacedLogicalWidth(ShouldComputePreferred  = ComputeActual) const override;
    76     LayoutUnit computeReplacedLogicalHeight() const override;
    77     LayoutUnit minimumReplacedHeight() const override;
     73    LayoutUnit computeReplacedLogicalWidth(ShouldComputePreferred  = ComputeActual) const final;
     74    LayoutUnit computeReplacedLogicalHeight() const final;
     75    LayoutUnit minimumReplacedHeight() const final;
    7876
    7977#if ENABLE(FULLSCREEN_API)
    80     LayoutUnit offsetLeft() const override;
    81     LayoutUnit offsetTop() const override;
    82     LayoutUnit offsetWidth() const override;
    83     LayoutUnit offsetHeight() const override;
     78    LayoutUnit offsetLeft() const final;
     79    LayoutUnit offsetTop() const final;
     80    LayoutUnit offsetWidth() const final;
     81    LayoutUnit offsetHeight() const final;
    8482#endif
    8583
    8684    void updatePlayer();
    8785
    88     bool foregroundIsKnownToBeOpaqueInRect(const LayoutRect& localRect, unsigned maxDepthToTest) const override;
     86    bool foregroundIsKnownToBeOpaqueInRect(const LayoutRect& localRect, unsigned maxDepthToTest) const final;
    8987
    9088    LayoutSize m_cachedImageSize;
    9189};
     90
     91inline RenderVideo* HTMLVideoElement::renderer() const
     92{
     93    return downcast<RenderVideo>(HTMLMediaElement::renderer());
     94}
    9295
    9396} // namespace WebCore
    … …  
    9699
    97100#endif // ENABLE(VIDEO)
    98 #endif // RenderVideo_h

  • trunk/Source/WebCore/svg/SVGGElement.cpp

    r200041 r201588  
    8686RenderPtr<RenderElement> SVGGElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    8787{
    88     // SVG 1.1 testsuite explicitely uses constructs like <g display="none"><linearGradient>
     88    // SVG 1.1 testsuite explicitly uses constructs like <g display="none"><linearGradient>
    8989    // We still have to create renderers for the <g> & <linearGradient> element, though the
    9090    // subtree may be hidden - we only want the resource renderers to exist so they can be

  • trunk/Source/WebCore/svg/SVGGraphicsElement.cpp

    r200098 r201588  
    164164RenderPtr<RenderElement> SVGGraphicsElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    165165{
    166     // By default, any subclass is expected to do path-based drawing
    167166    return createRenderer<RenderSVGPath>(*this, WTFMove(style));
    168167}

  • trunk/Source/WebCore/svg/SVGPathElement.cpp

    r201561 r201588  
    415415RenderPtr<RenderElement> SVGPathElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    416416{
    417     // By default, any subclass is expected to do path-based drawing
    418417    return createRenderer<RenderSVGPath>(*this, WTFMove(style));
    419418}

  • trunk/Source/WebKit/mac/ChangeLog

    r201542 r201588  
     12016-05-31  Darin Adler  <darin@apple.com>
     2
     3        Audit RenderObject casts and fix problems and style issues found
     4        https://bugs.webkit.org/show_bug.cgi?id=158221
     5
     6        Reviewed by Chris Dumez.
     7
     8        * Misc/WebNSPasteboardExtras.mm:
     9        (imageFromElement): Use auto and tighten the logic a bit.
     10        (-[NSPasteboard _web_declareAndWriteDragImageForElement:URL:title:archive:source:]):
     11        Use auto and added a comment about this not using imageFromElement.
     12
     13        * Plugins/WebBaseNetscapePluginView.mm:
     14        (-[WebBaseNetscapePluginView _windowClipRect]): Consistently cast to
     15        RenderEmbeddedObject, which is the class used for renderers for plug-ins.
     16        (-[WebBaseNetscapePluginView inFlatteningPaint]): Ditto.
     17        (-[WebBaseNetscapePluginView invalidatePluginContentRect:]): Ditto.
     18        (-[WebBaseNetscapePluginView actualVisibleRectInWindow]): Ditto.
     19
     20        * WebCoreSupport/WebFrameLoaderClient.mm:
     21        (WebFrameLoaderClient::createPlugin): Changed code so it does a null check
     22        rather than assuming the renderer is non-null.
     23        (WebFrameLoaderClient::createJavaAppletWidget): Ditto.
     24
    1252016-05-31  Yusuke Suzuki  <utatane.tea@gmail.com>
    226

  • trunk/Source/WebKit/mac/Misc/WebNSPasteboardExtras.mm

    r198289 r201588  
    220220static CachedImage* imageFromElement(DOMElement *domElement)
    221221{
    222     Element* element = core(domElement);
     222    auto* element = core(domElement);
    223223    if (!element)
    224224        return nullptr;
    225    
    226     ASSERT(element->renderer());
    227     auto& imageRenderer = downcast<RenderImage>(*element->renderer());
    228     if (!imageRenderer.cachedImage() || imageRenderer.cachedImage()->errorOccurred())
     225    auto* renderer = element->renderer();
     226    if (!is<RenderImage>(renderer))
    229227        return nullptr;
    230     return imageRenderer.cachedImage();
     228    auto* image = downcast<RenderImage>(*renderer).cachedImage();
     229    if (!image || image->errorOccurred())
     230        return nullptr;
     231    return image;
    231232}
    232233
    … …  
    276277    if (auto* renderer = core(element)->renderer()) {
    277278        if (is<RenderImage>(*renderer)) {
    278             if (CachedImage* image = downcast<RenderImage>(*renderer).cachedImage()) {
     279            if (auto* image = downcast<RenderImage>(*renderer).cachedImage()) {
     280                // FIXME: This doesn't check errorOccured the way imageFromElement does.
    279281                extension = image->image()->filenameExtension();
    280282                if (![extension length])

  • trunk/Source/WebKit/mac/Plugins/WebBaseNetscapePluginView.mm

    r193378 r201588  
    4141#import "WebView.h"
    4242#import "WebViewInternal.h"
    43 
    4443#import <WebCore/AuthenticationCF.h>
    4544#import <WebCore/AuthenticationMac.h>
    … …  
    5453#import <WebCore/Page.h>
    5554#import <WebCore/ProtectionSpace.h>
     55#import <WebCore/RenderEmbeddedObject.h>
    5656#import <WebCore/RenderView.h>
    57 #import <WebCore/RenderWidget.h>
    5857#import <WebCore/SecurityOrigin.h>
    5958#import <WebCore/WebCoreObjCExtras.h>
    … …  
    283282{
    284283    auto* renderer = _element->renderer();
    285     if (!renderer)
     284    if (!is<RenderEmbeddedObject>(renderer))
    286285        return NSZeroRect;
    287 
    288     return downcast<RenderWidget>(*renderer).windowClipRect();
     286    return downcast<RenderEmbeddedObject>(*renderer).windowClipRect();
    289287}
    290288
    … …  
    445443- (BOOL)inFlatteningPaint
    446444{
    447     RenderObject* renderer = _element->renderer();
    448     if (renderer)
    449         return renderer->view().frameView().paintBehavior() & PaintBehaviorFlattenCompositingLayers;
    450 
    451     return NO;
     445    auto* renderer = _element->renderer();
     446    if (!is<RenderEmbeddedObject>(renderer))
     447        return NO;
     448    return !!(downcast<RenderEmbeddedObject>(*renderer).view().frameView().paintBehavior() & PaintBehaviorFlattenCompositingLayers);
    452449}
    453450
    … …  
    856853- (void)invalidatePluginContentRect:(NSRect)rect
    857854{
    858     if (RenderBoxModelObject* renderer = downcast<RenderBoxModelObject>(_element->renderer())) {
    859         IntRect contentRect(rect);
    860         contentRect.move(renderer->borderLeft() + renderer->paddingLeft(), renderer->borderTop() + renderer->paddingTop());
    861        
    862         renderer->repaintRectangle(contentRect);
    863     }
     855    auto* renderer = _element->renderer();
     856    if (!is<RenderEmbeddedObject>(renderer))
     857        return;
     858    auto& object = downcast<RenderEmbeddedObject>(*renderer);
     859    IntRect contentRect(rect);
     860    contentRect.move(object.borderLeft() + object.paddingLeft(), object.borderTop() + object.paddingTop());
     861    object.repaintRectangle(contentRect);
    864862}
    865863
    … …  
    867865{
    868866    auto* renderer = _element->renderer();
    869     if (!renderer)
     867    if (!is<RenderEmbeddedObject>(renderer))
    870868        return NSZeroRect;
    871 
    872     IntRect widgetRect = renderer->pixelSnappedAbsoluteClippedOverflowRect();
    873     widgetRect = renderer->view().frameView().contentsToWindow(widgetRect);
    874     return intersection(downcast<RenderWidget>(*renderer).windowClipRect(), widgetRect);
     869    auto& object = downcast<RenderEmbeddedObject>(*renderer);
     870    auto widgetRect = object.view().frameView().contentsToWindow(object.pixelSnappedAbsoluteClippedOverflowRect());
     871    return intersection(object.windowClipRect(), widgetRect);
    875872}
    876873

  • trunk/Source/WebKit/mac/WebCoreSupport/WebFrameLoaderClient.mm

    r201038 r201588  
    20012001        if (WKShouldBlockPlugin([pluginPackage bundleIdentifier], [pluginPackage bundleVersion])) {
    20022002            errorCode = WebKitErrorBlockedPlugInVersion;
    2003             if (is<RenderEmbeddedObject>(*element->renderer()))
     2003            if (is<RenderEmbeddedObject>(element->renderer()))
    20042004                downcast<RenderEmbeddedObject>(*element->renderer()).setPluginUnavailabilityReason(RenderEmbeddedObject::InsecurePluginVersion);
    20052005        } else {
    … …  
    21062106        if (WKShouldBlockPlugin([pluginPackage bundleIdentifier], [pluginPackage bundleVersion])) {
    21072107            errorCode = WebKitErrorBlockedPlugInVersion;
    2108             if (is<RenderEmbeddedObject>(*element->renderer()))
     2108            if (is<RenderEmbeddedObject>(element->renderer()))
    21092109                downcast<RenderEmbeddedObject>(*element->renderer()).setPluginUnavailabilityReason(RenderEmbeddedObject::InsecurePluginVersion);
    21102110        } else {
    … …  
    21842184        CallFrameLoadDelegate(implementations->didCreateJavaScriptContextForFrameFunc, webView, @selector(webView:didCreateJavaScriptContext:forFrame:),
    21852185            script.javaScriptContext(), m_webFrame.get());
    2186     } else if (implementations->didClearWindowObjectForFrameFunc) {
    2187 #else
     2186    } else
     2187#endif
    21882188    if (implementations->didClearWindowObjectForFrameFunc) {
    2189 #endif
    21902189        CallFrameLoadDelegate(implementations->didClearWindowObjectForFrameFunc, webView, @selector(webView:didClearWindowObject:forFrame:),
    21912190            script.windowScriptObject(), m_webFrame.get());

  • trunk/Source/WebKit2/ChangeLog

    r201587 r201588  
     12016-05-31  Darin Adler  <darin@apple.com>
     2
     3        Audit RenderObject casts and fix problems and style issues found
     4        https://bugs.webkit.org/show_bug.cgi?id=158221
     5
     6        Reviewed by Chris Dumez.
     7
     8        * Shared/WebRenderObject.cpp:
     9        (WebKit::WebRenderObject::WebRenderObject): Tightened up the code that
     10        builds the tree of objects; fewer local variables.
     11
     12        * WebProcess/Plugins/PluginView.cpp:
     13        (WebKit::PluginView::invalidateRect): Cast to RenderEmbeddedObject since
     14        that is the class used for plug-ins.
     15        (WebKit::PluginView::pluginProcessCrashed): Ditto.
     16        * WebProcess/WebPage/WebPage.cpp:
     17        (WebKit::WebPage::createPlugin): Ditto.
     18        (WebKit::WebPage::plugInIsPrimarySize): Check the renderer for null here.
     19        Did not change this to RenderEmbeddedObject, though, because I wasn't
     20        absolute certain this is only called with that type of renderer.
     21
     22        * WebProcess/WebPage/ios/WebPageIOS.mm:
     23        (WebKit::WebPage::rangeForWebSelectionAtPosition): Tweaked.
     24
    1252016-06-01  Brady Eidson  <beidson@apple.com>
    226

  • trunk/Source/WebKit2/Shared/WebRenderObject.cpp

    r198771 r201588  
    114114    Vector<RefPtr<API::Object>> children;
    115115
    116     for (RenderObject* coreChild = renderer->firstChildSlow(); coreChild; coreChild = coreChild->nextSibling()) {
    117         RefPtr<WebRenderObject> child = adoptRef(new WebRenderObject(coreChild, shouldIncludeDescendants));
    118         children.append(WTFMove(child));
    119     }
     116    for (auto* coreChild = renderer->firstChildSlow(); coreChild; coreChild = coreChild->nextSibling())
     117        children.append(adoptRef(*new WebRenderObject(coreChild, shouldIncludeDescendants)));
    120118
    121119    if (is<RenderWidget>(*renderer)) {
    122         if (Widget* widget = downcast<RenderWidget>(*renderer).widget()) {
    123             if (is<FrameView>(*widget)) {
    124                 FrameView& frameView = downcast<FrameView>(*widget);
    125                 if (RenderView* coreContentRenderer = frameView.frame().contentRenderer()) {
    126                     RefPtr<WebRenderObject> contentRenderer = adoptRef(new WebRenderObject(coreContentRenderer, shouldIncludeDescendants));
    127 
    128                     children.append(WTFMove(contentRenderer));
    129                 }
    130             }
     120        auto* widget = downcast<RenderWidget>(*renderer).widget();
     121        if (is<FrameView>(widget)) {
     122            if (auto* coreContentRenderer = downcast<FrameView>(*widget).frame().contentRenderer())
     123                children.append(adoptRef(*new WebRenderObject(coreContentRenderer, shouldIncludeDescendants)));
    131124        }
    132125    }

  • trunk/Source/WebKit2/WebProcess/Plugins/PluginView.cpp

    r201575 r201588  
    13641364        return;
    13651365
    1366     RenderBoxModelObject* renderer = downcast<RenderBoxModelObject>(m_pluginElement->renderer());
    1367     if (!renderer)
    1368         return;
     1366    auto* renderer = m_pluginElement->renderer();
     1367    if (!is<RenderEmbeddedObject>(renderer))
     1368        return;
     1369    auto& object = downcast<RenderEmbeddedObject>(*renderer);
    13691370
    13701371    IntRect contentRect(dirtyRect);
    1371     contentRect.move(renderer->borderLeft() + renderer->paddingLeft(), renderer->borderTop() + renderer->paddingTop());
     1372    contentRect.move(object.borderLeft() + object.paddingLeft(), object.borderTop() + object.paddingTop());
    13721373    renderer->repaintRectangle(contentRect);
    13731374}
    … …  
    15651566    m_pluginProcessHasCrashed = true;
    15661567
    1567     if (!is<RenderEmbeddedObject>(m_pluginElement->renderer()))
     1568    auto* renderer = m_pluginElement->renderer();
     1569    if (!is<RenderEmbeddedObject>(renderer))
    15681570        return;
    15691571
    15701572    m_pluginElement->setNeedsStyleRecalc(SyntheticStyleChange);
    15711573
    1572     downcast<RenderEmbeddedObject>(*m_pluginElement->renderer()).setPluginUnavailabilityReason(RenderEmbeddedObject::PluginCrashed);
    1573    
     1574    downcast<RenderEmbeddedObject>(*renderer).setPluginUnavailabilityReason(RenderEmbeddedObject::PluginCrashed);
     1575
    15741576    Widget::invalidate();
    15751577}

  • trunk/Source/WebKit2/WebProcess/WebPage/WebPage.cpp

    r201519 r201588  
    763763    if (isBlockedPlugin) {
    764764        bool replacementObscured = false;
    765         if (is<RenderEmbeddedObject>(*pluginElement->renderer())) {
    766             auto& renderObject = downcast<RenderEmbeddedObject>(*pluginElement->renderer());
     765        auto* renderer = pluginElement->renderer();
     766        if (is<RenderEmbeddedObject>(renderer)) {
     767            auto& renderObject = downcast<RenderEmbeddedObject>(*renderer);
    767768            renderObject.setPluginUnavailabilityReasonWithDescription(RenderEmbeddedObject::InsecurePluginVersion, unavailabilityDescription);
    768769            replacementObscured = renderObject.isReplacementObscured();
    … …  
    51295130bool WebPage::plugInIsPrimarySize(WebCore::HTMLPlugInImageElement& plugInImageElement, unsigned& candidatePlugInArea)
    51305131{
    5131     auto& pluginRenderBox = downcast<RenderBox>(*plugInImageElement.renderer());
    5132     if (pluginRenderBox.contentWidth() < primarySnapshottedPlugInMinimumWidth || pluginRenderBox.contentHeight() < primarySnapshottedPlugInMinimumHeight)
     5132    auto* renderer = plugInImageElement.renderer();
     5133    if (!is<RenderBox>(renderer))
    51335134        return false;
    51345135
    5135     LayoutUnit contentArea = pluginRenderBox.contentWidth() * pluginRenderBox.contentHeight();
     5136    auto& box = downcast<RenderBox>(*renderer);
     5137    if (box.contentWidth() < primarySnapshottedPlugInMinimumWidth || box.contentHeight() < primarySnapshottedPlugInMinimumHeight)
     5138        return false;
     5139
     5140    LayoutUnit contentArea = box.contentWidth() * box.contentHeight();
    51365141    if (contentArea > candidatePlugInArea * primarySnapshottedPlugInSearchBucketSize) {
    51375142        candidatePlugInArea = contentArea.toUnsigned();
    51385143        return true;
    51395144    }
     5145
    51405146    return false;
    51415147}
     5148
    51425149#endif // ENABLE(PRIMARY_SNAPSHOTTED_PLUGIN_HEURISTIC)
    51435150

  • trunk/Source/WebKit2/WebProcess/WebPage/ios/WebPageIOS.mm

    r201583 r201588  
    915915        auto* renderer = currentNode->renderer();
    916916        if (is<RenderBlockFlow>(renderer)) {
    917             auto *renderText = downcast<RenderBlockFlow>(renderer)->findClosestTextAtAbsolutePoint(point);
     917            auto* renderText = downcast<RenderBlockFlow>(*renderer).findClosestTextAtAbsolutePoint(point);
    918918            if (renderText && renderText->textNode())
    919919                currentNode = renderText->textNode();
Note: See TracChangeset for help on using the changeset viewer.