+2013-12-31 Andreas Kling <akling@apple.com>
+
+ Element's renderer factory should return RenderPtrs.
+ <https://webkit.org/b/126318>
+
+ Rename Element::createRenderer() to createElementRenderer() and have
+ it return RenderPtr<RenderElement>. Propagate signature until it
+ builds again.
+
+ We leakPtr() the renderer at two call sites when handing things over
+ to raw pointer API. This'll get tidied up in subsequent patches.
+
+ Reviewed by Sam Weinig.
+
2013-12-31 Carlos Garcia Campos <cgarcia@igalia.com>
[SOUP] Return early in ResourceHandle::receivedCancellation if the load has already cancelled
#ifndef PluginReplacement_h
#define PluginReplacement_h
+#include "RenderPtr.h"
#include <wtf/RefCounted.h>
#include <wtf/text/WTFString.h>
virtual JSC::JSObject* scriptObject() { return 0; }
virtual bool willCreateRenderer() { return false; }
- virtual RenderElement* createRenderer(HTMLPlugInElement&, PassRef<RenderStyle>) = 0;
+ virtual RenderPtr<RenderElement> createElementRenderer(HTMLPlugInElement&, PassRef<RenderStyle>) = 0;
protected:
PluginReplacement() { }
m_mediaElement = nullptr;
}
-RenderElement* QuickTimePluginReplacement::createRenderer(HTMLPlugInElement& plugin, PassRef<RenderStyle> style)
+RenderPtr<RenderElement> QuickTimePluginReplacement::createElementRenderer(HTMLPlugInElement& plugin, PassRef<RenderStyle> style)
{
ASSERT_UNUSED(plugin, m_parentElement == &plugin);
if (m_mediaElement)
- return m_mediaElement->createRenderer(std::move(style));
+ return m_mediaElement->createElementRenderer(std::move(style));
- return 0;
+ return nullptr;
}
DOMWrapperWorld& QuickTimePluginReplacement::isolatedWorld()
virtual JSC::JSObject* scriptObject() OVERRIDE { return m_scriptObject; }
virtual bool willCreateRenderer() OVERRIDE { return m_mediaElement; }
- virtual RenderElement* createRenderer(HTMLPlugInElement&, PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(HTMLPlugInElement&, PassRef<RenderStyle>) OVERRIDE;
unsigned long long movieSize() const;
void postEvent(const String&);
return style.display() != NONE;
}
-RenderElement* Element::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> Element::createElementRenderer(PassRef<RenderStyle> style)
{
return RenderElement::createFor(*this, std::move(style));
}
void lazyReattach();
- virtual RenderElement* createRenderer(PassRef<RenderStyle>);
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>);
virtual bool rendererIsNeeded(const RenderStyle&);
void didAffectSelector(AffectedSelectorMask);
return HTMLPlugInImageElement::rendererIsNeeded(style);
}
-RenderElement* HTMLAppletElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> HTMLAppletElement::createElementRenderer(PassRef<RenderStyle> style)
{
if (!canEmbedJava())
return RenderElement::createFor(*this, std::move(style));
virtual void parseAttribute(const QualifiedName&, const AtomicString&) OVERRIDE;
virtual bool rendererIsNeeded(const RenderStyle&) OVERRIDE;
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual RenderWidget* renderWidgetForJSBindings() const;
virtual void updateWidget(PluginCreationOption) OVERRIDE;
HTMLElement::collectStyleForPresentationAttribute(name, value, style);
}
-RenderElement* HTMLBRElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> HTMLBRElement::createElementRenderer(PassRef<RenderStyle> style)
{
if (style.get().hasContent())
return RenderElement::createFor(*this, std::move(style));
- return new RenderLineBreak(*this, std::move(style));
+ return createRenderer<RenderLineBreak>(*this, std::move(style));
}
}
virtual bool isPresentationAttribute(const QualifiedName&) const OVERRIDE;
virtual void collectStyleForPresentationAttribute(const QualifiedName&, const AtomicString&, MutableStyleProperties&) OVERRIDE;
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
};
} // namespace
setAttribute(typeAttr, type);
}
-RenderElement* HTMLButtonElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> HTMLButtonElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderButton(*this, std::move(style));
+ return createRenderer<RenderButton>(*this, std::move(style));
}
const AtomicString& HTMLButtonElement::formControlType() const
virtual const AtomicString& formControlType() const;
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
// HTMLFormControlElement always creates one, but buttons don't need it.
virtual bool alwaysCreateUserAgentShadowRoot() const OVERRIDE { return false; }
HTMLElement::parseAttribute(name, value);
}
-RenderElement* HTMLCanvasElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> HTMLCanvasElement::createElementRenderer(PassRef<RenderStyle> style)
{
Frame* frame = document().frame();
if (frame && frame->script().canExecuteScripts(NotAboutToExecuteScript)) {
m_rendererIsCanvas = true;
- return new RenderHTMLCanvas(*this, std::move(style));
+ return createRenderer<RenderHTMLCanvas>(*this, std::move(style));
}
m_rendererIsCanvas = false;
- return HTMLElement::createRenderer(std::move(style));
+ return HTMLElement::createElementRenderer(std::move(style));
}
void HTMLCanvasElement::willAttachRenderers()
HTMLCanvasElement(const QualifiedName&, Document&);
virtual void parseAttribute(const QualifiedName&, const AtomicString&) OVERRIDE;
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual void willAttachRenderers() OVERRIDE;
virtual bool areAuthorShadowsAllowed() const OVERRIDE;
ASSERT(hasTagName(detailsTag));
}
-RenderElement* HTMLDetailsElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> HTMLDetailsElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderBlockFlow(*this, std::move(style));
+ return createRenderer<RenderBlockFlow>(*this, std::move(style));
}
void HTMLDetailsElement::didAddUserAgentShadowRoot(ShadowRoot* root)
private:
HTMLDetailsElement(const QualifiedName&, Document&);
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual bool childShouldCreateRenderer(const Node&) const OVERRIDE;
virtual void parseAttribute(const QualifiedName&, const AtomicString&) OVERRIDE;
return StyledElement::rendererIsNeeded(style);
}
-RenderElement* HTMLElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> HTMLElement::createElementRenderer(PassRef<RenderStyle> style)
{
if (hasLocalName(wbrTag))
- return new RenderLineBreak(*this, std::move(style));
+ return createRenderer<RenderLineBreak>(*this, std::move(style));
return RenderElement::createFor(*this, std::move(style));
}
bool ieForbidsInsertHTML() const;
virtual bool rendererIsNeeded(const RenderStyle&) OVERRIDE;
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
HTMLFormElement* form() const { return virtualForm(); }
return fieldset;
}
-RenderElement* HTMLFieldSetElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> HTMLFieldSetElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderFieldset(*this, std::move(style));
+ return createRenderer<RenderFieldset>(*this, std::move(style));
}
HTMLLegendElement* HTMLFieldSetElement::legend() const
virtual bool isEnumeratable() const OVERRIDE { return true; }
virtual bool supportsFocus() const OVERRIDE;
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual const AtomicString& formControlType() const OVERRIDE;
virtual bool recalcWillValidate() const OVERRIDE { return false; }
virtual void childrenChanged(const ChildChange&) OVERRIDE;
return isURLAllowed();
}
-RenderElement* HTMLFrameElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> HTMLFrameElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderFrame(*this, std::move(style));
+ return createRenderer<RenderFrame>(*this, std::move(style));
}
bool HTMLFrameElement::noResize() const
virtual void didAttachRenderers() OVERRIDE;
virtual bool rendererIsNeeded(const RenderStyle&);
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual void parseAttribute(const QualifiedName&, const AtomicString&) OVERRIDE;
return style.isStyleAvailable();
}
-RenderElement* HTMLFrameSetElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> HTMLFrameSetElement::createElementRenderer(PassRef<RenderStyle> style)
{
if (style.get().hasContent())
return RenderElement::createFor(*this, std::move(style));
- return new RenderFrameSet(*this, std::move(style));
+ return createRenderer<RenderFrameSet>(*this, std::move(style));
}
HTMLFrameSetElement* HTMLFrameSetElement::findContaining(Element* descendant)
virtual void willAttachRenderers() OVERRIDE;
virtual bool rendererIsNeeded(const RenderStyle&);
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual void defaultEventHandler(Event*);
return isURLAllowed() && style.display() != NONE;
}
-RenderElement* HTMLIFrameElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> HTMLIFrameElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderIFrame(*this, std::move(style));
+ return createRenderer<RenderIFrame>(*this, std::move(style));
}
bool HTMLIFrameElement::shouldDisplaySeamlessly() const
virtual void collectStyleForPresentationAttribute(const QualifiedName&, const AtomicString&, MutableStyleProperties&) OVERRIDE;
virtual bool rendererIsNeeded(const RenderStyle&);
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual void didRecalcStyle(Style::Change) OVERRIDE;
};
return alt;
}
-RenderElement* HTMLImageElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> HTMLImageElement::createElementRenderer(PassRef<RenderStyle> style)
{
if (style.get().hasContent())
return RenderElement::createFor(*this, std::move(style));
- RenderImage* image = new RenderImage(*this, std::move(style));
+ auto image = createRenderer<RenderImage>(*this, std::move(style));
image->setImageResource(RenderImageResource::create());
- return image;
+ return std::move(image);
}
bool HTMLImageElement::canStartSelection() const
virtual void collectStyleForPresentationAttribute(const QualifiedName&, const AtomicString&, MutableStyleProperties&) OVERRIDE;
virtual void didAttachRenderers() OVERRIDE;
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual bool canStartSelection() const OVERRIDE;
return m_inputType->rendererIsNeeded() && HTMLTextFormControlElement::rendererIsNeeded(style);
}
-RenderElement* HTMLInputElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> HTMLInputElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return m_inputType->createInputRenderer(std::move(style)).leakPtr();
+ return m_inputType->createInputRenderer(std::move(style));
}
void HTMLInputElement::willAttachRenderers()
bool canHaveSelection() const;
virtual bool rendererIsNeeded(const RenderStyle&) OVERRIDE;
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual void willAttachRenderers() OVERRIDE;
virtual void didAttachRenderers() OVERRIDE;
virtual void didDetachRenderers() OVERRIDE;
return controls() && HTMLElement::rendererIsNeeded(style);
}
-RenderElement* HTMLMediaElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> HTMLMediaElement::createElementRenderer(PassRef<RenderStyle> style)
{
#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
if (shouldUseVideoPluginProxy()) {
// Setup the renderer if we already have a proxy widget.
- RenderEmbeddedObject* mediaRenderer = new RenderEmbeddedObject(*this, std::move(style));
+ auto mediaRenderer = createRenderer<RenderEmbeddedObject>(*this, std::move(style));
if (m_proxyWidget) {
mediaRenderer->setWidget(m_proxyWidget);
if (Frame* frame = document().frame())
frame->loader().client().showMediaPlayerProxyPlugin(m_proxyWidget.get());
}
- return mediaRenderer;
+ return std::move(mediaRenderer);
}
#endif
- return new RenderMedia(*this, std::move(style));
+ return createRenderer<RenderMedia>(*this, std::move(style));
}
bool HTMLMediaElement::childShouldCreateRenderer(const Node& child) const
void endIgnoringTrackDisplayUpdateRequests();
#endif
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
private:
void createMediaPlayer();
return meter;
}
-RenderElement* HTMLMeterElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> HTMLMeterElement::createElementRenderer(PassRef<RenderStyle> style)
{
if (hasAuthorShadowRoot() || !document().page()->theme().supportsMeter(style.get().appearance()))
return RenderElement::createFor(*this, std::move(style));
- return new RenderMeter(*this, std::move(style));
+ return createRenderer<RenderMeter>(*this, std::move(style));
}
bool HTMLMeterElement::childShouldCreateRenderer(const Node& child) const
virtual bool supportLabels() const OVERRIDE { return true; }
virtual bool recalcWillValidate() const { return false; }
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual bool childShouldCreateRenderer(const Node&) const OVERRIDE;
virtual void parseAttribute(const QualifiedName&, const AtomicString&) OVERRIDE;
#endif /* ENABLE(NETSCAPE_PLUGIN_API) */
-RenderElement* HTMLPlugInElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> HTMLPlugInElement::createElementRenderer(PassRef<RenderStyle> style)
{
if (m_pluginReplacement && m_pluginReplacement->willCreateRenderer())
- return m_pluginReplacement->createRenderer(*this, std::move(style));
+ return m_pluginReplacement->createElementRenderer(*this, std::move(style));
- return new RenderEmbeddedObject(*this, std::move(style));
+ return createRenderer<RenderEmbeddedObject>(*this, std::move(style));
}
void HTMLPlugInElement::swapRendererTimerFired(Timer<HTMLPlugInElement>*)
virtual void defaultEventHandler(Event*) OVERRIDE;
virtual bool requestObject(const String& url, const String& mimeType, const Vector<String>& paramNames, const Vector<String>& paramValues);
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual void didAddUserAgentShadowRoot(ShadowRoot*) OVERRIDE;
// Subclasses should use guardedDispatchBeforeLoadEvent instead of calling dispatchBeforeLoadEvent directly.
return false;
}
-RenderElement* HTMLPlugInImageElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> HTMLPlugInImageElement::createElementRenderer(PassRef<RenderStyle> style)
{
if (displayState() >= PreparingPluginReplacement)
- return HTMLPlugInElement::createRenderer(std::move(style));
+ return HTMLPlugInElement::createElementRenderer(std::move(style));
// Once a PlugIn Element creates its renderer, it needs to be told when the Document goes
// inactive or reactivates so it can clear the renderer before going into the page cache.
}
if (displayState() == DisplayingSnapshot) {
- RenderSnapshottedPlugIn* renderSnapshottedPlugIn = new RenderSnapshottedPlugIn(*this, std::move(style));
+ auto renderSnapshottedPlugIn = createRenderer<RenderSnapshottedPlugIn>(*this, std::move(style));
renderSnapshottedPlugIn->updateSnapshot(m_snapshotImage);
- return renderSnapshottedPlugIn;
+ return std::move(renderSnapshottedPlugIn);
}
// Fallback content breaks the DOM->Renderer class relationship of this
return RenderElement::createFor(*this, std::move(style));
if (isImageType()) {
- RenderImage* image = new RenderImage(*this, std::move(style));
+ auto image = createRenderer<RenderImage>(*this, std::move(style));
image->setImageResource(RenderImageResource::create());
- return image;
+ return std::move(image);
}
#if PLATFORM(IOS)
if (ShadowRoot* shadowRoot = this->shadowRoot()) {
Element* shadowElement = toElement(shadowRoot->firstChild());
if (shadowElement && shadowElement->shadowPseudoId() == "-apple-youtube-shadow-iframe")
- return new RenderBlockFlow(*this, std::move(style));
+ return createRenderer<RenderBlockFlow>(*this, std::move(style));
}
#endif
- return HTMLPlugInElement::createRenderer(std::move(style));
+ return HTMLPlugInElement::createElementRenderer(std::move(style));
}
bool HTMLPlugInImageElement::willRecalcStyle(Style::Change)
virtual bool requestObject(const String& url, const String& mimeType, const Vector<String>& paramNames, const Vector<String>& paramValues) OVERRIDE;
private:
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual bool willRecalcStyle(Style::Change) OVERRIDE;
virtual void didAddUserAgentShadowRoot(ShadowRoot*) OVERRIDE;
return progress.release();
}
-RenderElement* HTMLProgressElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> HTMLProgressElement::createElementRenderer(PassRef<RenderStyle> style)
{
if (!style.get().hasAppearance() || hasAuthorShadowRoot())
return RenderElement::createFor(*this, std::move(style));
- return new RenderProgress(*this, std::move(style));
+ return createRenderer<RenderProgress>(*this, std::move(style));
}
bool HTMLProgressElement::childShouldCreateRenderer(const Node& child) const
virtual bool shouldAppearIndeterminate() const OVERRIDE;
virtual bool supportLabels() const OVERRIDE { return true; }
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual bool childShouldCreateRenderer(const Node&) const OVERRIDE;
RenderProgress* renderProgress() const;
return !usesMenuList();
}
-RenderElement* HTMLSelectElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> HTMLSelectElement::createElementRenderer(PassRef<RenderStyle> style)
{
#if !PLATFORM(IOS)
if (usesMenuList())
- return new RenderMenuList(*this, std::move(style));
- return new RenderListBox(*this, std::move(style));
+ return createRenderer<RenderMenuList>(*this, std::move(style));
+ return createRenderer<RenderListBox>(*this, std::move(style));
#else
- return new RenderMenuList(*this, std::move(style));
+ return createRenderer<RenderMenuList>(*this, std::move(style));
#endif
}
virtual bool isPresentationAttribute(const QualifiedName&) const OVERRIDE;
virtual bool childShouldCreateRenderer(const Node&) const OVERRIDE;
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual bool appendFormData(FormDataList&, bool) OVERRIDE;
virtual void reset() OVERRIDE;
ASSERT(hasTagName(summaryTag));
}
-RenderElement* HTMLSummaryElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> HTMLSummaryElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderBlockFlow(*this, std::move(style));
+ return createRenderer<RenderBlockFlow>(*this, std::move(style));
}
bool HTMLSummaryElement::childShouldCreateRenderer(const Node& child) const
private:
HTMLSummaryElement(const QualifiedName&, Document&);
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual bool childShouldCreateRenderer(const Node&) const OVERRIDE;
virtual void defaultEventHandler(Event*);
HTMLTextFormControlElement::parseAttribute(name, value);
}
-RenderElement* HTMLTextAreaElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> HTMLTextAreaElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderTextControlMultiLine(*this, std::move(style));
+ return createRenderer<RenderTextControlMultiLine>(*this, std::move(style));
}
bool HTMLTextAreaElement::appendFormData(FormDataList& encoding, bool)
virtual void parseAttribute(const QualifiedName&, const AtomicString&) OVERRIDE;
virtual bool isPresentationAttribute(const QualifiedName&) const OVERRIDE;
virtual void collectStyleForPresentationAttribute(const QualifiedName&, const AtomicString&, MutableStyleProperties&) OVERRIDE;
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual bool appendFormData(FormDataList&, bool) OVERRIDE;
virtual void reset() OVERRIDE;
virtual bool hasCustomFocusLogic() const OVERRIDE;
return HTMLElement::rendererIsNeeded(style);
}
-RenderElement* HTMLVideoElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> HTMLVideoElement::createElementRenderer(PassRef<RenderStyle> style)
{
#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
if (shouldUseVideoPluginProxy())
- return HTMLMediaElement::createRenderer(std::move(style));
+ return HTMLMediaElement::createElementRenderer(std::move(style));
#endif
- return new RenderVideo(*this, std::move(style));
+ return createRenderer<RenderVideo>(*this, std::move(style));
}
void HTMLVideoElement::didAttachRenderers()
bool shouldDisplayPosterImage() const { return displayMode() == Poster || displayMode() == PosterWaitingForVideo; }
URL posterImageURL() const;
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
private:
HTMLVideoElement(const QualifiedName&, Document&, bool);
{
}
-RenderElement* DetailsMarkerControl::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> DetailsMarkerControl::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderDetailsMarker(*this, std::move(style));
+ return createRenderer<RenderDetailsMarker>(*this, std::move(style));
}
bool DetailsMarkerControl::rendererIsNeeded(const RenderStyle& style)
private:
DetailsMarkerControl(Document&);
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual bool rendererIsNeeded(const RenderStyle&);
virtual const AtomicString& shadowPseudoId() const;
}
}
-RenderElement* MediaControlTimelineContainerElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> MediaControlTimelineContainerElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderMediaControlTimelineContainer(*this, std::move(style));
+ return createRenderer<RenderMediaControlTimelineContainer>(*this, std::move(style));
}
// ----------------------------
return element.release();
}
-RenderElement* MediaControlVolumeSliderContainerElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> MediaControlVolumeSliderContainerElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderMediaVolumeSliderContainer(*this, std::move(style));
+ return createRenderer<RenderMediaVolumeSliderContainer>(*this, std::move(style));
}
void MediaControlVolumeSliderContainerElement::defaultEventHandler(Event* event)
return element.release();
}
-RenderElement* MediaControlTextTrackContainerElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> MediaControlTextTrackContainerElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderTextTrackContainerElement(*this, std::move(style));
+ return createRenderer<RenderTextTrackContainerElement>(*this, std::move(style));
}
const AtomicString& MediaControlTextTrackContainerElement::textTrackContainerElementShadowPseudoId()
explicit MediaControlTimelineContainerElement(Document&);
virtual const AtomicString& shadowPseudoId() const OVERRIDE;
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
};
// ----------------------------
virtual const AtomicString& shadowPseudoId() const OVERRIDE;
virtual void defaultEventHandler(Event*) OVERRIDE;
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
};
// ----------------------------
explicit MediaControlTextTrackContainerElement(Document&);
virtual const AtomicString& shadowPseudoId() const OVERRIDE;
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual PassRefPtr<Image> createTextTrackRepresentationImage() OVERRIDE;
virtual void textTrackRepresentationBoundsChanged(const IntRect&) OVERRIDE;
return render && !render->theme().supportsMeter(render->style().appearance()) && HTMLDivElement::rendererIsNeeded(style);
}
-RenderElement* MeterInnerElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> MeterInnerElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderMeter(*this, std::move(style));
+ return createRenderer<RenderMeter>(*this, std::move(style));
}
const AtomicString& MeterValueElement::valuePseudoId() const
MeterInnerElement(Document&);
virtual bool rendererIsNeeded(const RenderStyle&) OVERRIDE;
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
};
inline PassRefPtr<MeterInnerElement> MeterInnerElement::create(Document& document)
{
}
-RenderElement* ProgressInnerElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> ProgressInnerElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderProgress(*this, std::move(style));
+ return createRenderer<RenderProgress>(*this, std::move(style));
}
bool ProgressInnerElement::rendererIsNeeded(const RenderStyle& style)
private:
ProgressInnerElement(Document&);
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual bool rendererIsNeeded(const RenderStyle&);
};
renderer()->setNeedsLayout();
}
-RenderElement* SliderThumbElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> SliderThumbElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderSliderThumb(*this, std::move(style));
+ return createRenderer<RenderSliderThumb>(*this, std::move(style));
}
bool SliderThumbElement::isDisabledFormControl() const
return adoptRef(new SliderContainerElement(document));
}
-RenderElement* SliderContainerElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> SliderContainerElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderSliderContainer(*this, std::move(style));
+ return createRenderer<RenderSliderContainer>(*this, std::move(style));
}
const AtomicString& SliderContainerElement::shadowPseudoId() const
private:
SliderThumbElement(Document&);
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual PassRefPtr<Element> cloneElementWithoutAttributesAndChildren() OVERRIDE;
virtual bool isDisabledFormControl() const OVERRIDE;
virtual bool matchesReadOnlyPseudoClass() const OVERRIDE;
private:
SliderContainerElement(Document&);
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual const AtomicString& shadowPseudoId() const;
};
return adoptRef(new TextControlInnerContainer(document));
}
-RenderElement* TextControlInnerContainer::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> TextControlInnerContainer::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderTextControlInnerContainer(*this, std::move(style));
+ return createRenderer<RenderTextControlInnerContainer>(*this, std::move(style));
}
TextControlInnerElement::TextControlInnerElement(Document& document)
HTMLDivElement::defaultEventHandler(event);
}
-RenderElement* TextControlInnerTextElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> TextControlInnerTextElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderTextControlInnerBlock(*this, std::move(style));
+ return createRenderer<RenderTextControlInnerBlock>(*this, std::move(style));
}
RenderTextControlInnerBlock* TextControlInnerTextElement::renderer() const
static PassRefPtr<TextControlInnerContainer> create(Document&);
protected:
TextControlInnerContainer(Document&);
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
};
class TextControlInnerElement FINAL : public HTMLDivElement {
private:
TextControlInnerTextElement(Document&);
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual PassRefPtr<RenderStyle> customStyleForRenderer() OVERRIDE;
virtual bool isMouseFocusable() const OVERRIDE { return false; }
virtual bool isTextControlInnerTextElement() const OVERRIDE { return true; }
return trackDisplayBoxShadowPseudoId;
}
-RenderElement* TextTrackCueBox::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> TextTrackCueBox::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderTextTrackCue(*this, std::move(style));
+ return createRenderer<RenderTextTrackCue>(*this, std::move(style));
}
// ----------------------------
protected:
TextTrackCueBox(Document&, TextTrackCue*);
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
TextTrackCue* m_cue;
};
return adoptRef(new MathMLInlineContainerElement(tagName, document));
}
-RenderElement* MathMLInlineContainerElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> MathMLInlineContainerElement::createElementRenderer(PassRef<RenderStyle> style)
{
if (hasLocalName(annotation_xmlTag))
- return new RenderMathMLRow(*this, std::move(style));
+ return createRenderer<RenderMathMLRow>(*this, std::move(style));
if (hasLocalName(merrorTag) || hasLocalName(mphantomTag) || hasLocalName(mrowTag) || hasLocalName(mstyleTag))
- return new RenderMathMLRow(*this, std::move(style));
+ return createRenderer<RenderMathMLRow>(*this, std::move(style));
if (hasLocalName(msubTag))
- return new RenderMathMLScripts(*this, std::move(style));
+ return createRenderer<RenderMathMLScripts>(*this, std::move(style));
if (hasLocalName(msupTag))
- return new RenderMathMLScripts(*this, std::move(style));
+ return createRenderer<RenderMathMLScripts>(*this, std::move(style));
if (hasLocalName(msubsupTag))
- return new RenderMathMLScripts(*this, std::move(style));
+ return createRenderer<RenderMathMLScripts>(*this, std::move(style));
if (hasLocalName(mmultiscriptsTag))
- return new RenderMathMLScripts(*this, std::move(style));
+ return createRenderer<RenderMathMLScripts>(*this, std::move(style));
if (hasLocalName(moverTag))
- return new RenderMathMLUnderOver(*this, std::move(style));
+ return createRenderer<RenderMathMLUnderOver>(*this, std::move(style));
if (hasLocalName(munderTag))
- return new RenderMathMLUnderOver(*this, std::move(style));
+ return createRenderer<RenderMathMLUnderOver>(*this, std::move(style));
if (hasLocalName(munderoverTag))
- return new RenderMathMLUnderOver(*this, std::move(style));
+ return createRenderer<RenderMathMLUnderOver>(*this, std::move(style));
if (hasLocalName(mfracTag))
- return new RenderMathMLFraction(*this, std::move(style));
+ return createRenderer<RenderMathMLFraction>(*this, std::move(style));
if (hasLocalName(msqrtTag))
- return new RenderMathMLSquareRoot(*this, std::move(style));
+ return createRenderer<RenderMathMLSquareRoot>(*this, std::move(style));
if (hasLocalName(mrootTag))
- return new RenderMathMLRoot(*this, std::move(style));
+ return createRenderer<RenderMathMLRoot>(*this, std::move(style));
if (hasLocalName(mfencedTag))
- return new RenderMathMLFenced(*this, std::move(style));
+ return createRenderer<RenderMathMLFenced>(*this, std::move(style));
if (hasLocalName(mtableTag))
- return new RenderMathMLTable(*this, std::move(style));
+ return createRenderer<RenderMathMLTable>(*this, std::move(style));
- return new RenderMathMLBlock(*this, std::move(style));
+ return createRenderer<RenderMathMLBlock>(*this, std::move(style));
}
}
MathMLInlineContainerElement(const QualifiedName& tagName, Document&);
private:
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
};
}
return MathMLInlineContainerElement::insertedInto(insertionPoint);
}
-RenderElement* MathMLMathElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> MathMLMathElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderMathMLMath(*this, std::move(style));
+ return createRenderer<RenderMathMLMath>(*this, std::move(style));
}
}
MathMLMathElement(const QualifiedName& tagName, Document&);
virtual InsertionNotificationRequest insertedInto(ContainerNode&) OVERRIDE;
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
};
}
return adoptRef(new MathMLSelectElement(tagName, document));
}
-RenderElement* MathMLSelectElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> MathMLSelectElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderMathMLRow(*this, std::move(style));
+ return createRenderer<RenderMathMLRow>(*this, std::move(style));
}
bool MathMLSelectElement::childShouldCreateRenderer(const Node& child) const
private:
MathMLSelectElement(const QualifiedName& tagName, Document&);
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual bool childShouldCreateRenderer(const Node&) const OVERRIDE;
renderer()->updateFromElement();
}
-RenderElement* MathMLTextElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> MathMLTextElement::createElementRenderer(PassRef<RenderStyle> style)
{
if (hasLocalName(MathMLNames::moTag))
- return new RenderMathMLOperator(*this, std::move(style));
+ return createRenderer<RenderMathMLOperator>(*this, std::move(style));
if (hasLocalName(MathMLNames::mspaceTag))
- return new RenderMathMLSpace(*this, std::move(style));
+ return createRenderer<RenderMathMLSpace>(*this, std::move(style));
- return MathMLElement::createRenderer(std::move(style));
+ return MathMLElement::createElementRenderer(std::move(style));
}
bool MathMLTextElement::childShouldCreateRenderer(const Node& child) const
private:
MathMLTextElement(const QualifiedName& tagName, Document&);
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual bool childShouldCreateRenderer(const Node&) const OVERRIDE;
virtual void childrenChanged(const ChildChange&) OVERRIDE;
cloneBlock = createAnonymousBlock();
cloneBlock->setChildrenInline(childrenInline());
} else {
- auto cloneRenderer = element()->createRenderer(style());
- cloneBlock = toRenderBlock(cloneRenderer);
+ auto cloneRenderer = element()->createElementRenderer(style());
+ cloneBlock = toRenderBlock(cloneRenderer.leakPtr());
cloneBlock->initializeStyle();
// This takes care of setting the right value of childrenInline in case
}
}
-RenderElement* RenderElement::createFor(Element& element, PassRef<RenderStyle> style)
+RenderPtr<RenderElement> RenderElement::createFor(Element& element, PassRef<RenderStyle> style)
{
Document& document = element.document();
// Otherwise acts as if we didn't support this feature.
const ContentData* contentData = style.get().contentData();
if (contentData && !contentData->next() && contentData->isImage() && !element.isPseudoElement()) {
- RenderImage* image = new RenderImage(element, std::move(style));
+ auto image = createRenderer<RenderImage>(element, std::move(style));
if (const StyleImage* styleImage = static_cast<const ImageContentData*>(contentData)->image()) {
image->setImageResource(RenderImageResourceStyleImage::create(const_cast<StyleImage&>(*styleImage)));
image->setIsGeneratedContent();
} else
image->setImageResource(RenderImageResource::create());
- return image;
+ return std::move(image);
}
if (element.hasTagName(HTMLNames::rubyTag)) {
if (style.get().display() == INLINE)
- return new RenderRubyAsInline(element, std::move(style));
+ return createRenderer<RenderRubyAsInline>(element, std::move(style));
if (style.get().display() == BLOCK)
- return new RenderRubyAsBlock(element, std::move(style));
+ return createRenderer<RenderRubyAsBlock>(element, std::move(style));
}
// treat <rt> as ruby text ONLY if it still has its default treatment of block
if (element.hasTagName(HTMLNames::rtTag) && style.get().display() == BLOCK)
- return new RenderRubyText(element, std::move(style));
+ return createRenderer<RenderRubyText>(element, std::move(style));
switch (style.get().display()) {
case NONE:
style.dropRef();
return nullptr;
case INLINE:
- return new RenderInline(element, std::move(style));
+ return createRenderer<RenderInline>(element, std::move(style));
case BLOCK:
case INLINE_BLOCK:
case RUN_IN:
case COMPACT:
if ((!style.get().hasAutoColumnCount() || !style.get().hasAutoColumnWidth()) && document.regionBasedColumnsEnabled())
- return new RenderMultiColumnBlock(element, std::move(style));
- return new RenderBlockFlow(element, std::move(style));
+ return createRenderer<RenderMultiColumnBlock>(element, std::move(style));
+ return createRenderer<RenderBlockFlow>(element, std::move(style));
case LIST_ITEM:
- return new RenderListItem(element, std::move(style));
+ return createRenderer<RenderListItem>(element, std::move(style));
case TABLE:
case INLINE_TABLE:
- return new RenderTable(element, std::move(style));
+ return createRenderer<RenderTable>(element, std::move(style));
case TABLE_ROW_GROUP:
case TABLE_HEADER_GROUP:
case TABLE_FOOTER_GROUP:
- return new RenderTableSection(element, std::move(style));
+ return createRenderer<RenderTableSection>(element, std::move(style));
case TABLE_ROW:
- return new RenderTableRow(element, std::move(style));
+ return createRenderer<RenderTableRow>(element, std::move(style));
case TABLE_COLUMN_GROUP:
case TABLE_COLUMN:
- return new RenderTableCol(element, std::move(style));
+ return createRenderer<RenderTableCol>(element, std::move(style));
case TABLE_CELL:
- return new RenderTableCell(element, std::move(style));
+ return createRenderer<RenderTableCell>(element, std::move(style));
case TABLE_CAPTION:
- return new RenderTableCaption(element, std::move(style));
+ return createRenderer<RenderTableCaption>(element, std::move(style));
case BOX:
case INLINE_BOX:
- return new RenderDeprecatedFlexibleBox(element, std::move(style));
+ return createRenderer<RenderDeprecatedFlexibleBox>(element, std::move(style));
case FLEX:
case INLINE_FLEX:
- return new RenderFlexibleBox(element, std::move(style));
+ return createRenderer<RenderFlexibleBox>(element, std::move(style));
case GRID:
case INLINE_GRID:
- return new RenderGrid(element, std::move(style));
+ return createRenderer<RenderGrid>(element, std::move(style));
}
ASSERT_NOT_REACHED();
return nullptr;
public:
virtual ~RenderElement();
- static RenderElement* createFor(Element&, PassRef<RenderStyle>);
+ static RenderPtr<RenderElement> createFor(Element&, PassRef<RenderStyle>);
bool hasInitializedStyle() const { return m_hasInitializedStyle; }
view().frameView().removeEmbeddedObjectToUpdate(*this);
}
-RenderEmbeddedObject* RenderEmbeddedObject::createForApplet(HTMLAppletElement& applet, PassRef<RenderStyle> style)
+RenderPtr<RenderEmbeddedObject> RenderEmbeddedObject::createForApplet(HTMLAppletElement& applet, PassRef<RenderStyle> style)
{
- RenderEmbeddedObject* renderer = new RenderEmbeddedObject(applet, std::move(style));
+ auto renderer = createRenderer<RenderEmbeddedObject>(applet, std::move(style));
renderer->setInline(true);
return renderer;
}
RenderEmbeddedObject(HTMLFrameOwnerElement&, PassRef<RenderStyle>);
virtual ~RenderEmbeddedObject();
- static RenderEmbeddedObject* createForApplet(HTMLAppletElement&, PassRef<RenderStyle>);
+ static RenderPtr<RenderEmbeddedObject> createForApplet(HTMLAppletElement&, PassRef<RenderStyle>);
enum PluginUnavailabilityReason {
PluginMissing,
nextRenderer = nextSiblingRenderer(element, renderingParentNode);
}
- RenderElement* newRenderer = element.createRenderer(style.releaseNonNull());
+ RenderElement* newRenderer = element.createElementRenderer(style.releaseNonNull()).leakPtr();
if (!newRenderer)
return;
if (!parentRenderer->isChildAllowed(*newRenderer, newRenderer->style())) {
}
}
-RenderElement* SVGAElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> SVGAElement::createElementRenderer(PassRef<RenderStyle> style)
{
if (parentNode() && parentNode()->isSVGElement() && toSVGElement(parentNode())->isTextContent())
- return new RenderSVGInline(*this, std::move(style));
+ return createRenderer<RenderSVGInline>(*this, std::move(style));
- return new RenderSVGTransformableContainer(*this, std::move(style));
+ return createRenderer<RenderSVGTransformableContainer>(*this, std::move(style));
}
void SVGAElement::defaultEventHandler(Event* event)
virtual void parseAttribute(const QualifiedName&, const AtomicString&) OVERRIDE;
virtual void svgAttributeChanged(const QualifiedName&);
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual bool childShouldCreateRenderer(const Node&) const OVERRIDE;
virtual void defaultEventHandler(Event*);
return false;
}
-RenderElement* SVGAltGlyphElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> SVGAltGlyphElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderSVGTSpan(*this, std::move(style));
+ return createRenderer<RenderSVGTSpan>(*this, std::move(style));
}
bool SVGAltGlyphElement::hasValidGlyphElements(Vector<String>& glyphNames) const
private:
SVGAltGlyphElement(const QualifiedName&, Document&);
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual bool childShouldCreateRenderer(const Node&) const OVERRIDE;
BEGIN_DECLARE_ANIMATED_PROPERTIES(SVGAltGlyphElement)
|| r().isRelative();
}
-RenderElement* SVGCircleElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> SVGCircleElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderSVGEllipse(*this, std::move(style));
+ return createRenderer<RenderSVGEllipse>(*this, std::move(style));
}
}
virtual bool selfHasRelativeLengths() const;
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
BEGIN_DECLARE_ANIMATED_PROPERTIES(SVGCircleElement)
DECLARE_ANIMATED_LENGTH(Cx, cx)
object->setNeedsLayout();
}
-RenderElement* SVGClipPathElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> SVGClipPathElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderSVGResourceClipper(*this, std::move(style));
+ return createRenderer<RenderSVGResourceClipper>(*this, std::move(style));
}
}
virtual void svgAttributeChanged(const QualifiedName&);
virtual void childrenChanged(const ChildChange&) OVERRIDE;
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
BEGIN_DECLARE_ANIMATED_PROPERTIES(SVGClipPathElement)
DECLARE_ANIMATED_ENUMERATION(ClipPathUnits, clipPathUnits, SVGUnitTypes::SVGUnitType)
return SVGTests::isValid();
}
-RenderElement* SVGDefsElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> SVGDefsElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderSVGHiddenContainer(*this, std::move(style));
+ return createRenderer<RenderSVGHiddenContainer>(*this, std::move(style));
}
}
virtual bool isValid() const;
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
BEGIN_DECLARE_ANIMATED_PROPERTIES(SVGDefsElement)
DECLARE_ANIMATED_BOOLEAN(ExternalResourcesRequired, externalResourcesRequired)
|| ry().isRelative();
}
-RenderElement* SVGEllipseElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> SVGEllipseElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderSVGEllipse(*this, std::move(style));
+ return createRenderer<RenderSVGEllipse>(*this, std::move(style));
}
}
virtual bool selfHasRelativeLengths() const;
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
BEGIN_DECLARE_ANIMATED_PROPERTIES(SVGEllipseElement)
DECLARE_ANIMATED_LENGTH(Cx, cx)
object->setNeedsLayout();
}
-RenderElement* SVGFilterElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> SVGFilterElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderSVGResourceFilter(*this, std::move(style));
+ return createRenderer<RenderSVGResourceFilter>(*this, std::move(style));
}
bool SVGFilterElement::childShouldCreateRenderer(const Node& child) const
virtual void svgAttributeChanged(const QualifiedName&);
virtual void childrenChanged(const ChildChange&) OVERRIDE;
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual bool childShouldCreateRenderer(const Node&) const OVERRIDE;
virtual bool selfHasRelativeLengths() const;
filterEffect->setHasHeight(true);
}
-RenderElement* SVGFilterPrimitiveStandardAttributes::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> SVGFilterPrimitiveStandardAttributes::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderSVGResourceFilterPrimitive(*this, std::move(style));
+ return createRenderer<RenderSVGResourceFilterPrimitive>(*this, std::move(style));
}
bool SVGFilterPrimitiveStandardAttributes::rendererIsNeeded(const RenderStyle& style)
private:
virtual bool isFilterEffect() const OVERRIDE { return true; }
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual bool rendererIsNeeded(const RenderStyle&) OVERRIDE;
virtual bool childShouldCreateRenderer(const Node&) const OVERRIDE { return false; }
RenderSVGResource::markForLayoutAndParentResourceInvalidation(*renderer);
}
-RenderElement* SVGForeignObjectElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> SVGForeignObjectElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderSVGForeignObject(*this, std::move(style));
+ return createRenderer<RenderSVGForeignObject>(*this, std::move(style));
}
bool SVGForeignObjectElement::childShouldCreateRenderer(const Node& child) const
virtual bool rendererIsNeeded(const RenderStyle&) OVERRIDE;
virtual bool childShouldCreateRenderer(const Node&) const OVERRIDE;
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual bool selfHasRelativeLengths() const;
RenderSVGResource::markForLayoutAndParentResourceInvalidation(*renderer);
}
-RenderElement* SVGGElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> SVGGElement::createElementRenderer(PassRef<RenderStyle> style)
{
// SVG 1.1 testsuite explicitely uses constructs like <g display="none"><linearGradient>
// We still have to create renderers for the <g> & <linearGradient> element, though the
// subtree may be hidden - we only want the resource renderers to exist so they can be
// referenced from somewhere else.
if (style.get().display() == NONE)
- return new RenderSVGHiddenContainer(*this, std::move(style));
+ return createRenderer<RenderSVGHiddenContainer>(*this, std::move(style));
- return new RenderSVGTransformableContainer(*this, std::move(style));
+ return createRenderer<RenderSVGTransformableContainer>(*this, std::move(style));
}
bool SVGGElement::rendererIsNeeded(const RenderStyle&)
private:
SVGGElement(const QualifiedName&, Document&);
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual bool isValid() const OVERRIDE { return SVGTests::isValid(); }
virtual bool supportsFocus() const OVERRIDE { return true; }
return SVGTransformable::getBBox(this, styleUpdateStrategy);
}
-RenderElement* SVGGraphicsElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> SVGGraphicsElement::createElementRenderer(PassRef<RenderStyle> style)
{
// By default, any subclass is expected to do path-based drawing
- return new RenderSVGPath(*this, std::move(style));
+ return createRenderer<RenderSVGPath>(*this, std::move(style));
}
void SVGGraphicsElement::toClipPath(Path& path)
// "base class" methods for all the elements which render as paths
virtual void toClipPath(Path&);
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
protected:
SVGGraphicsElement(const QualifiedName&, Document&);
|| height().isRelative();
}
-RenderElement* SVGImageElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> SVGImageElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderSVGImage(*this, std::move(style));
+ return createRenderer<RenderSVGImage>(*this, std::move(style));
}
bool SVGImageElement::haveLoadedRequiredResources()
virtual void didAttachRenderers() OVERRIDE;
virtual InsertionNotificationRequest insertedInto(ContainerNode&) OVERRIDE;
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual const AtomicString& imageSourceURL() const OVERRIDE;
virtual void addSubresourceAttributeURLs(ListHashSet<URL>&) const;
object->setNeedsLayout();
}
-RenderElement* SVGLinearGradientElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> SVGLinearGradientElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderSVGResourceLinearGradient(*this, std::move(style));
+ return createRenderer<RenderSVGResourceLinearGradient>(*this, std::move(style));
}
bool SVGLinearGradientElement::collectGradientAttributes(LinearGradientAttributes& attributes)
virtual void parseAttribute(const QualifiedName&, const AtomicString&) OVERRIDE;
virtual void svgAttributeChanged(const QualifiedName&);
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual bool selfHasRelativeLengths() const;
svgAttributeChanged(orientAnglePropertyInfo()->attributeName);
}
-RenderElement* SVGMarkerElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> SVGMarkerElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderSVGResourceMarker(*this, std::move(style));
+ return createRenderer<RenderSVGResourceMarker>(*this, std::move(style));
}
bool SVGMarkerElement::selfHasRelativeLengths() const
virtual void svgAttributeChanged(const QualifiedName&);
virtual void childrenChanged(const ChildChange&) OVERRIDE;
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual bool rendererIsNeeded(const RenderStyle&) { return true; }
virtual bool selfHasRelativeLengths() const;
object->setNeedsLayout();
}
-RenderElement* SVGMaskElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> SVGMaskElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderSVGResourceMasker(*this, std::move(style));
+ return createRenderer<RenderSVGResourceMasker>(*this, std::move(style));
}
bool SVGMaskElement::selfHasRelativeLengths() const
virtual void svgAttributeChanged(const QualifiedName&);
virtual void childrenChanged(const ChildChange&) OVERRIDE;
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual bool selfHasRelativeLengths() const;
return renderer->path().boundingRect();
}
-RenderElement* SVGPathElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> SVGPathElement::createElementRenderer(PassRef<RenderStyle> style)
{
// By default, any subclass is expected to do path-based drawing
- return new RenderSVGPath(*this, std::move(style));
+ return createRenderer<RenderSVGPath>(*this, std::move(style));
}
}
DECLARE_ANIMATED_BOOLEAN(ExternalResourcesRequired, externalResourcesRequired)
END_DECLARE_ANIMATED_PROPERTIES
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual Node::InsertionNotificationRequest insertedInto(ContainerNode&) OVERRIDE;
virtual void removedFrom(ContainerNode&) OVERRIDE;
object->setNeedsLayout();
}
-RenderElement* SVGPatternElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> SVGPatternElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderSVGResourcePattern(*this, std::move(style));
+ return createRenderer<RenderSVGResourcePattern>(*this, std::move(style));
}
void SVGPatternElement::collectPatternAttributes(PatternAttributes& attributes) const
virtual void svgAttributeChanged(const QualifiedName&);
virtual void childrenChanged(const ChildChange&) OVERRIDE;
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual bool selfHasRelativeLengths() const;
object->setNeedsLayout();
}
-RenderElement* SVGRadialGradientElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> SVGRadialGradientElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderSVGResourceRadialGradient(*this, std::move(style));
+ return createRenderer<RenderSVGResourceRadialGradient>(*this, std::move(style));
}
bool SVGRadialGradientElement::collectGradientAttributes(RadialGradientAttributes& attributes)
virtual void parseAttribute(const QualifiedName&, const AtomicString&) OVERRIDE;
virtual void svgAttributeChanged(const QualifiedName&);
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual bool selfHasRelativeLengths() const;
|| ry().isRelative();
}
-RenderElement* SVGRectElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> SVGRectElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderSVGRect(*this, std::move(style));
+ return createRenderer<RenderSVGRect>(*this, std::move(style));
}
}
virtual bool selfHasRelativeLengths() const;
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
BEGIN_DECLARE_ANIMATED_PROPERTIES(SVGRectElement)
DECLARE_ANIMATED_LENGTH(X, x)
return StyledElement::rendererIsNeeded(style);
}
-RenderElement* SVGSVGElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> SVGSVGElement::createElementRenderer(PassRef<RenderStyle> style)
{
if (isOutermostSVGSVGElement())
- return new RenderSVGRoot(*this, std::move(style));
+ return createRenderer<RenderSVGRoot>(*this, std::move(style));
- return new RenderSVGViewportContainer(*this, std::move(style));
+ return createRenderer<RenderSVGViewportContainer>(*this, std::move(style));
}
Node::InsertionNotificationRequest SVGSVGElement::insertedInto(ContainerNode& rootParent)
virtual void parseAttribute(const QualifiedName&, const AtomicString&) OVERRIDE;
virtual bool rendererIsNeeded(const RenderStyle&) OVERRIDE;
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual InsertionNotificationRequest insertedInto(ContainerNode&) OVERRIDE;
virtual void removedFrom(ContainerNode&) OVERRIDE;
ASSERT_NOT_REACHED();
}
-RenderElement* SVGStopElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> SVGStopElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderSVGGradientStop(*this, std::move(style));
+ return createRenderer<RenderSVGGradientStop>(*this, std::move(style));
}
bool SVGStopElement::rendererIsNeeded(const RenderStyle&)
virtual bool isGradientStop() const OVERRIDE { return true; }
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual bool rendererIsNeeded(const RenderStyle&) OVERRIDE;
BEGIN_DECLARE_ANIMATED_PROPERTIES(SVGStopElement)
return false;
}
-RenderElement* SVGSwitchElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> SVGSwitchElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderSVGTransformableContainer(*this, std::move(style));
+ return createRenderer<RenderSVGTransformableContainer>(*this, std::move(style));
}
}
virtual bool supportsFocus() const OVERRIDE { return true; }
virtual bool childShouldCreateRenderer(const Node&) const OVERRIDE;
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
BEGIN_DECLARE_ANIMATED_PROPERTIES(SVGSwitchElement)
DECLARE_ANIMATED_BOOLEAN(ExternalResourcesRequired, externalResourcesRequired)
return hasAttribute(SVGNames::viewBoxAttr);
}
-RenderElement* SVGSymbolElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> SVGSymbolElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderSVGHiddenContainer(*this, std::move(style));
+ return createRenderer<RenderSVGHiddenContainer>(*this, std::move(style));
}
}
bool isSupportedAttribute(const QualifiedName&);
virtual void parseAttribute(const QualifiedName&, const AtomicString&) OVERRIDE;
virtual void svgAttributeChanged(const QualifiedName&);
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual bool selfHasRelativeLengths() const;
ASSERT_NOT_REACHED();
}
-RenderElement* SVGTRefElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> SVGTRefElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderSVGInline(*this, std::move(style));
+ return createRenderer<RenderSVGInline>(*this, std::move(style));
}
bool SVGTRefElement::childShouldCreateRenderer(const Node& child) const
virtual void parseAttribute(const QualifiedName&, const AtomicString&) OVERRIDE;
virtual void svgAttributeChanged(const QualifiedName&);
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual bool childShouldCreateRenderer(const Node&) const OVERRIDE;
virtual bool rendererIsNeeded(const RenderStyle&);
return adoptRef(new SVGTSpanElement(tagName, document));
}
-RenderElement* SVGTSpanElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> SVGTSpanElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderSVGTSpan(*this, std::move(style));
+ return createRenderer<RenderSVGTSpan>(*this, std::move(style));
}
bool SVGTSpanElement::childShouldCreateRenderer(const Node& child) const
private:
SVGTSpanElement(const QualifiedName&, Document&);
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual bool childShouldCreateRenderer(const Node&) const OVERRIDE;
virtual bool rendererIsNeeded(const RenderStyle&);
};
return matrix;
}
-RenderElement* SVGTextElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> SVGTextElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderSVGText(*this, std::move(style));
+ return createRenderer<RenderSVGText>(*this, std::move(style));
}
bool SVGTextElement::childShouldCreateRenderer(const Node& child) const
virtual bool supportsFocus() const OVERRIDE { return true; }
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual bool childShouldCreateRenderer(const Node&) const OVERRIDE;
};
RenderSVGResource::markForLayoutAndParentResourceInvalidation(*renderer);
}
-RenderElement* SVGTextPathElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> SVGTextPathElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderSVGTextPath(*this, std::move(style));
+ return createRenderer<RenderSVGTextPath>(*this, std::move(style));
}
bool SVGTextPathElement::childShouldCreateRenderer(const Node& child) const
virtual void parseAttribute(const QualifiedName&, const AtomicString&) OVERRIDE;
virtual void svgAttributeChanged(const QualifiedName&);
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual bool childShouldCreateRenderer(const Node&) const OVERRIDE;
virtual bool rendererIsNeeded(const RenderStyle&);
#endif
}
-RenderElement* SVGUseElement::createRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> SVGUseElement::createElementRenderer(PassRef<RenderStyle> style)
{
- return new RenderSVGTransformableContainer(*this, std::move(style));
+ return createRenderer<RenderSVGTransformableContainer>(*this, std::move(style));
}
static bool isDirectReference(const Node* node)
virtual void willAttachRenderers() OVERRIDE;
- virtual RenderElement* createRenderer(PassRef<RenderStyle>) OVERRIDE;
+ virtual RenderPtr<RenderElement> createElementRenderer(PassRef<RenderStyle>) OVERRIDE;
virtual void toClipPath(Path&);
void clearResourceReferences();