Changeset 200041 in webkit


Ignore:
Timestamp:
Apr 25, 2016, 12:49:23 PM (10 years ago)
Author:
Antti Koivisto
Message:

Inline RenderStyle into RenderElement
​https://bugs.webkit.org/show_bug.cgi?id=156981

Reviewed by Andreas Kling.

We can save memory and reduce indirection of style access by inlining RenderStyle to RenderElement.

This patch also makes RenderStyle moveable and switches from std::unique_ptr<RenderStyle> to RenderStyle&&
in many places where ownership is passed.

  • Modules/plugins/PluginReplacement.h:

(WebCore::PluginReplacement::scriptObject):
(WebCore::PluginReplacement::willCreateRenderer):

  • Modules/plugins/QuickTimePluginReplacement.h:
  • Modules/plugins/QuickTimePluginReplacement.mm:

(WebCore::QuickTimePluginReplacement::~QuickTimePluginReplacement):
(WebCore::QuickTimePluginReplacement::createElementRenderer):

  • Modules/plugins/YouTubePluginReplacement.cpp:

(WebCore::YouTubePluginReplacement::YouTubePluginReplacement):
(WebCore::YouTubePluginReplacement::createElementRenderer):

  • Modules/plugins/YouTubePluginReplacement.h:
  • css/StyleResolver.cpp:

(WebCore::StyleResolver::styleForElement):
(WebCore::StyleResolver::styleForKeyframe):
(WebCore::StyleResolver::pseudoStyleForElement):
(WebCore::StyleResolver::styleForPage):
(WebCore::StyleResolver::defaultStyleForElement):
(WebCore::StyleResolver::addToMatchedPropertiesCache):
(WebCore::StyleResolver::applyPropertyToStyle):

  • dom/Document.cpp:

(WebCore::Document::recalcStyle):
(WebCore::Document::webkitWillEnterFullScreenForElement):
(WebCore::Document::setFullScreenRenderer):

  • dom/Element.cpp:

(WebCore::Element::rendererIsNeeded):
(WebCore::Element::createElementRenderer):

  • dom/Element.h:

(WebCore::Element::copyNonAttributePropertiesFromElement):

  • dom/PseudoElement.cpp:

(WebCore::PseudoElement::resolveCustomStyle):
(WebCore::PseudoElement::didAttachRenderers):
(WebCore::PseudoElement::didRecalcStyle):

  • html/BaseButtonInputType.cpp:

(WebCore::BaseButtonInputType::appendFormData):
(WebCore::BaseButtonInputType::createInputRenderer):

  • html/BaseButtonInputType.h:
  • html/FileInputType.cpp:

(WebCore::FileInputType::handleDOMActivateEvent):
(WebCore::FileInputType::createInputRenderer):

  • html/FileInputType.h:
  • html/HTMLAppletElement.cpp:

(WebCore::HTMLAppletElement::rendererIsNeeded):
(WebCore::HTMLAppletElement::createElementRenderer):

...

Location:
trunk/Source/WebCore
Files:
393 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r200039 r200041  
     12016-04-25  Antti Koivisto  <antti@apple.com>
     2
     3        Inline RenderStyle into RenderElement
     4        https://bugs.webkit.org/show_bug.cgi?id=156981
     5
     6        Reviewed by Andreas Kling.
     7
     8        We can save memory and reduce indirection of style access by inlining RenderStyle to RenderElement.
     9
     10        This patch also makes RenderStyle moveable and switches from std::unique_ptr<RenderStyle> to RenderStyle&&
     11        in many places where ownership is passed.
     12
     13        * Modules/plugins/PluginReplacement.h:
     14        (WebCore::PluginReplacement::scriptObject):
     15        (WebCore::PluginReplacement::willCreateRenderer):
     16        * Modules/plugins/QuickTimePluginReplacement.h:
     17        * Modules/plugins/QuickTimePluginReplacement.mm:
     18        (WebCore::QuickTimePluginReplacement::~QuickTimePluginReplacement):
     19        (WebCore::QuickTimePluginReplacement::createElementRenderer):
     20        * Modules/plugins/YouTubePluginReplacement.cpp:
     21        (WebCore::YouTubePluginReplacement::YouTubePluginReplacement):
     22        (WebCore::YouTubePluginReplacement::createElementRenderer):
     23        * Modules/plugins/YouTubePluginReplacement.h:
     24        * css/StyleResolver.cpp:
     25        (WebCore::StyleResolver::styleForElement):
     26        (WebCore::StyleResolver::styleForKeyframe):
     27        (WebCore::StyleResolver::pseudoStyleForElement):
     28        (WebCore::StyleResolver::styleForPage):
     29        (WebCore::StyleResolver::defaultStyleForElement):
     30        (WebCore::StyleResolver::addToMatchedPropertiesCache):
     31        (WebCore::StyleResolver::applyPropertyToStyle):
     32        * dom/Document.cpp:
     33        (WebCore::Document::recalcStyle):
     34        (WebCore::Document::webkitWillEnterFullScreenForElement):
     35        (WebCore::Document::setFullScreenRenderer):
     36        * dom/Element.cpp:
     37        (WebCore::Element::rendererIsNeeded):
     38        (WebCore::Element::createElementRenderer):
     39        * dom/Element.h:
     40        (WebCore::Element::copyNonAttributePropertiesFromElement):
     41        * dom/PseudoElement.cpp:
     42        (WebCore::PseudoElement::resolveCustomStyle):
     43        (WebCore::PseudoElement::didAttachRenderers):
     44        (WebCore::PseudoElement::didRecalcStyle):
     45        * html/BaseButtonInputType.cpp:
     46        (WebCore::BaseButtonInputType::appendFormData):
     47        (WebCore::BaseButtonInputType::createInputRenderer):
     48        * html/BaseButtonInputType.h:
     49        * html/FileInputType.cpp:
     50        (WebCore::FileInputType::handleDOMActivateEvent):
     51        (WebCore::FileInputType::createInputRenderer):
     52        * html/FileInputType.h:
     53        * html/HTMLAppletElement.cpp:
     54        (WebCore::HTMLAppletElement::rendererIsNeeded):
     55        (WebCore::HTMLAppletElement::createElementRenderer):
     56
     57        ...
     58
    1592016-04-25  Eric Carlson  <eric.carlson@apple.com>
    260
    … …  
    80138        * fileapi/File.h:
    81139        * fileapi/File.idl:
     140
     141
    82142
    831432016-04-25  Antti Koivisto  <antti@apple.com>

  • trunk/Source/WebCore/Modules/plugins/PluginReplacement.h

    r199964 r200041  
    5050
    5151    virtual bool willCreateRenderer() { return false; }
    52     virtual RenderPtr<RenderElement> createElementRenderer(HTMLPlugInElement&, std::unique_ptr<RenderStyle>, const RenderTreePosition&) = 0;
     52    virtual RenderPtr<RenderElement> createElementRenderer(HTMLPlugInElement&, RenderStyle&&, const RenderTreePosition&) = 0;
    5353};
    5454

  • trunk/Source/WebCore/Modules/plugins/QuickTimePluginReplacement.h

    r199964 r200041  
    5555
    5656    bool willCreateRenderer() final { return m_mediaElement; }
    57     RenderPtr<RenderElement> createElementRenderer(HTMLPlugInElement&, std::unique_ptr<RenderStyle>, const RenderTreePosition&) final;
     57    RenderPtr<RenderElement> createElementRenderer(HTMLPlugInElement&, RenderStyle&&, const RenderTreePosition&) final;
    5858
    5959    bool ensureReplacementScriptInjected();

  • trunk/Source/WebCore/Modules/plugins/QuickTimePluginReplacement.mm

    r199964 r200041  
    131131}
    132132
    133 RenderPtr<RenderElement> QuickTimePluginReplacement::createElementRenderer(HTMLPlugInElement& plugin, std::unique_ptr<RenderStyle> style, const RenderTreePosition& insertionPosition)
     133RenderPtr<RenderElement> QuickTimePluginReplacement::createElementRenderer(HTMLPlugInElement& plugin, RenderStyle&& style, const RenderTreePosition& insertionPosition)
    134134{
    135135    ASSERT_UNUSED(plugin, m_parentElement == &plugin);

  • trunk/Source/WebCore/Modules/plugins/YouTubePluginReplacement.cpp

    r199964 r200041  
    6868}
    6969
    70 RenderPtr<RenderElement> YouTubePluginReplacement::createElementRenderer(HTMLPlugInElement& plugin, std::unique_ptr<RenderStyle> style, const RenderTreePosition& insertionPosition)
     70RenderPtr<RenderElement> YouTubePluginReplacement::createElementRenderer(HTMLPlugInElement& plugin, RenderStyle&& style, const RenderTreePosition& insertionPosition)
    7171{
    7272    ASSERT_UNUSED(plugin, m_parentElement == &plugin);

  • trunk/Source/WebCore/Modules/plugins/YouTubePluginReplacement.h

    r199964 r200041  
    5151
    5252    bool willCreateRenderer() final { return m_embedShadowElement; }
    53     RenderPtr<RenderElement> createElementRenderer(HTMLPlugInElement&, std::unique_ptr<RenderStyle>, const RenderTreePosition&) final;
     53    RenderPtr<RenderElement> createElementRenderer(HTMLPlugInElement&, RenderStyle&&, const RenderTreePosition&) final;
    5454
    5555    HTMLPlugInElement* m_parentElement;

  • trunk/Source/WebCore/css/StyleResolver.cpp

    r199964 r200041  
    389389
    390390    if (state.parentStyle()) {
    391         state.setStyle(RenderStyle::create());
     391        state.setStyle(RenderStyle::createPtr());
    392392        state.style()->inheritFrom(state.parentStyle(), isAtShadowBoundary(element) ? RenderStyle::AtShadowBoundary : RenderStyle::NotAtShadowBoundary);
    393393    } else {
    394394        state.setStyle(defaultStyleForElement());
    395         state.setParentStyle(RenderStyle::clone(state.style()));
     395        state.setParentStyle(RenderStyle::clonePtr(*state.style()));
    396396    }
    397397
    … …  
    454454
    455455    // Create the style
    456     state.setStyle(RenderStyle::clone(elementStyle));
    457     state.setParentStyle(RenderStyle::clone(elementStyle));
     456    state.setStyle(RenderStyle::clonePtr(*elementStyle));
     457    state.setParentStyle(RenderStyle::clonePtr(*elementStyle));
    458458
    459459    TextDirection direction;
    … …  
    566566
    567567    if (m_state.parentStyle()) {
    568         state.setStyle(RenderStyle::create());
     568        state.setStyle(RenderStyle::createPtr());
    569569        state.style()->inheritFrom(m_state.parentStyle());
    570570    } else {
    571571        state.setStyle(defaultStyleForElement());
    572         state.setParentStyle(RenderStyle::clone(state.style()));
     572        state.setParentStyle(RenderStyle::clonePtr(*state.style()));
    573573    }
    574574
    … …  
    615615    auto* documentElement = m_document.documentElement();
    616616    if (!documentElement)
    617         return RenderStyle::create();
     617        return RenderStyle::createPtr();
    618618
    619619    m_state = State(*documentElement, m_document.renderStyle());
    620620
    621     m_state.setStyle(RenderStyle::create());
     621    m_state.setStyle(RenderStyle::createPtr());
    622622    m_state.style()->inheritFrom(m_state.rootElementStyle());
    623623
    … …  
    655655std::unique_ptr<RenderStyle> StyleResolver::defaultStyleForElement()
    656656{
    657     m_state.setStyle(RenderStyle::create());
     657    m_state.setStyle(RenderStyle::createPtr());
    658658    // Make sure our fonts are initialized if we don't inherit them from our parent style.
    659659    initializeFontStyle(documentSettings());
    … …  
    12141214    // Note that we don't cache the original RenderStyle instance. It may be further modified.
    12151215    // The RenderStyle in the cache is really just a holder for the substructures and never used as-is.
    1216     cacheItem.renderStyle = RenderStyle::clone(style);
    1217     cacheItem.parentRenderStyle = RenderStyle::clone(parentStyle);
     1216    cacheItem.renderStyle = RenderStyle::clonePtr(*style);
     1217    cacheItem.parentRenderStyle = RenderStyle::clonePtr(*parentStyle);
    12181218    m_matchedPropertiesCache.add(hash, WTFMove(cacheItem));
    12191219}
    … …  
    13941394{
    13951395    m_state = State();
    1396     m_state.setParentStyle(RenderStyle::clone(style.get()));
     1396    m_state.setParentStyle(RenderStyle::clonePtr(*style));
    13971397    m_state.setStyle(WTFMove(style));
    13981398    applyPropertyToCurrentStyle(id, value);

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

    r199969 r200041  
    18771877            if (Settings* settings = this->settings()) {
    18781878                if (settings->fontFallbackPrefersPictographs())
    1879                     documentStyle->fontCascade().update(&fontSelector());
     1879                    documentStyle.fontCascade().update(&fontSelector());
    18801880            }
    18811881
    1882             auto documentChange = Style::determineChange(*documentStyle, m_renderView->style());
     1882            auto documentChange = Style::determineChange(documentStyle, m_renderView->style());
    18831883            if (documentChange != Style::NoChange)
    18841884                renderView()->setStyle(WTFMove(documentStyle));
    … …  
    58365836    if (shouldCreatePlaceholder) {
    58375837        m_savedPlaceholderFrameRect = downcast<RenderBox>(*renderer).frameRect();
    5838         m_savedPlaceholderRenderStyle = RenderStyle::clone(&renderer->style());
     5838        m_savedPlaceholderRenderStyle = RenderStyle::clonePtr(renderer->style());
    58395839    }
    58405840
    … …  
    59165916    else if (renderer && m_fullScreenRenderer && m_fullScreenRenderer->placeholder()) {
    59175917        RenderBlock* placeholder = m_fullScreenRenderer->placeholder();
    5918         renderer->createPlaceholder(RenderStyle::clone(&placeholder->style()), placeholder->frameRect());
     5918        renderer->createPlaceholder(RenderStyle::clonePtr(placeholder->style()), placeholder->frameRect());
    59195919    }
    59205920

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

    r199969 r200041  
    14941494}
    14951495
    1496 RenderPtr<RenderElement> Element::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     1496RenderPtr<RenderElement> Element::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    14971497{
    14981498    return RenderElement::createFor(*this, WTFMove(style));

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

    r199969 r200041  
    244244    virtual void copyNonAttributePropertiesFromElement(const Element&) { }
    245245
    246     virtual RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&);
     246    virtual RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&);
    247247    virtual bool rendererIsNeeded(const RenderStyle&);
    248248

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

    r199964 r200041  
    8383    if (!style)
    8484        return Nullopt;
    85     return ElementStyle(RenderStyle::clone(style));
     85    return ElementStyle(RenderStyle::clonePtr(*style));
    8686}
    8787
    … …  
    123123        if (!is<RenderImage>(*child) && !is<RenderQuote>(*child))
    124124            continue;
    125         std::unique_ptr<RenderStyle> createdStyle = RenderStyle::createStyleInheritingFromPseudoStyle(renderer.style());
     125        auto createdStyle = RenderStyle::createStyleInheritingFromPseudoStyle(renderer.style());
    126126        downcast<RenderElement>(*child).setStyle(WTFMove(createdStyle));
    127127    }

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

    r199964 r200041  
    5353}
    5454
    55 RenderPtr<RenderElement> BaseButtonInputType::createInputRenderer(std::unique_ptr<RenderStyle> style)
     55RenderPtr<RenderElement> BaseButtonInputType::createInputRenderer(RenderStyle&& style)
    5656{
    5757    return createRenderer<RenderButton>(element(), WTFMove(style));

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

    r199964 r200041  
    4444    bool shouldSaveAndRestoreFormControlState() const override;
    4545    bool appendFormData(FormDataList&, bool) const override;
    46     RenderPtr<RenderElement> createInputRenderer(std::unique_ptr<RenderStyle>) override;
     46    RenderPtr<RenderElement> createInputRenderer(RenderStyle&&) override;
    4747    bool storesValueSeparateFromAttribute() override;
    4848    void setValue(const String&, bool, TextFieldEventBehavior) override;

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

    r199964 r200041  
    196196}
    197197
    198 RenderPtr<RenderElement> FileInputType::createInputRenderer(std::unique_ptr<RenderStyle> style)
     198RenderPtr<RenderElement> FileInputType::createInputRenderer(RenderStyle&& style)
    199199{
    200200    return createRenderer<RenderFileUploadControl>(element(), WTFMove(style));

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

    r199964 r200041  
    5959    String valueMissingText() const override;
    6060    void handleDOMActivateEvent(Event*) override;
    61     RenderPtr<RenderElement> createInputRenderer(std::unique_ptr<RenderStyle>) override;
     61    RenderPtr<RenderElement> createInputRenderer(RenderStyle&&) override;
    6262    bool canSetStringValue() const override;
    6363    bool canChangeFromAnotherType() const override;

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

    r199964 r200041  
    7676}
    7777
    78 RenderPtr<RenderElement> HTMLAppletElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     78RenderPtr<RenderElement> HTMLAppletElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    7979{
    8080    if (!canEmbedJava())

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

    r199964 r200041  
    3838   
    3939    bool rendererIsNeeded(const RenderStyle&) override;
    40     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     40    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    4141
    4242    RenderWidget* renderWidgetLoadingPlugin() const override;

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

    r199964 r200041  
    5252}
    5353
    54 RenderPtr<RenderElement> HTMLAttachmentElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     54RenderPtr<RenderElement> HTMLAttachmentElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    5555{
    5656    return createRenderer<RenderAttachment>(*this, WTFMove(style));

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

    r199964 r200041  
    4848    virtual ~HTMLAttachmentElement();
    4949
    50     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     50    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    5151
    5252    bool shouldSelectOnMouseDown() override { return true; }

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

    r199964 r200041  
    7171}
    7272
    73 RenderPtr<RenderElement> HTMLBRElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     73RenderPtr<RenderElement> HTMLBRElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    7474{
    75     if (style->hasContent())
     75    if (style.hasContent())
    7676        return RenderElement::createFor(*this, WTFMove(style));
    7777

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

    r199964 r200041  
    4242    void collectStyleForPresentationAttribute(const QualifiedName&, const AtomicString&, MutableStyleProperties&) override;
    4343
    44     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     44    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    4545};
    4646

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

    r199964 r200041  
    5757}
    5858
    59 RenderPtr<RenderElement> HTMLButtonElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     59RenderPtr<RenderElement> HTMLButtonElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    6060{
    6161    return createRenderer<RenderButton>(*this, WTFMove(style));

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

    r199964 r200041  
    4646    const AtomicString& formControlType() const override;
    4747
    48     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     48    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    4949
    5050    // HTMLFormControlElement always creates one, but buttons don't need it.

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

    r199964 r200041  
    125125}
    126126
    127 RenderPtr<RenderElement> HTMLCanvasElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition& insertionPosition)
     127RenderPtr<RenderElement> HTMLCanvasElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition& insertionPosition)
    128128{
    129129    Frame* frame = document().frame();

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

    r199964 r200041  
    151151
    152152    void parseAttribute(const QualifiedName&, const AtomicString&) override;
    153     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     153    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    154154
    155155    bool canContainRangeEndPoint() const override;

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

    r199964 r200041  
    8888}
    8989
    90 RenderPtr<RenderElement> HTMLDetailsElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     90RenderPtr<RenderElement> HTMLDetailsElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    9191{
    9292    return createRenderer<RenderBlockFlow>(*this, WTFMove(style));

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

    r199964 r200041  
    3939    HTMLDetailsElement(const QualifiedName&, Document&);
    4040
    41     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     41    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    4242    void parseAttribute(const QualifiedName&, const AtomicString&) override;
    4343

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

    r199969 r200041  
    869869}
    870870
    871 RenderPtr<RenderElement> HTMLElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     871RenderPtr<RenderElement> HTMLElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    872872{
    873873    return RenderElement::createFor(*this, WTFMove(style));

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

    r199969 r200041  
    7878
    7979    bool rendererIsNeeded(const RenderStyle&) override;
    80     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     80    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    8181
    8282    HTMLFormElement* form() const { return virtualForm(); }

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

    r199964 r200041  
    151151}
    152152
    153 RenderPtr<RenderElement> HTMLFieldSetElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     153RenderPtr<RenderElement> HTMLFieldSetElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    154154{
    155155    return createRenderer<RenderFieldset>(*this, WTFMove(style));

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

    r199964 r200041  
    5454    bool isEnumeratable() const override { return true; }
    5555    bool supportsFocus() const override;
    56     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     56    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    5757    const AtomicString& formControlType() const override;
    5858    bool computeWillValidate() const override { return false; }

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

    r199964 r200041  
    5454}
    5555
    56 RenderPtr<RenderElement> HTMLFrameElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     56RenderPtr<RenderElement> HTMLFrameElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    5757{
    5858    return createRenderer<RenderFrame>(*this, WTFMove(style));

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

    r199964 r200041  
    4343
    4444    bool rendererIsNeeded(const RenderStyle&) override;
    45     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     45    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    4646   
    4747    void parseAttribute(const QualifiedName&, const AtomicString&) override;

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

    r199964 r200041  
    158158}
    159159
    160 RenderPtr<RenderElement> HTMLFrameSetElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
    161 {
    162     if (style->hasContent())
     160RenderPtr<RenderElement> HTMLFrameSetElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
     161{
     162    if (style.hasContent())
    163163        return RenderElement::createFor(*this, WTFMove(style));
    164164   

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

    r199964 r200041  
    5757    void willAttachRenderers() override;
    5858    bool rendererIsNeeded(const RenderStyle&) override;
    59     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     59    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    6060   
    6161    void defaultEventHandler(Event*) override;

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

    r199964 r200041  
    101101}
    102102
    103 RenderPtr<RenderElement> HTMLIFrameElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     103RenderPtr<RenderElement> HTMLIFrameElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    104104{
    105105    return createRenderer<RenderIFrame>(*this, WTFMove(style));

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

    r199964 r200041  
    4949
    5050    bool rendererIsNeeded(const RenderStyle&) override;
    51     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     51    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    5252
    5353    std::unique_ptr<DOMTokenList> m_sandbox;

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

    r199964 r200041  
    257257}
    258258
    259 RenderPtr<RenderElement> HTMLImageElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
    260 {
    261     if (style->hasContent())
     259RenderPtr<RenderElement> HTMLImageElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
     260{
     261    if (style.hasContent())
    262262        return RenderElement::createFor(*this, WTFMove(style));
    263263

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

    r199964 r200041  
    106106
    107107    void didAttachRenderers() override;
    108     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     108    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    109109    void setBestFitURLAndDPRFromImageCandidate(const ImageCandidate&);
    110110

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

    r199964 r200041  
    761761}
    762762
    763 RenderPtr<RenderElement> HTMLInputElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     763RenderPtr<RenderElement> HTMLInputElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    764764{
    765765    return m_inputType->createInputRenderer(WTFMove(style));
    … …  
    18761876}
    18771877
    1878 std::unique_ptr<RenderStyle> HTMLInputElement::createInnerTextStyle(const RenderStyle& style) const
     1878RenderStyle HTMLInputElement::createInnerTextStyle(const RenderStyle& style) const
    18791879{
    18801880    auto textBlockStyle = RenderStyle::create();
    1881     textBlockStyle->inheritFrom(&style);
    1882     adjustInnerTextStyle(style, *textBlockStyle);
    1883 
    1884     textBlockStyle->setWhiteSpace(PRE);
    1885     textBlockStyle->setOverflowWrap(NormalOverflowWrap);
    1886     textBlockStyle->setOverflowX(OHIDDEN);
    1887     textBlockStyle->setOverflowY(OHIDDEN);
    1888     textBlockStyle->setTextOverflow(shouldTruncateText(style) ? TextOverflowEllipsis : TextOverflowClip);
     1881    textBlockStyle.inheritFrom(&style);
     1882    adjustInnerTextStyle(style, textBlockStyle);
     1883
     1884    textBlockStyle.setWhiteSpace(PRE);
     1885    textBlockStyle.setOverflowWrap(NormalOverflowWrap);
     1886    textBlockStyle.setOverflowX(OHIDDEN);
     1887    textBlockStyle.setOverflowY(OHIDDEN);
     1888    textBlockStyle.setTextOverflow(shouldTruncateText(style) ? TextOverflowEllipsis : TextOverflowClip);
    18891889
    18901890    // Do not allow line-height to be smaller than our default.
    1891     if (textBlockStyle->fontMetrics().lineSpacing() > style.computedLineHeight())
    1892         textBlockStyle->setLineHeight(RenderStyle::initialLineHeight());
    1893 
    1894     textBlockStyle->setDisplay(BLOCK);
     1891    if (textBlockStyle.fontMetrics().lineSpacing() > style.computedLineHeight())
     1892        textBlockStyle.setLineHeight(RenderStyle::initialLineHeight());
     1893
     1894    textBlockStyle.setDisplay(BLOCK);
    18951895
    18961896    return textBlockStyle;

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

    r199964 r200041  
    143143   
    144144    TextControlInnerTextElement* innerTextElement() const final;
    145     std::unique_ptr<RenderStyle> createInnerTextStyle(const RenderStyle&) const override;
     145    RenderStyle createInnerTextStyle(const RenderStyle&) const override;
    146146
    147147    HTMLElement* innerBlockElement() const;
    … …  
    202202
    203203    bool rendererIsNeeded(const RenderStyle&) final;
    204     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) final;
     204    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) final;
    205205    void willAttachRenderers() final;
    206206    void didAttachRenderers() final;

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

    r199964 r200041  
    238238        bool mediaQueryMatches = true;
    239239        if (!m_media.isEmpty()) {
    240             std::unique_ptr<RenderStyle> documentStyle;
     240            Optional<RenderStyle> documentStyle;
    241241            if (document().hasLivingRenderTree())
    242242                documentStyle = Style::resolveForDocument(document());
    243243            RefPtr<MediaQuerySet> media = MediaQuerySet::createAllowingDescriptionSyntax(m_media);
    244             MediaQueryEvaluator evaluator(document().frame()->view()->mediaType(), document().frame(), documentStyle.get());
     244            MediaQueryEvaluator evaluator(document().frame()->view()->mediaType(), document().frame(), documentStyle ? &*documentStyle : nullptr);
    245245            mediaQueryMatches = evaluator.eval(media.get());
    246246        }

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

    r200039 r200041  
    737737}
    738738
    739 RenderPtr<RenderElement> HTMLMediaElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     739RenderPtr<RenderElement> HTMLMediaElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    740740{
    741741    return createRenderer<RenderMedia>(*this, WTFMove(style));

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

    r199964 r200041  
    483483#endif
    484484
    485     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     485    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    486486
    487487#if ENABLE(MEDIA_CONTROLS_SCRIPT)

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

    r199964 r200041  
    5858}
    5959
    60 RenderPtr<RenderElement> HTMLMeterElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
    61 {
    62     if (!document().page()->theme().supportsMeter(style->appearance()))
     60RenderPtr<RenderElement> HTMLMeterElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
     61{
     62    if (!document().page()->theme().supportsMeter(style.appearance()))
    6363        return RenderElement::createFor(*this, WTFMove(style));
    6464

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

    r199964 r200041  
    7171    bool supportLabels() const override { return true; }
    7272
    73     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     73    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    7474    bool childShouldCreateRenderer(const Node&) const override;
    7575    void parseAttribute(const QualifiedName&, const AtomicString&) override;

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

    r199964 r200041  
    295295#endif /* ENABLE(NETSCAPE_PLUGIN_API) */
    296296
    297 RenderPtr<RenderElement> HTMLPlugInElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition& insertionPosition)
     297RenderPtr<RenderElement> HTMLPlugInElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition& insertionPosition)
    298298{
    299299    if (m_pluginReplacement && m_pluginReplacement->willCreateRenderer())

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

    r199964 r200041  
    104104
    105105    virtual bool requestObject(const String& url, const String& mimeType, const Vector<String>& paramNames, const Vector<String>& paramValues);
    106     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     106    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    107107    void didAddUserAgentShadowRoot(ShadowRoot*) override;
    108108

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

    r199964 r200041  
    195195}
    196196
    197 RenderPtr<RenderElement> HTMLPlugInImageElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition& insertionPosition)
     197RenderPtr<RenderElement> HTMLPlugInImageElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition& insertionPosition)
    198198{
    199199    ASSERT(!document().inPageCache());

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

    r199964 r200041  
    115115    void didAddUserAgentShadowRoot(ShadowRoot*) final;
    116116
    117     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     117    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    118118    bool childShouldCreateRenderer(const Node&) const override;
    119119    bool willRecalcStyle(Style::Change) final;

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

    r199964 r200041  
    5757}
    5858
    59 RenderPtr<RenderElement> HTMLProgressElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     59RenderPtr<RenderElement> HTMLProgressElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    6060{
    61     if (!style->hasAppearance())
     61    if (!style.hasAppearance())
    6262        return RenderElement::createFor(*this, WTFMove(style));
    6363

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

    r199964 r200041  
    5353    bool supportLabels() const override { return true; }
    5454
    55     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     55    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    5656    bool childShouldCreateRenderer(const Node&) const override;
    5757    RenderProgress* renderProgress() const;

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

    r199964 r200041  
    340340}
    341341
    342 RenderPtr<RenderElement> HTMLSelectElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     342RenderPtr<RenderElement> HTMLSelectElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    343343{
    344344#if !PLATFORM(IOS)

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

    r199964 r200041  
    132132
    133133    bool childShouldCreateRenderer(const Node&) const final;
    134     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) final;
     134    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) final;
    135135    bool appendFormData(FormDataList&, bool) final;
    136136

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

    r199964 r200041  
    5050}
    5151
    52 RenderPtr<RenderElement> HTMLSummaryElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     52RenderPtr<RenderElement> HTMLSummaryElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    5353{
    5454    return createRenderer<RenderBlockFlow>(*this, WTFMove(style));

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

    r199964 r200041  
    3838    HTMLSummaryElement(const QualifiedName&, Document&);
    3939
    40     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     40    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    4141    void defaultEventHandler(Event*) override;
    4242

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

    r199964 r200041  
    209209}
    210210
    211 RenderPtr<RenderElement> HTMLTextAreaElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     211RenderPtr<RenderElement> HTMLTextAreaElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    212212{
    213213    return createRenderer<RenderTextControlMultiLine>(*this, WTFMove(style));
    … …  
    524524}
    525525
    526 std::unique_ptr<RenderStyle> HTMLTextAreaElement::createInnerTextStyle(const RenderStyle& style) const
     526RenderStyle HTMLTextAreaElement::createInnerTextStyle(const RenderStyle& style) const
    527527{
    528528    auto textBlockStyle = RenderStyle::create();
    529     textBlockStyle->inheritFrom(&style);
    530     adjustInnerTextStyle(style, *textBlockStyle);
    531     textBlockStyle->setDisplay(BLOCK);
     529    textBlockStyle.inheritFrom(&style);
     530    adjustInnerTextStyle(style, textBlockStyle);
     531    textBlockStyle.setDisplay(BLOCK);
    532532
    533533#if PLATFORM(IOS)
    534534    // We're adding three extra pixels of padding to line textareas up with text fields. 
    535     textBlockStyle->setPaddingLeft(Length(3, Fixed));
    536     textBlockStyle->setPaddingRight(Length(3, Fixed));
     535    textBlockStyle.setPaddingLeft(Length(3, Fixed));
     536    textBlockStyle.setPaddingRight(Length(3, Fixed));
    537537#endif
    538538

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

    r199964 r200041  
    5555   
    5656    TextControlInnerTextElement* innerTextElement() const override;
    57     std::unique_ptr<RenderStyle> createInnerTextStyle(const RenderStyle&) const override;
     57    RenderStyle createInnerTextStyle(const RenderStyle&) const override;
    5858
    5959    void rendererWillBeDestroyed();
    … …  
    106106    bool isPresentationAttribute(const QualifiedName&) const override;
    107107    void collectStyleForPresentationAttribute(const QualifiedName&, const AtomicString&, MutableStyleProperties&) override;
    108     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     108    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    109109    bool appendFormData(FormDataList&, bool) override;
    110110    void reset() override;

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

    r199964 r200041  
    8181
    8282    virtual TextControlInnerTextElement* innerTextElement() const = 0;
    83     virtual std::unique_ptr<RenderStyle> createInnerTextStyle(const RenderStyle&) const = 0;
     83    virtual RenderStyle createInnerTextStyle(const RenderStyle&) const = 0;
    8484
    8585    void selectionChanged(bool shouldFireSelectEvent);

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

    r199964 r200041  
    7474}
    7575
    76 RenderPtr<RenderElement> HTMLVideoElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     76RenderPtr<RenderElement> HTMLVideoElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    7777{
    7878    return createRenderer<RenderVideo>(*this, WTFMove(style));

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

    r199964 r200041  
    7979
    8080    URL posterImageURL() const;
    81     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     81    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    8282
    8383#if ENABLE(VIDEO_PRESENTATION_MODE)

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

    r199964 r200041  
    4545}
    4646
    47 RenderPtr<RenderElement> HTMLWBRElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     47RenderPtr<RenderElement> HTMLWBRElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    4848{
    4949    return createRenderer<RenderLineBreak>(*this, WTFMove(style));

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

    r199964 r200041  
    3838    HTMLWBRElement(const QualifiedName&, Document&);
    3939
    40     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     40    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    4141};
    4242

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

    r199964 r200041  
    6868}
    6969
    70 RenderPtr<RenderElement> HiddenInputType::createInputRenderer(std::unique_ptr<RenderStyle>)
     70RenderPtr<RenderElement> HiddenInputType::createInputRenderer(RenderStyle&&)
    7171{
    7272    ASSERT_NOT_REACHED();

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

    r199964 r200041  
    4545    void restoreFormControlState(const FormControlState&) override;
    4646    bool supportsValidation() const override;
    47     RenderPtr<RenderElement> createInputRenderer(std::unique_ptr<RenderStyle>) override;
     47    RenderPtr<RenderElement> createInputRenderer(RenderStyle&&) override;
    4848    void accessKeyAction(bool sendMouseEvents) override;
    4949    bool rendererIsNeeded() override;

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

    r199964 r200041  
    103103}
    104104
    105 RenderPtr<RenderElement> ImageInputType::createInputRenderer(std::unique_ptr<RenderStyle> style)
     105RenderPtr<RenderElement> ImageInputType::createInputRenderer(RenderStyle&& style)
    106106{
    107107    return createRenderer<RenderImage>(element(), WTFMove(style));

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

    r199964 r200041  
    4848    bool appendFormData(FormDataList&, bool) const override;
    4949    bool supportsValidation() const override;
    50     RenderPtr<RenderElement> createInputRenderer(std::unique_ptr<RenderStyle>) override;
     50    RenderPtr<RenderElement> createInputRenderer(RenderStyle&&) override;
    5151    void handleDOMActivateEvent(Event*) override;
    5252    void altAttributeChanged() override;

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

    r199964 r200041  
    480480}
    481481
    482 RenderPtr<RenderElement> InputType::createInputRenderer(std::unique_ptr<RenderStyle> style)
     482RenderPtr<RenderElement> InputType::createInputRenderer(RenderStyle&& style)
    483483{
    484484    return RenderPtr<RenderElement>(RenderElement::createFor(element(), WTFMove(style)));

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

    r199964 r200041  
    233233
    234234    virtual bool rendererIsNeeded();
    235     virtual RenderPtr<RenderElement> createInputRenderer(std::unique_ptr<RenderStyle>);
     235    virtual RenderPtr<RenderElement> createInputRenderer(RenderStyle&&);
    236236    virtual void addSearchResult();
    237237    virtual void attach();

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

    r199964 r200041  
    286286}
    287287
    288 RenderPtr<RenderElement> RangeInputType::createInputRenderer(std::unique_ptr<RenderStyle> style)
     288RenderPtr<RenderElement> RangeInputType::createInputRenderer(RenderStyle&& style)
    289289{
    290290    return createRenderer<RenderSlider>(element(), WTFMove(style));

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

    r199964 r200041  
    5555#endif
    5656    void handleKeydownEvent(KeyboardEvent*) override;
    57     RenderPtr<RenderElement> createInputRenderer(std::unique_ptr<RenderStyle>) override;
     57    RenderPtr<RenderElement> createInputRenderer(RenderStyle&&) override;
    5858    void createShadowSubtree() override;
    5959    Decimal parseToNumber(const String&, const Decimal&) const override;

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

    r199964 r200041  
    4444}
    4545
    46 RenderPtr<RenderElement> RubyElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition& insertionPosition)
     46RenderPtr<RenderElement> RubyElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition& insertionPosition)
    4747{
    48     if (style->display() == INLINE)
     48    if (style.display() == INLINE)
    4949        return createRenderer<RenderRubyAsInline>(*this, WTFMove(style));
    50     if (style->display() == BLOCK || style->display() == INLINE_BLOCK)
     50    if (style.display() == BLOCK || style.display() == INLINE_BLOCK)
    5151        return createRenderer<RenderRubyAsBlock>(*this, WTFMove(style));
    5252    return HTMLElement::createElementRenderer(WTFMove(style), insertionPosition);

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

    r199964 r200041  
    3737private:
    3838    RubyElement(const QualifiedName&, Document&);
    39     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     39    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    4040};
    4141

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

    r199964 r200041  
    4646}
    4747
    48 RenderPtr<RenderElement> RubyTextElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition& insertionPosition)
     48RenderPtr<RenderElement> RubyTextElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition& insertionPosition)
    4949{
    5050    // RenderRubyText requires its parent to be RenderRubyRun.
    51     if (isRuby(insertionPosition.parent()) && style->display() == BLOCK)
     51    if (isRuby(insertionPosition.parent()) && style.display() == BLOCK)
    5252        return createRenderer<RenderRubyText>(*this, WTFMove(style));
    5353    return HTMLElement::createElementRenderer(WTFMove(style), insertionPosition);

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

    r199964 r200041  
    3737private:
    3838    RubyTextElement(const QualifiedName&, Document&);
    39     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     39    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    4040};
    4141

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

    r199964 r200041  
    7777}
    7878
    79 RenderPtr<RenderElement> SearchInputType::createInputRenderer(std::unique_ptr<RenderStyle> style)
     79RenderPtr<RenderElement> SearchInputType::createInputRenderer(RenderStyle&& style)
    8080{
    8181    return createRenderer<RenderSearchField>(element(), WTFMove(style));

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

    r199964 r200041  
    4949    void addSearchResult() override;
    5050    void maxResultsAttributeChanged() override;
    51     RenderPtr<RenderElement> createInputRenderer(std::unique_ptr<RenderStyle>) override;
     51    RenderPtr<RenderElement> createInputRenderer(RenderStyle&&) override;
    5252    const AtomicString& formControlType() const override;
    5353    bool isSearchField() const override;

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

    r199964 r200041  
    232232}
    233233
    234 RenderPtr<RenderElement> TextFieldInputType::createInputRenderer(std::unique_ptr<RenderStyle> style)
     234RenderPtr<RenderElement> TextFieldInputType::createInputRenderer(RenderStyle&& style)
    235235{
    236236    return createRenderer<RenderTextControlSingleLine>(element(), WTFMove(style));

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

    r199964 r200041  
    8383    void forwardEvent(Event*) final;
    8484    bool shouldSubmitImplicitly(Event*) final;
    85     RenderPtr<RenderElement> createInputRenderer(std::unique_ptr<RenderStyle>) override;
     85    RenderPtr<RenderElement> createInputRenderer(RenderStyle&&) override;
    8686    bool shouldUseInputMethod() const override;
    8787    bool shouldRespectListAttribute() override;

  • trunk/Source/WebCore/html/canvas/CanvasRenderingContext2D.cpp

    r199964 r200041  
    22172217    // Map the <canvas> font into the text style. If the font uses keywords like larger/smaller, these will work
    22182218    // relative to the canvas.
    2219     auto newStyle = RenderStyle::create();
     2219    auto newStyle = RenderStyle::createPtr();
    22202220
    22212221    Document& document = canvas()->document();

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

    r199964 r200041  
    5151}
    5252
    53 RenderPtr<RenderElement> DetailsMarkerControl::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     53RenderPtr<RenderElement> DetailsMarkerControl::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    5454{
    5555    return createRenderer<RenderDetailsMarker>(*this, WTFMove(style));

  • trunk/Source/WebCore/html/shadow/DetailsMarkerControl.h

    r199964 r200041  
    4444    DetailsMarkerControl(Document&);
    4545
    46     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     46    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    4747    bool rendererIsNeeded(const RenderStyle&) override;
    4848};

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

    r199964 r200041  
    308308}
    309309
    310 RenderPtr<RenderElement> MediaControlTimelineContainerElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     310RenderPtr<RenderElement> MediaControlTimelineContainerElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    311311{
    312312    return createRenderer<RenderMediaControlTimelineContainer>(*this, WTFMove(style));
    … …  
    328328}
    329329
    330 RenderPtr<RenderElement> MediaControlVolumeSliderContainerElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     330RenderPtr<RenderElement> MediaControlVolumeSliderContainerElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    331331{
    332332    return createRenderer<RenderMediaVolumeSliderContainer>(*this, WTFMove(style));
    … …  
    10831083}
    10841084
    1085 RenderPtr<RenderElement> MediaControlTextTrackContainerElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     1085RenderPtr<RenderElement> MediaControlTextTrackContainerElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    10861086{
    10871087    return createRenderer<RenderTextTrackContainerElement>(*this, WTFMove(style));

  • trunk/Source/WebCore/html/shadow/MediaControlElements.h

    r199964 r200041  
    111111    explicit MediaControlTimelineContainerElement(Document&);
    112112
    113     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     113    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    114114};
    115115
    … …  
    129129    void defaultEventHandler(Event*) override;
    130130
    131     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     131    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    132132};
    133133
    … …  
    457457    explicit MediaControlTextTrackContainerElement(Document&);
    458458
    459     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     459    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    460460
    461461    RefPtr<Image> createTextTrackRepresentationImage() override;

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

    r199964 r200041  
    7474}
    7575
    76 RenderPtr<RenderElement> MeterInnerElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     76RenderPtr<RenderElement> MeterInnerElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    7777{
    7878    return createRenderer<RenderMeter>(*this, WTFMove(style));

  • trunk/Source/WebCore/html/shadow/MeterShadowElement.h

    r199964 r200041  
    6161
    6262    bool rendererIsNeeded(const RenderStyle&) override;
    63     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     63    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    6464};
    6565

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

    r199964 r200041  
    6161}
    6262
    63 RenderPtr<RenderElement> ProgressInnerElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     63RenderPtr<RenderElement> ProgressInnerElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    6464{
    6565    return createRenderer<RenderProgress>(*this, WTFMove(style));

  • trunk/Source/WebCore/html/shadow/ProgressShadowElement.h

    r199964 r200041  
    5858    ProgressInnerElement(Document&);
    5959
    60     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     60    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    6161    bool rendererIsNeeded(const RenderStyle&) override;
    6262};

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

    r199964 r200041  
    7979// --------------------------------
    8080
    81 RenderSliderThumb::RenderSliderThumb(SliderThumbElement& element, std::unique_ptr<RenderStyle> style)
     81RenderSliderThumb::RenderSliderThumb(SliderThumbElement& element, RenderStyle&& style)
    8282    : RenderBlockFlow(element, WTFMove(style))
    8383{
    … …  
    113113class RenderSliderContainer final : public RenderFlexibleBox {
    114114public:
    115     RenderSliderContainer(SliderContainerElement& element, std::unique_ptr<RenderStyle> style)
     115    RenderSliderContainer(SliderContainerElement& element, RenderStyle&& style)
    116116        : RenderFlexibleBox(element, WTFMove(style))
    117117    {
    … …  
    220220}
    221221
    222 RenderPtr<RenderElement> SliderThumbElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     222RenderPtr<RenderElement> SliderThumbElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    223223{
    224224    return createRenderer<RenderSliderThumb>(*this, WTFMove(style));
    … …  
    624624}
    625625
    626 RenderPtr<RenderElement> SliderContainerElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     626RenderPtr<RenderElement> SliderContainerElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    627627{
    628628    return createRenderer<RenderSliderContainer>(*this, WTFMove(style));

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

    r199964 r200041  
    6262    SliderThumbElement(Document&);
    6363
    64     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     64    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    6565
    6666    Ref<Element> cloneElementWithoutAttributesAndChildren(Document&) override;
    … …  
    120120class RenderSliderThumb final : public RenderBlockFlow {
    121121public:
    122     RenderSliderThumb(SliderThumbElement&, std::unique_ptr<RenderStyle>);
     122    RenderSliderThumb(SliderThumbElement&, RenderStyle&&);
    123123    void updateAppearance(RenderStyle* parentStyle);
    124124
    … …  
    135135private:
    136136    SliderContainerElement(Document&);
    137     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     137    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    138138    Optional<ElementStyle> resolveCustomStyle(RenderStyle&, RenderStyle*) override;
    139139    const AtomicString& shadowPseudoId() const override;

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

    r199964 r200041  
    6060}
    6161   
    62 RenderPtr<RenderElement> TextControlInnerContainer::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     62RenderPtr<RenderElement> TextControlInnerContainer::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    6363{
    6464    return createRenderer<RenderTextControlInnerContainer>(*this, WTFMove(style));
    … …  
    7878Optional<ElementStyle> TextControlInnerElement::resolveCustomStyle(RenderStyle&, RenderStyle* shadowHostStyle)
    7979{
    80     auto innerContainerStyle = RenderStyle::create();
     80    auto innerContainerStyle = RenderStyle::createPtr();
    8181    innerContainerStyle->inheritFrom(shadowHostStyle);
    8282
    … …  
    125125}
    126126
    127 RenderPtr<RenderElement> TextControlInnerTextElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     127RenderPtr<RenderElement> TextControlInnerTextElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    128128{
    129129    return createRenderer<RenderTextControlInnerBlock>(*this, WTFMove(style));
    … …  
    137137Optional<ElementStyle> TextControlInnerTextElement::resolveCustomStyle(RenderStyle&, RenderStyle* shadowHostStyle)
    138138{
    139     return ElementStyle(downcast<HTMLTextFormControlElement>(*shadowHost()).createInnerTextStyle(*shadowHostStyle));
     139    auto style = downcast<HTMLTextFormControlElement>(*shadowHost()).createInnerTextStyle(*shadowHostStyle);
     140    return ElementStyle(std::make_unique<RenderStyle>(WTFMove(style)));
    140141}
    141142

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

    r199964 r200041  
    4040protected:
    4141    TextControlInnerContainer(Document&);
    42     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     42    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    4343};
    4444
    … …  
    6565private:
    6666    TextControlInnerTextElement(Document&);
    67     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     67    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    6868    Optional<ElementStyle> resolveCustomStyle(RenderStyle& parentStyle, RenderStyle* shadowHostStyle) override;
    6969    bool isMouseFocusable() const override { return false; }

  • trunk/Source/WebCore/html/shadow/mac/ImageControlsButtonElementMac.cpp

    r199964 r200041  
    4545class RenderImageControlsButton final : public RenderBlockFlow {
    4646public:
    47     RenderImageControlsButton(HTMLElement&, std::unique_ptr<RenderStyle>);
     47    RenderImageControlsButton(HTMLElement&, RenderStyle&&);
    4848    virtual ~RenderImageControlsButton();
    4949
    … …  
    5656};
    5757
    58 RenderImageControlsButton::RenderImageControlsButton(HTMLElement& element, std::unique_ptr<RenderStyle> style)
     58RenderImageControlsButton::RenderImageControlsButton(HTMLElement& element, RenderStyle&& style)
    5959    : RenderBlockFlow(element, WTFMove(style))
    6060{
    … …  
    126126}
    127127
    128 RenderPtr<RenderElement> ImageControlsButtonElementMac::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     128RenderPtr<RenderElement> ImageControlsButtonElementMac::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    129129{
    130130    return createRenderer<RenderImageControlsButton>(*this, WTFMove(style));

  • trunk/Source/WebCore/html/shadow/mac/ImageControlsButtonElementMac.h

    r199964 r200041  
    4343
    4444    void defaultEventHandler(Event*) override;
    45     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     45    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    4646
    4747    bool isImageControlsButtonElement() const override { return true; }

  • trunk/Source/WebCore/html/shadow/mac/ImageControlsRootElementMac.cpp

    r199964 r200041  
    3939class RenderImageControls final : public RenderBlockFlow {
    4040public:
    41     RenderImageControls(HTMLElement&, std::unique_ptr<RenderStyle>);
     41    RenderImageControls(HTMLElement&, RenderStyle&&);
    4242    virtual ~RenderImageControls();
    4343
    … …  
    5050};
    5151
    52 RenderImageControls::RenderImageControls(HTMLElement& element, std::unique_ptr<RenderStyle> style)
     52RenderImageControls::RenderImageControls(HTMLElement& element, RenderStyle&& style)
    5353    : RenderBlockFlow(element, WTFMove(style))
    5454{
    … …  
    104104}
    105105
    106 RenderPtr<RenderElement> ImageControlsRootElementMac::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     106RenderPtr<RenderElement> ImageControlsRootElementMac::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    107107{
    108108    return createRenderer<RenderImageControls>(*this, WTFMove(style));

  • trunk/Source/WebCore/html/shadow/mac/ImageControlsRootElementMac.h

    r199964 r200041  
    4141    ImageControlsRootElementMac(Document&);
    4242
    43     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     43    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    4444};
    4545

  • trunk/Source/WebCore/html/track/VTTCue.cpp

    r199964 r200041  
    230230}
    231231
    232 RenderPtr<RenderElement> VTTCueBox::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     232RenderPtr<RenderElement> VTTCueBox::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    233233{
    234234    return createRenderer<RenderVTTCue>(*this, WTFMove(style));

  • trunk/Source/WebCore/html/track/VTTCue.h

    r199964 r200041  
    6565    VTTCueBox(Document&, VTTCue&);
    6666
    67     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) final;
     67    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) final;
    6868
    6969    VTTCue& m_cue;

  • trunk/Source/WebCore/mathml/MathMLInlineContainerElement.cpp

    r199964 r200041  
    7575}
    7676
    77 RenderPtr<RenderElement> MathMLInlineContainerElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     77RenderPtr<RenderElement> MathMLInlineContainerElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    7878{
    7979    if (hasTagName(annotation_xmlTag))

  • trunk/Source/WebCore/mathml/MathMLInlineContainerElement.h

    r199964 r200041  
    4444
    4545private:
    46     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     46    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    4747};
    4848   

  • trunk/Source/WebCore/mathml/MathMLMathElement.cpp

    r199964 r200041  
    4444}
    4545
    46 RenderPtr<RenderElement> MathMLMathElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     46RenderPtr<RenderElement> MathMLMathElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    4747{
    4848    return createRenderer<RenderMathMLMath>(*this, WTFMove(style));

  • trunk/Source/WebCore/mathml/MathMLMathElement.h

    r199964 r200041  
    4040    MathMLMathElement(const QualifiedName& tagName, Document&);
    4141
    42     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     42    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    4343};
    4444   

  • trunk/Source/WebCore/mathml/MathMLMencloseElement.cpp

    r199980 r200041  
    4848}
    4949
    50 RenderPtr<RenderElement> MathMLMencloseElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     50RenderPtr<RenderElement> MathMLMencloseElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    5151{   
    5252    return createRenderer<RenderMathMLMenclose>(*this, WTFMove(style));

  • trunk/Source/WebCore/mathml/MathMLMencloseElement.h

    r199980 r200041  
    5959private:
    6060    MathMLMencloseElement(const QualifiedName&, Document&);
    61     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) final;
     61    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) final;
    6262    void clearNotations() { m_notationFlags = 0; }
    6363    void addNotation(MencloseNotationFlag notationFlag) { m_notationFlags |= notationFlag; }

  • trunk/Source/WebCore/mathml/MathMLSelectElement.cpp

    r199964 r200041  
    5353}
    5454
    55 RenderPtr<RenderElement> MathMLSelectElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     55RenderPtr<RenderElement> MathMLSelectElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    5656{
    5757    return createRenderer<RenderMathMLRow>(*this, WTFMove(style));

  • trunk/Source/WebCore/mathml/MathMLSelectElement.h

    r199964 r200041  
    4141private:
    4242    MathMLSelectElement(const QualifiedName& tagName, Document&);
    43     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     43    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    4444
    4545    bool childShouldCreateRenderer(const Node&) const override;

  • trunk/Source/WebCore/mathml/MathMLTextElement.cpp

    r199964 r200041  
    7676}
    7777
    78 RenderPtr<RenderElement> MathMLTextElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition& insertionPosition)
     78RenderPtr<RenderElement> MathMLTextElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition& insertionPosition)
    7979{
    8080    if (hasTagName(MathMLNames::moTag))
    … …  
    8989    // FIXME: why do we have to set the alignment here ? It seems needed to make the
    9090    // style-changed.htmt test to pass, since mathml renders expect Stretch as default.
    91     style->setAlignItemsPosition(ItemPositionStretch);
     91    style.setAlignItemsPosition(ItemPositionStretch);
    9292
    9393    return createRenderer<RenderMathMLToken>(*this, WTFMove(style));

  • trunk/Source/WebCore/mathml/MathMLTextElement.h

    r199964 r200041  
    4343    MathMLTextElement(const QualifiedName& tagName, Document&);
    4444
    45     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     45    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    4646    bool childShouldCreateRenderer(const Node&) const override;
    4747

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

    r199964 r200041  
    38003800    else {
    38013801        if (!m_scrollCorner) {
    3802             m_scrollCorner = createRenderer<RenderScrollbarPart>(renderer->document(), WTFMove(cornerStyle));
     3802            m_scrollCorner = createRenderer<RenderScrollbarPart>(renderer->document(), WTFMove(*cornerStyle));
    38033803            m_scrollCorner->initializeStyle();
    38043804        } else
    3805             m_scrollCorner->setStyle(WTFMove(cornerStyle));
     3805            m_scrollCorner->setStyle(WTFMove(*cornerStyle));
    38063806        invalidateScrollCorner(cornerRect);
    38073807    }

  • trunk/Source/WebCore/page/animation/AnimationController.cpp

    r199964 r200041  
    426426    std::unique_ptr<RenderStyle> animatingStyle = rendererAnimations.getAnimatedStyle();
    427427    if (!animatingStyle)
    428         animatingStyle = RenderStyle::clone(&renderer.style());
     428        animatingStyle = RenderStyle::clonePtr(renderer.style());
    429429   
    430430    return animatingStyle;
    … …  
    638638{
    639639    if (!renderer.isCSSAnimating())
    640         return RenderStyle::clone(&renderer.style());
     640        return RenderStyle::clonePtr(renderer.style());
    641641    return m_data->getAnimatedStyleForRenderer(renderer);
    642642}

  • trunk/Source/WebCore/page/animation/CompositeAnimation.cpp

    r199964 r200041  
    149149                        if (CSSPropertyAnimation::animationOfPropertyIsAccelerated(prop) && implAnim->isAccelerated()) {
    150150                            if (!modifiedCurrentStyle)
    151                                 modifiedCurrentStyle = RenderStyle::clone(currentStyle);
     151                                modifiedCurrentStyle = RenderStyle::clonePtr(*currentStyle);
    152152
    153153                            implAnim->blendPropertyValueInStyle(prop, modifiedCurrentStyle.get());

  • trunk/Source/WebCore/page/animation/ImplicitAnimation.cpp

    r199964 r200041  
    4242ImplicitAnimation::ImplicitAnimation(Animation& transition, CSSPropertyID animatingProperty, RenderElement* renderer, CompositeAnimation* compAnim, RenderStyle* fromStyle)
    4343    : AnimationBase(transition, renderer, compAnim)
    44     , m_fromStyle(RenderStyle::clone(fromStyle))
     44    , m_fromStyle(RenderStyle::clonePtr(*fromStyle))
    4545    , m_transitionProperty(transition.property())
    4646    , m_animatingProperty(animatingProperty)
    … …  
    7777    // We know we will need a new render style, so make one if needed
    7878    if (!animatedStyle)
    79         animatedStyle = RenderStyle::clone(targetStyle);
     79        animatedStyle = RenderStyle::clonePtr(*targetStyle);
    8080
    8181    bool needsAnim = CSSPropertyAnimation::blendProperties(this, m_animatingProperty, animatedStyle.get(), m_fromStyle.get(), m_toStyle.get(), progress());
    … …  
    9999{
    100100    if (!animatedStyle)
    101         animatedStyle = RenderStyle::clone(m_toStyle.get());
     101        animatedStyle = RenderStyle::clonePtr(*m_toStyle);
    102102
    103103    CSSPropertyAnimation::blendProperties(this, m_animatingProperty, animatedStyle.get(), m_fromStyle.get(), m_toStyle.get(), progress());
    … …  
    171171    RefPtr<KeyframeAnimation> keyframeAnim = m_compositeAnimation->getAnimationForProperty(m_animatingProperty);
    172172    if (keyframeAnim)
    173         keyframeAnim->setUnanimatedStyle(RenderStyle::clone(m_toStyle.get()));
     173        keyframeAnim->setUnanimatedStyle(RenderStyle::clonePtr(*m_toStyle));
    174174   
    175175    sendTransitionEvent(eventNames().transitionendEvent, elapsedTime);
    … …  
    211211    ASSERT(m_fromStyle);
    212212
    213     m_toStyle = RenderStyle::clone(to);
     213    m_toStyle = RenderStyle::clonePtr(*to);
    214214
    215215    // Restart the transition

  • trunk/Source/WebCore/page/animation/KeyframeAnimation.cpp

    r199964 r200041  
    4545    : AnimationBase(animation, renderer, compositeAnimation)
    4646    , m_keyframes(animation.name())
    47     , m_unanimatedStyle(RenderStyle::clone(unanimatedStyle))
     47    , m_unanimatedStyle(RenderStyle::clonePtr(*unanimatedStyle))
    4848    , m_index(index)
    4949{
    … …  
    139139    if (postActive()) {
    140140        if (!animatedStyle)
    141             animatedStyle = RenderStyle::clone(targetStyle);
     141            animatedStyle = RenderStyle::clonePtr(*targetStyle);
    142142        return false;
    143143    }
    … …  
    162162    // We know we will need a new render style, so make one if needed.
    163163    if (!animatedStyle)
    164         animatedStyle = RenderStyle::clone(targetStyle);
     164        animatedStyle = RenderStyle::clonePtr(*targetStyle);
    165165
    166166    // FIXME: we need to be more efficient about determining which keyframes we are animating between.
    … …  
    196196
    197197    if (!animatedStyle)
    198         animatedStyle = RenderStyle::clone(&m_object->style());
     198        animatedStyle = RenderStyle::clonePtr(m_object->style());
    199199
    200200    for (auto propertyID : m_keyframes.properties()) {

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

    r199964 r200041  
    4242using namespace HTMLNames;
    4343
    44 RenderAttachment::RenderAttachment(HTMLAttachmentElement& element, std::unique_ptr<RenderStyle> style)
     44RenderAttachment::RenderAttachment(HTMLAttachmentElement& element, RenderStyle&& style)
    4545    : RenderReplaced(element, WTFMove(style), LayoutSize())
    4646{

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

    r199964 r200041  
    3737class RenderAttachment final : public RenderReplaced {
    3838public:
    39     RenderAttachment(HTMLAttachmentElement&, std::unique_ptr<RenderStyle>);
     39    RenderAttachment(HTMLAttachmentElement&, RenderStyle&&);
    4040
    4141    HTMLAttachmentElement& attachmentElement() const;

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

    r199964 r200041  
    182182};
    183183
    184 RenderBlock::RenderBlock(Element& element, std::unique_ptr<RenderStyle> style, BaseTypeFlags baseTypeFlags)
     184RenderBlock::RenderBlock(Element& element, RenderStyle&& style, BaseTypeFlags baseTypeFlags)
    185185    : RenderBox(element, WTFMove(style), baseTypeFlags | RenderBlockFlag)
    186186{
    187187}
    188188
    189 RenderBlock::RenderBlock(Document& document, std::unique_ptr<RenderStyle> style, BaseTypeFlags baseTypeFlags)
     189RenderBlock::RenderBlock(Document& document, RenderStyle&& style, BaseTypeFlags baseTypeFlags)
    190190    : RenderBox(document, WTFMove(style), baseTypeFlags | RenderBlockFlag)
    191191{
    … …  
    307307            RenderBoxModelObject* nextCont = currCont->continuation();
    308308            currCont->setContinuation(0);
    309             currCont->setStyle(RenderStyle::clone(&newStyle));
     309            currCont->setStyle(RenderStyle::clone(newStyle));
    310310            currCont->setContinuation(nextCont);
    311311        }
    … …  
    392392    } else {
    393393        RenderTreePosition insertionPosition(*parent());
    394         cloneBlock = static_pointer_cast<RenderBlock>(element()->createElementRenderer(RenderStyle::clone(&style()), insertionPosition));
     394        cloneBlock = static_pointer_cast<RenderBlock>(element()->createElementRenderer(RenderStyle::clone(style()), insertionPosition));
    395395        cloneBlock->initializeStyle();
    396396
    … …  
    718718            // Cache this value as it might get changed in setStyle() call.
    719719            bool inlineChildrenBlockHasLayer = inlineChildrenBlock.hasLayer();
    720             inlineChildrenBlock.setStyle(RenderStyle::createAnonymousStyleWithDisplay(&style(), BLOCK));
     720            inlineChildrenBlock.setStyle(RenderStyle::createAnonymousStyleWithDisplay(style(), BLOCK));
    721721            removeChildInternal(inlineChildrenBlock, inlineChildrenBlockHasLayer ? NotifyChildren : DontNotifyChildren);
    722722           
    … …  
    30693069        RenderBoxModelObject* newFirstLetter;
    30703070        if (pseudoStyle.display() == INLINE)
    3071             newFirstLetter = new RenderInline(document(), RenderStyle::clone(&pseudoStyle));
     3071            newFirstLetter = new RenderInline(document(), RenderStyle::clone(pseudoStyle));
    30723072        else
    3073             newFirstLetter = new RenderBlockFlow(document(), RenderStyle::clone(&pseudoStyle));
     3073            newFirstLetter = new RenderBlockFlow(document(), RenderStyle::clone(pseudoStyle));
    30743074        newFirstLetter->initializeStyle();
    30753075
    … …  
    30973097        firstLetterContainer->addChild(firstLetter, nextSibling);
    30983098    } else
    3099         firstLetter->setStyle(RenderStyle::clone(&pseudoStyle));
     3099        firstLetter->setStyle(RenderStyle::clone(pseudoStyle));
    31003100}
    31013101
    … …  
    31063106    RenderBoxModelObject* firstLetter = nullptr;
    31073107    if (pseudoStyle.display() == INLINE)
    3108         firstLetter = new RenderInline(document(), RenderStyle::clone(&pseudoStyle));
     3108        firstLetter = new RenderInline(document(), RenderStyle::clone(pseudoStyle));
    31093109    else
    3110         firstLetter = new RenderBlockFlow(document(), RenderStyle::clone(&pseudoStyle));
     3110        firstLetter = new RenderBlockFlow(document(), RenderStyle::clone(pseudoStyle));
    31113111    firstLetter->initializeStyle();
    31123112    firstLetterContainer->addChild(firstLetter, currentTextChild);
    … …  
    37443744    RenderBlock* newBox;
    37453745    if (display == FLEX || display == INLINE_FLEX)
    3746         newBox = new RenderFlexibleBox(parent->document(), RenderStyle::createAnonymousStyleWithDisplay(&parent->style(), FLEX));
     3746        newBox = new RenderFlexibleBox(parent->document(), RenderStyle::createAnonymousStyleWithDisplay(parent->style(), FLEX));
    37473747    else
    3748         newBox = new RenderBlockFlow(parent->document(), RenderStyle::createAnonymousStyleWithDisplay(&parent->style(), BLOCK));
     3748        newBox = new RenderBlockFlow(parent->document(), RenderStyle::createAnonymousStyleWithDisplay(parent->style(), BLOCK));
    37493749
    37503750    newBox->initializeStyle();

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

    r199964 r200041  
    6262
    6363protected:
    64     RenderBlock(Element&, std::unique_ptr<RenderStyle>, BaseTypeFlags);
    65     RenderBlock(Document&, std::unique_ptr<RenderStyle>, BaseTypeFlags);
     64    RenderBlock(Element&, RenderStyle&&, BaseTypeFlags);
     65    RenderBlock(Document&, RenderStyle&&, BaseTypeFlags);
    6666    virtual ~RenderBlock();
    6767

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

    r199964 r200041  
    9595}
    9696
    97 RenderBlockFlow::RenderBlockFlow(Element& element, std::unique_ptr<RenderStyle> style)
     97RenderBlockFlow::RenderBlockFlow(Element& element, RenderStyle&& style)
    9898    : RenderBlock(element, WTFMove(style), RenderBlockFlowFlag)
    9999#if ENABLE(IOS_TEXT_AUTOSIZING)
    … …  
    105105}
    106106
    107 RenderBlockFlow::RenderBlockFlow(Document& document, std::unique_ptr<RenderStyle> style)
     107RenderBlockFlow::RenderBlockFlow(Document& document, RenderStyle&& style)
    108108    : RenderBlock(document, WTFMove(style), RenderBlockFlowFlag)
    109109#if ENABLE(IOS_TEXT_AUTOSIZING)
    … …  
    121121void RenderBlockFlow::createMultiColumnFlowThread()
    122122{
    123     RenderMultiColumnFlowThread* flowThread = new RenderMultiColumnFlowThread(document(), RenderStyle::createAnonymousStyleWithDisplay(&style(), BLOCK));
     123    RenderMultiColumnFlowThread* flowThread = new RenderMultiColumnFlowThread(document(), RenderStyle::createAnonymousStyleWithDisplay(style(), BLOCK));
    124124    flowThread->initializeStyle();
    125125    setChildrenInline(false); // Do this to avoid wrapping inline children that are just going to move into the flow thread.
    … …  
    20382038{
    20392039    for (auto* child = firstChildBox(); child && (child->isInFlowRenderFlowThread() || child->isRenderMultiColumnSet()); child = child->nextSiblingBox())
    2040         child->setStyle(RenderStyle::createAnonymousStyleWithDisplay(&style(), BLOCK));
     2040        child->setStyle(RenderStyle::createAnonymousStyleWithDisplay(style(), BLOCK));
    20412041}
    20422042

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

    r199964 r200041  
    5656class RenderBlockFlow : public RenderBlock {
    5757public:
    58     RenderBlockFlow(Element&, std::unique_ptr<RenderStyle>);
    59     RenderBlockFlow(Document&, std::unique_ptr<RenderStyle>);
     58    RenderBlockFlow(Element&, RenderStyle&&);
     59    RenderBlockFlow(Document&, RenderStyle&&);
    6060    virtual ~RenderBlockFlow();
    6161       

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

    r199964 r200041  
    119119}
    120120
    121 RenderBox::RenderBox(Element& element, std::unique_ptr<RenderStyle> style, BaseTypeFlags baseTypeFlags)
     121RenderBox::RenderBox(Element& element, RenderStyle&& style, BaseTypeFlags baseTypeFlags)
    122122    : RenderBoxModelObject(element, WTFMove(style), baseTypeFlags)
    123123    , m_minPreferredLogicalWidth(-1)
    … …  
    128128}
    129129
    130 RenderBox::RenderBox(Document& document, std::unique_ptr<RenderStyle> style, BaseTypeFlags baseTypeFlags)
     130RenderBox::RenderBox(Document& document, RenderStyle&& style, BaseTypeFlags baseTypeFlags)
    131131    : RenderBoxModelObject(document, WTFMove(style), baseTypeFlags)
    132132    , m_minPreferredLogicalWidth(-1)

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

    r199964 r200041  
    631631
    632632protected:
    633     RenderBox(Element&, std::unique_ptr<RenderStyle>, BaseTypeFlags);
    634     RenderBox(Document&, std::unique_ptr<RenderStyle>, BaseTypeFlags);
     633    RenderBox(Element&, RenderStyle&&, BaseTypeFlags);
     634    RenderBox(Document&, RenderStyle&&, BaseTypeFlags);
    635635
    636636    void styleWillChange(StyleDifference, const RenderStyle& newStyle) override;

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

    r199964 r200041  
    162162}
    163163
    164 RenderBoxModelObject::RenderBoxModelObject(Element& element, std::unique_ptr<RenderStyle> style, BaseTypeFlags baseTypeFlags)
     164RenderBoxModelObject::RenderBoxModelObject(Element& element, RenderStyle&& style, BaseTypeFlags baseTypeFlags)
    165165    : RenderLayerModelObject(element, WTFMove(style), baseTypeFlags | RenderBoxModelObjectFlag)
    166166{
    167167}
    168168
    169 RenderBoxModelObject::RenderBoxModelObject(Document& document, std::unique_ptr<RenderStyle> style, BaseTypeFlags baseTypeFlags)
     169RenderBoxModelObject::RenderBoxModelObject(Document& document, RenderStyle&& style, BaseTypeFlags baseTypeFlags)
    170170    : RenderLayerModelObject(document, WTFMove(style), baseTypeFlags | RenderBoxModelObjectFlag)
    171171{

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

    r199964 r200041  
    239239
    240240protected:
    241     RenderBoxModelObject(Element&, std::unique_ptr<RenderStyle>, BaseTypeFlags);
    242     RenderBoxModelObject(Document&, std::unique_ptr<RenderStyle>, BaseTypeFlags);
     241    RenderBoxModelObject(Element&, RenderStyle&&, BaseTypeFlags);
     242    RenderBoxModelObject(Document&, RenderStyle&&, BaseTypeFlags);
    243243
    244244    void willBeDestroyed() override;

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

    r199964 r200041  
    3838using namespace HTMLNames;
    3939
    40 RenderButton::RenderButton(HTMLFormControlElement& element, std::unique_ptr<RenderStyle> style)
     40RenderButton::RenderButton(HTMLFormControlElement& element, RenderStyle&& style)
    4141    : RenderFlexibleBox(element, WTFMove(style))
    4242    , m_buttonText(0)

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

    r199964 r200041  
    3636class RenderButton final : public RenderFlexibleBox {
    3737public:
    38     RenderButton(HTMLFormControlElement&, std::unique_ptr<RenderStyle>);
     38    RenderButton(HTMLFormControlElement&, RenderStyle&&);
    3939    virtual ~RenderButton();
    4040

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

    r192639 r200041  
    4444    // the font doesn't change.
    4545    if (!oldStyle || oldStyle->fontCascade() != style().fontCascade())
    46         m_combineFontStyle = RenderStyle::clone(&style());
     46        m_combineFontStyle = RenderStyle::clonePtr(style());
    4747
    4848    RenderText::styleDidChange(diff, oldStyle);

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

    r199964 r200041  
    118118};
    119119
    120 RenderDeprecatedFlexibleBox::RenderDeprecatedFlexibleBox(Element& element, std::unique_ptr<RenderStyle> style)
     120RenderDeprecatedFlexibleBox::RenderDeprecatedFlexibleBox(Element& element, RenderStyle&& style)
    121121    : RenderBlock(element, WTFMove(style), 0)
    122122{

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

    r199964 r200041  
    3232class RenderDeprecatedFlexibleBox final : public RenderBlock {
    3333public:
    34     RenderDeprecatedFlexibleBox(Element&, std::unique_ptr<RenderStyle>);
     34    RenderDeprecatedFlexibleBox(Element&, RenderStyle&&);
    3535    virtual ~RenderDeprecatedFlexibleBox();
    3636

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

    r199964 r200041  
    3434using namespace HTMLNames;
    3535
    36 RenderDetailsMarker::RenderDetailsMarker(DetailsMarkerControl& element, std::unique_ptr<RenderStyle> style)
     36RenderDetailsMarker::RenderDetailsMarker(DetailsMarkerControl& element, RenderStyle&& style)
    3737    : RenderBlockFlow(element, WTFMove(style))
    3838{

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

    r199964 r200041  
    3030class RenderDetailsMarker final : public RenderBlockFlow {
    3131public:
    32     RenderDetailsMarker(DetailsMarkerControl&, std::unique_ptr<RenderStyle>);
     32    RenderDetailsMarker(DetailsMarkerControl&, RenderStyle&&);
    3333    DetailsMarkerControl& element() const { return static_cast<DetailsMarkerControl&>(nodeForNonAnonymous()); }
    3434

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

    r200031 r200041  
    8383}
    8484
    85 inline RenderElement::RenderElement(ContainerNode& elementOrDocument, std::unique_ptr<RenderStyle> style, BaseTypeFlags baseTypeFlags)
     85inline RenderElement::RenderElement(ContainerNode& elementOrDocument, RenderStyle&& style, BaseTypeFlags baseTypeFlags)
    8686    : RenderObject(elementOrDocument)
    8787    , m_baseTypeFlags(baseTypeFlags)
    … …  
    105105}
    106106
    107 RenderElement::RenderElement(Element& element, std::unique_ptr<RenderStyle> style, BaseTypeFlags baseTypeFlags)
     107RenderElement::RenderElement(Element& element, RenderStyle&& style, BaseTypeFlags baseTypeFlags)
    108108    : RenderElement(static_cast<ContainerNode&>(element), WTFMove(style), baseTypeFlags)
    109109{
    110110}
    111111
    112 RenderElement::RenderElement(Document& document, std::unique_ptr<RenderStyle> style, BaseTypeFlags baseTypeFlags)
     112RenderElement::RenderElement(Document& document, RenderStyle&& style, BaseTypeFlags baseTypeFlags)
    113113    : RenderElement(static_cast<ContainerNode&>(document), WTFMove(style), baseTypeFlags)
    114114{
    … …  
    118118{
    119119    if (hasInitializedStyle()) {
    120         for (const FillLayer* bgLayer = m_style->backgroundLayers(); bgLayer; bgLayer = bgLayer->next()) {
     120        for (const FillLayer* bgLayer = m_style.backgroundLayers(); bgLayer; bgLayer = bgLayer->next()) {
    121121            if (StyleImage* backgroundImage = bgLayer->image())
    122122                backgroundImage->removeClient(this);
    123123        }
    124124
    125         for (const FillLayer* maskLayer = m_style->maskLayers(); maskLayer; maskLayer = maskLayer->next()) {
     125        for (const FillLayer* maskLayer = m_style.maskLayers(); maskLayer; maskLayer = maskLayer->next()) {
    126126            if (StyleImage* maskImage = maskLayer->image())
    127127                maskImage->removeClient(this);
    128128        }
    129129
    130         if (StyleImage* borderImage = m_style->borderImage().image())
     130        if (StyleImage* borderImage = m_style.borderImage().image())
    131131            borderImage->removeClient(this);
    132132
    133         if (StyleImage* maskBoxImage = m_style->maskBoxImage().image())
     133        if (StyleImage* maskBoxImage = m_style.maskBoxImage().image())
    134134            maskBoxImage->removeClient(this);
    135135
    136136#if ENABLE(CSS_SHAPES)
    137         if (auto shapeValue = m_style->shapeOutside()) {
     137        if (auto shapeValue = m_style.shapeOutside()) {
    138138            if (auto shapeImage = shapeValue->image())
    139139                shapeImage->removeClient(this);
    … …  
    147147}
    148148
    149 RenderPtr<RenderElement> RenderElement::createFor(Element& element, std::unique_ptr<RenderStyle> style)
     149RenderPtr<RenderElement> RenderElement::createFor(Element& element, RenderStyle&& style)
    150150{
    151151    // Minimal support for content properties replacing an entire element.
    152152    // Works only if we have exactly one piece of content and it's a URL.
    153153    // Otherwise acts as if we didn't support this feature.
    154     const ContentData* contentData = style->contentData();
     154    const ContentData* contentData = style.contentData();
    155155    if (contentData && !contentData->next() && is<ImageContentData>(*contentData) && !element.isPseudoElement()) {
    156156        auto& styleImage = downcast<ImageContentData>(*contentData).image();
    … …  
    160160    }
    161161
    162     switch (style->display()) {
     162    switch (style.display()) {
    163163    case NONE:
    164164    case CONTENTS:
    … …  
    376376    m_hasInitializedStyle = true;
    377377
    378     updateFillImages(nullptr, m_style->backgroundLayers());
    379     updateFillImages(nullptr, m_style->maskLayers());
    380 
    381     updateImage(nullptr, m_style->borderImage().image());
    382     updateImage(nullptr, m_style->maskBoxImage().image());
     378    updateFillImages(nullptr, m_style.backgroundLayers());
     379    updateFillImages(nullptr, m_style.maskLayers());
     380
     381    updateImage(nullptr, m_style.borderImage().image());
     382    updateImage(nullptr, m_style.maskBoxImage().image());
    383383
    384384#if ENABLE(CSS_SHAPES)
    385     updateShapeImage(nullptr, m_style->shapeOutside());
     385    updateShapeImage(nullptr, m_style.shapeOutside());
    386386#endif
    387387
    … …  
    395395}
    396396
    397 void RenderElement::setStyle(std::unique_ptr<RenderStyle> style, StyleDifference minimalStyleDifference)
     397void RenderElement::setStyle(RenderStyle&& style, StyleDifference minimalStyleDifference)
    398398{
    399399    // FIXME: Should change RenderView so it can use initializeStyle too.
    … …  
    405405    unsigned contextSensitiveProperties = ContextSensitivePropertyNone;
    406406    if (m_hasInitializedStyle)
    407         diff = m_style->diff(*style, contextSensitiveProperties);
     407        diff = m_style.diff(style, contextSensitiveProperties);
    408408
    409409    diff = std::max(diff, minimalStyleDifference);
    … …  
    411411    diff = adjustStyleDifference(diff, contextSensitiveProperties);
    412412
    413     styleWillChange(diff, *style);
     413    styleWillChange(diff, style);
    414414
    415415    auto oldStyle = WTFMove(m_style);
    416416    m_style = WTFMove(style);
    417417
    418     updateFillImages(oldStyle->backgroundLayers(), m_style->backgroundLayers());
    419     updateFillImages(oldStyle->maskLayers(), m_style->maskLayers());
    420 
    421     updateImage(oldStyle->borderImage().image(), m_style->borderImage().image());
    422     updateImage(oldStyle->maskBoxImage().image(), m_style->maskBoxImage().image());
     418    updateFillImages(oldStyle.backgroundLayers(), m_style.backgroundLayers());
     419    updateFillImages(oldStyle.maskLayers(), m_style.maskLayers());
     420
     421    updateImage(oldStyle.borderImage().image(), m_style.borderImage().image());
     422    updateImage(oldStyle.maskBoxImage().image(), m_style.maskBoxImage().image());
    423423
    424424#if ENABLE(CSS_SHAPES)
    425     updateShapeImage(oldStyle->shapeOutside(), m_style->shapeOutside());
     425    updateShapeImage(oldStyle.shapeOutside(), m_style.shapeOutside());
    426426#endif
    427427
    428428    bool doesNotNeedLayout = !parent();
    429429
    430     styleDidChange(diff, oldStyle.get());
     430    styleDidChange(diff, &oldStyle);
    431431
    432432    // Text renderers use their parent style. Notify them about the change.
    433433    for (auto& child : childrenOfType<RenderText>(*this))
    434         child.styleDidChange(diff, oldStyle.get());
     434        child.styleDidChange(diff, &oldStyle);
    435435
    436436    // FIXME: |this| might be destroyed here. This can currently happen for a RenderTextFragment when
    … …  
    449449            setNeedsLayoutAndPrefWidthsRecalc();
    450450        else if (updatedDiff == StyleDifferenceLayoutPositionedMovementOnly)
    451             setNeedsPositionedMovementLayout(oldStyle.get());
     451            setNeedsPositionedMovementLayout(&oldStyle);
    452452        else if (updatedDiff == StyleDifferenceSimplifiedLayoutAndPositionedMovement) {
    453             setNeedsPositionedMovementLayout(oldStyle.get());
     453            setNeedsPositionedMovementLayout(&oldStyle);
    454454            setNeedsSimplifiedNormalFlowLayout();
    455455        } else if (updatedDiff == StyleDifferenceSimplifiedLayout)
    … …  
    783783            continue;
    784784
    785         auto newStyle = RenderStyle::createAnonymousStyleWithDisplay(&style(), elementChild.style().display());
     785        auto newStyle = RenderStyle::createAnonymousStyleWithDisplay(style(), elementChild.style().display());
    786786        if (style().specifiesColumns()) {
    787787            if (elementChild.style().specifiesColumns())
    788                 newStyle->inheritColumnPropertiesFrom(&style());
     788                newStyle.inheritColumnPropertiesFrom(&style());
    789789            if (elementChild.style().columnSpan())
    790                 newStyle->setColumnSpan(ColumnSpanAll);
     790                newStyle.setColumnSpan(ColumnSpanAll);
    791791        }
    792792
    … …  
    794794        // they contain block descendants of relative or sticky positioned inlines.
    795795        if (elementChild.isInFlowPositioned() && downcast<RenderBlock>(elementChild).isAnonymousBlockContinuation())
    796             newStyle->setPosition(elementChild.style().position());
     796            newStyle.setPosition(elementChild.style().position());
    797797
    798798        elementChild.setStyle(WTFMove(newStyle));
    … …  
    811811        // If our z-index changes value or our visibility changes,
    812812        // we need to dirty our stacking context's z-order list.
    813         bool visibilityChanged = m_style->visibility() != newStyle.visibility()
    814             || m_style->zIndex() != newStyle.zIndex()
    815             || m_style->hasAutoZIndex() != newStyle.hasAutoZIndex();
     813        bool visibilityChanged = m_style.visibility() != newStyle.visibility()
     814            || m_style.zIndex() != newStyle.zIndex()
     815            || m_style.hasAutoZIndex() != newStyle.hasAutoZIndex();
    816816#if ENABLE(DASHBOARD_SUPPORT)
    817817        if (visibilityChanged)
    … …  
    828828
    829829        // Keep layer hierarchy visibility bits up to date if visibility changes.
    830         if (m_style->visibility() != newStyle.visibility()) {
     830        if (m_style.visibility() != newStyle.visibility()) {
    831831            if (RenderLayer* layer = enclosingLayer()) {
    832832                if (newStyle.visibility() == VISIBLE)
    … …  
    840840        }
    841841
    842         if (m_parent && (newStyle.outlineSize() < m_style->outlineSize() || shouldRepaintForStyleDifference(diff)))
     842        if (m_parent && (newStyle.outlineSize() < m_style.outlineSize() || shouldRepaintForStyleDifference(diff)))
    843843            repaint();
    844         if (isFloating() && (m_style->floating() != newStyle.floating()))
     844        if (isFloating() && m_style.floating() != newStyle.floating()) {
    845845            // For changes in float styles, we need to conceivably remove ourselves
    846846            // from the floating objects list.
    847847            downcast<RenderBox>(*this).removeFloatingOrPositionedChildFromBlockLists();
    848         else if (isOutOfFlowPositioned() && (m_style->position() != newStyle.position()))
     848        } else if (isOutOfFlowPositioned() && m_style.position() != newStyle.position()) {
    849849            // For changes in positioning styles, we need to conceivably remove ourselves
    850850            // from the positioned objects list.
    851851            downcast<RenderBox>(*this).removeFloatingOrPositionedChildFromBlockLists();
     852        }
    852853
    853854        s_affectsParentBlock = isFloatingOrOutOfFlowPositioned()
    … …  
    874875
    875876    bool newStyleUsesFixedBackgrounds = newStyle.hasFixedBackgroundImage();
    876     bool oldStyleUsesFixedBackgrounds = m_style->hasFixedBackgroundImage();
     877    bool oldStyleUsesFixedBackgrounds = m_style.hasFixedBackgroundImage();
    877878    if (newStyleUsesFixedBackgrounds || oldStyleUsesFixedBackgrounds) {
    878879        bool repaintFixedBackgroundsOnScroll = !frame().settings().fixedBackgroundsPaintRelativeToDocument();
    … …  
    886887                    newStyleSlowScroll = false;
    887888
    888                 if (oldStyleSlowScroll && m_style->hasEntirelyFixedBackground())
     889                if (oldStyleSlowScroll && m_style.hasEntirelyFixedBackground())
    889890                    oldStyleSlowScroll = false;
    890891            }
    … …  
    981982   
    982983    if (diff == StyleDifferenceLayout || diff == StyleDifferenceSimplifiedLayout) {
    983         RenderCounter::rendererStyleChanged(*this, oldStyle, m_style.get());
     984        RenderCounter::rendererStyleChanged(*this, oldStyle, &m_style);
    984985
    985986        // If the object already needs layout, then setNeedsLayout won't do
    … …  
    988989        // directly affect the containing block of this object is a change to
    989990        // the position style.
    990         if (needsLayout() && oldStyle->position() != m_style->position())
     991        if (needsLayout() && oldStyle->position() != m_style.position())
    991992            markContainingBlocksForLayout();
    992993
    … …  
    10561057    }
    10571058
    1058     if (m_style->hasFixedBackgroundImage() && !frame().settings().fixedBackgroundsPaintRelativeToDocument())
     1059    if (m_style.hasFixedBackgroundImage() && !frame().settings().fixedBackgroundsPaintRelativeToDocument())
    10591060        view().frameView().removeSlowRepaintObject(this);
    10601061

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

    r199964 r200041  
    3737    virtual ~RenderElement();
    3838
    39     static RenderPtr<RenderElement> createFor(Element&, std::unique_ptr<RenderStyle>);
     39    static RenderPtr<RenderElement> createFor(Element&, RenderStyle&&);
    4040
    4141    bool hasInitializedStyle() const { return m_hasInitializedStyle; }
    4242
    43     RenderStyle& style() const { return const_cast<RenderStyle&>(*m_style); }
     43    RenderStyle& style() const { return const_cast<RenderStyle&>(m_style); }
    4444    RenderStyle& firstLineStyle() const;
    4545
    … …  
    4949    // out-of-band state (e.g. animations) requires that styleDidChange processing
    5050    // continue even if the style isn't different from the current style.
    51     void setStyle(std::unique_ptr<RenderStyle>, StyleDifference minimalStyleDifference = StyleDifferenceEqual);
     51    void setStyle(RenderStyle&&, StyleDifference minimalStyleDifference = StyleDifferenceEqual);
    5252
    5353    // The pseudo element style can be cached or uncached.  Use the cached method if the pseudo element doesn't respect
    … …  
    137137    // Updates only the local style ptr of the object. Does not update the state of the object,
    138138    // and so only should be called when the style is known not to have changed (or from setStyle).
    139     void setStyleInternal(std::unique_ptr<RenderStyle> style) { m_style = WTFMove(style); }
     139    void setStyleInternal(RenderStyle&& style) { m_style = WTFMove(style); }
    140140
    141141    // Repaint only if our old bounds and new bounds are different. The caller may pass in newBounds and newOutlineBox if they are known.
    … …  
    224224    typedef unsigned BaseTypeFlags;
    225225
    226     RenderElement(Element&, std::unique_ptr<RenderStyle>, BaseTypeFlags);
    227     RenderElement(Document&, std::unique_ptr<RenderStyle>, BaseTypeFlags);
     226    RenderElement(Element&, RenderStyle&&, BaseTypeFlags);
     227    RenderElement(Document&, RenderStyle&&, BaseTypeFlags);
    228228
    229229    bool layerCreationAllowedForSubtree() const;
    … …  
    273273
    274274private:
    275     RenderElement(ContainerNode&, std::unique_ptr<RenderStyle>, BaseTypeFlags);
     275    RenderElement(ContainerNode&, RenderStyle&&, BaseTypeFlags);
    276276    void node() const = delete;
    277277    void nonPseudoNode() const = delete;
    … …  
    333333    RenderObject* m_lastChild;
    334334
    335     std::unique_ptr<RenderStyle> m_style;
     335    RenderStyle m_style;
    336336
    337337    // FIXME: Get rid of this hack.

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

    r199964 r200041  
    9797}
    9898
    99 RenderEmbeddedObject::RenderEmbeddedObject(HTMLFrameOwnerElement& element, std::unique_ptr<RenderStyle> style)
     99RenderEmbeddedObject::RenderEmbeddedObject(HTMLFrameOwnerElement& element, RenderStyle&& style)
    100100    : RenderWidget(element, WTFMove(style))
    101101    , m_isPluginUnavailable(false)
    … …  
    112112}
    113113
    114 RenderPtr<RenderEmbeddedObject> RenderEmbeddedObject::createForApplet(HTMLAppletElement& applet, std::unique_ptr<RenderStyle> style)
     114RenderPtr<RenderEmbeddedObject> RenderEmbeddedObject::createForApplet(HTMLAppletElement& applet, RenderStyle&& style)
    115115{
    116116    auto renderer = createRenderer<RenderEmbeddedObject>(applet, WTFMove(style));

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

    r199964 r200041  
    3636class RenderEmbeddedObject : public RenderWidget {
    3737public:
    38     RenderEmbeddedObject(HTMLFrameOwnerElement&, std::unique_ptr<RenderStyle>);
     38    RenderEmbeddedObject(HTMLFrameOwnerElement&, RenderStyle&&);
    3939    virtual ~RenderEmbeddedObject();
    4040
    41     static RenderPtr<RenderEmbeddedObject> createForApplet(HTMLAppletElement&, std::unique_ptr<RenderStyle>);
     41    static RenderPtr<RenderEmbeddedObject> createForApplet(HTMLAppletElement&, RenderStyle&&);
    4242
    4343    enum PluginUnavailabilityReason {

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

    r199964 r200041  
    3535using namespace HTMLNames;
    3636
    37 RenderFieldset::RenderFieldset(HTMLFieldSetElement& element, std::unique_ptr<RenderStyle> style)
     37RenderFieldset::RenderFieldset(HTMLFieldSetElement& element, RenderStyle&& style)
    3838    : RenderBlockFlow(element, WTFMove(style))
    3939{

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

    r199964 r200041  
    3434class RenderFieldset final : public RenderBlockFlow {
    3535public:
    36     RenderFieldset(HTMLFieldSetElement&, std::unique_ptr<RenderStyle>);
     36    RenderFieldset(HTMLFieldSetElement&, RenderStyle&&);
    3737
    3838    enum FindLegendOption { IgnoreFloatingOrOutOfFlow, IncludeFloatingOrOutOfFlow };

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

    r199964 r200041  
    5959const int buttonShadowHeight = 2;
    6060
    61 RenderFileUploadControl::RenderFileUploadControl(HTMLInputElement& input, std::unique_ptr<RenderStyle> style)
     61RenderFileUploadControl::RenderFileUploadControl(HTMLInputElement& input, RenderStyle&& style)
    6262    : RenderBlockFlow(input, WTFMove(style))
    6363    , m_canReceiveDroppedFiles(input.canReceiveDroppedFiles())

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

    r199964 r200041  
    3434class RenderFileUploadControl final : public RenderBlockFlow {
    3535public:
    36     RenderFileUploadControl(HTMLInputElement&, std::unique_ptr<RenderStyle>);
     36    RenderFileUploadControl(HTMLInputElement&, RenderStyle&&);
    3737    virtual ~RenderFileUploadControl();
    3838

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

    r199964 r200041  
    6767
    6868
    69 RenderFlexibleBox::RenderFlexibleBox(Element& element, std::unique_ptr<RenderStyle> style)
     69RenderFlexibleBox::RenderFlexibleBox(Element& element, RenderStyle&& style)
    7070    : RenderBlock(element, WTFMove(style), 0)
    7171    , m_orderIterator(*this)
    … …  
    7575}
    7676
    77 RenderFlexibleBox::RenderFlexibleBox(Document& document, std::unique_ptr<RenderStyle> style)
     77RenderFlexibleBox::RenderFlexibleBox(Document& document, RenderStyle&& style)
    7878    : RenderBlock(document, WTFMove(style), 0)
    7979    , m_orderIterator(*this)

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

    r199964 r200041  
    3939class RenderFlexibleBox : public RenderBlock {
    4040public:
    41     RenderFlexibleBox(Element&, std::unique_ptr<RenderStyle>);
    42     RenderFlexibleBox(Document&, std::unique_ptr<RenderStyle>);
     41    RenderFlexibleBox(Element&, RenderStyle&&);
     42    RenderFlexibleBox(Document&, RenderStyle&&);
    4343    virtual ~RenderFlexibleBox();
    4444

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

    r199964 r200041  
    5353namespace WebCore {
    5454
    55 RenderFlowThread::RenderFlowThread(Document& document, std::unique_ptr<RenderStyle> style)
     55RenderFlowThread::RenderFlowThread(Document& document, RenderStyle&& style)
    5656    : RenderBlockFlow(document, WTFMove(style))
    5757    , m_previousRegionCount(0)
    … …  
    7070}
    7171
    72 std::unique_ptr<RenderStyle> RenderFlowThread::createFlowThreadStyle(RenderStyle* parentStyle)
     72RenderStyle RenderFlowThread::createFlowThreadStyle(RenderStyle* parentStyle)
    7373{
    7474    auto newStyle = RenderStyle::create();
    75     newStyle->inheritFrom(parentStyle);
    76     newStyle->setDisplay(BLOCK);
    77     newStyle->setPosition(AbsolutePosition);
    78     newStyle->setZIndex(0);
    79     newStyle->setLeft(Length(0, Fixed));
    80     newStyle->setTop(Length(0, Fixed));
    81     newStyle->setWidth(Length(100, Percent));
    82     newStyle->setHeight(Length(100, Percent));
    83     newStyle->fontCascade().update(nullptr);
     75    newStyle.inheritFrom(parentStyle);
     76    newStyle.setDisplay(BLOCK);
     77    newStyle.setPosition(AbsolutePosition);
     78    newStyle.setZIndex(0);
     79    newStyle.setLeft(Length(0, Fixed));
     80    newStyle.setTop(Length(0, Fixed));
     81    newStyle.setWidth(Length(100, Percent));
     82    newStyle.setHeight(Length(100, Percent));
     83    newStyle.fontCascade().update(nullptr);
    8484    return newStyle;
    8585}

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

    r199964 r200041  
    100100    virtual void flowThreadDescendantBoxLaidOut(RenderBox*) { }
    101101
    102     static std::unique_ptr<RenderStyle> createFlowThreadStyle(RenderStyle* parentStyle);
     102    static RenderStyle createFlowThreadStyle(RenderStyle* parentStyle);
    103103
    104104    void styleDidChange(StyleDifference, const RenderStyle* oldStyle) override;
    … …  
    241241
    242242protected:
    243     RenderFlowThread(Document&, std::unique_ptr<RenderStyle>);
     243    RenderFlowThread(Document&, RenderStyle&&);
    244244
    245245    RenderFlowThread* locateFlowThreadContainingBlock() const override { return const_cast<RenderFlowThread*>(this); }

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

    r199964 r200041  
    2929namespace WebCore {
    3030
    31 RenderFrame::RenderFrame(HTMLFrameElement& frame, std::unique_ptr<RenderStyle> style)
     31RenderFrame::RenderFrame(HTMLFrameElement& frame, RenderStyle&& style)
    3232    : RenderFrameBase(frame, WTFMove(style))
    3333{

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

    r199964 r200041  
    3333class RenderFrame final : public RenderFrameBase {
    3434public:
    35     RenderFrame(HTMLFrameElement&, std::unique_ptr<RenderStyle>);
     35    RenderFrame(HTMLFrameElement&, RenderStyle&&);
    3636
    3737    HTMLFrameElement& frameElement() const;

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

    r199964 r200041  
    3434namespace WebCore {
    3535
    36 RenderFrameBase::RenderFrameBase(HTMLFrameElementBase& element, std::unique_ptr<RenderStyle> style)
     36RenderFrameBase::RenderFrameBase(HTMLFrameElementBase& element, RenderStyle&& style)
    3737    : RenderWidget(element, WTFMove(style))
    3838{

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

    r199964 r200041  
    3838class RenderFrameBase : public RenderWidget {
    3939protected:
    40     RenderFrameBase(HTMLFrameElementBase&, std::unique_ptr<RenderStyle>);
     40    RenderFrameBase(HTMLFrameElementBase&, RenderStyle&&);
    4141
    4242public:

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

    r199964 r200041  
    4646namespace WebCore {
    4747
    48 RenderFrameSet::RenderFrameSet(HTMLFrameSetElement& frameSet, std::unique_ptr<RenderStyle> style)
     48RenderFrameSet::RenderFrameSet(HTMLFrameSetElement& frameSet, RenderStyle&& style)
    4949    : RenderBox(frameSet, WTFMove(style), 0)
    5050    , m_isResizing(false)

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

    r199964 r200041  
    5656class RenderFrameSet final : public RenderBox {
    5757public:
    58     RenderFrameSet(HTMLFrameSetElement&, std::unique_ptr<RenderStyle>);
     58    RenderFrameSet(HTMLFrameSetElement&, RenderStyle&&);
    5959    virtual ~RenderFrameSet();
    6060

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

    r199964 r200041  
    3737class RenderFullScreenPlaceholder final : public RenderBlockFlow {
    3838public:
    39     RenderFullScreenPlaceholder(RenderFullScreen& owner, std::unique_ptr<RenderStyle> style)
     39    RenderFullScreenPlaceholder(RenderFullScreen& owner, RenderStyle&& style)
    4040        : RenderBlockFlow(owner.document(), WTFMove(style))
    4141        , m_owner(owner)
    … …  
    5555}
    5656
    57 RenderFullScreen::RenderFullScreen(Document& document, std::unique_ptr<RenderStyle> style)
     57RenderFullScreen::RenderFullScreen(Document& document, RenderStyle&& style)
    5858    : RenderFlexibleBox(document, WTFMove(style))
    5959    , m_placeholder(0)
    … …  
    7979}
    8080
    81 static std::unique_ptr<RenderStyle> createFullScreenStyle()
    82 {
    83     auto fullscreenStyle = RenderStyle::createDefaultStyle();
     81static RenderStyle createFullScreenStyle()
     82{
     83    auto fullscreenStyle = RenderStyle::create();
    8484
    8585    // Create a stacking context:
    86     fullscreenStyle->setZIndex(INT_MAX);
    87 
    88     fullscreenStyle->setFontDescription({ });
    89     fullscreenStyle->fontCascade().update(nullptr);
    90 
    91     fullscreenStyle->setDisplay(FLEX);
    92     fullscreenStyle->setJustifyContentPosition(ContentPositionCenter);
    93     fullscreenStyle->setAlignItemsPosition(ItemPositionCenter);
    94     fullscreenStyle->setFlexDirection(FlowColumn);
     86    fullscreenStyle.setZIndex(INT_MAX);
     87
     88    fullscreenStyle.setFontDescription({ });
     89    fullscreenStyle.fontCascade().update(nullptr);
     90
     91    fullscreenStyle.setDisplay(FLEX);
     92    fullscreenStyle.setJustifyContentPosition(ContentPositionCenter);
     93    fullscreenStyle.setAlignItemsPosition(ItemPositionCenter);
     94    fullscreenStyle.setFlexDirection(FlowColumn);
    9595   
    96     fullscreenStyle->setPosition(FixedPosition);
    97     fullscreenStyle->setWidth(Length(100.0, Percent));
    98     fullscreenStyle->setHeight(Length(100.0, Percent));
    99     fullscreenStyle->setLeft(Length(0, WebCore::Fixed));
    100     fullscreenStyle->setTop(Length(0, WebCore::Fixed));
     96    fullscreenStyle.setPosition(FixedPosition);
     97    fullscreenStyle.setWidth(Length(100.0, Percent));
     98    fullscreenStyle.setHeight(Length(100.0, Percent));
     99    fullscreenStyle.setLeft(Length(0, WebCore::Fixed));
     100    fullscreenStyle.setTop(Length(0, WebCore::Fixed));
    101101   
    102     fullscreenStyle->setBackgroundColor(Color::black);
     102    fullscreenStyle.setBackgroundColor(Color::black);
    103103
    104104    return fullscreenStyle;
    … …  
    194194
    195195    if (m_placeholder) {
    196         m_placeholder->setStyle(WTFMove(style));
     196        m_placeholder->setStyle(WTFMove(*style));
    197197        return;
    198198    }
    199199
    200     m_placeholder = new RenderFullScreenPlaceholder(*this, WTFMove(style));
     200    m_placeholder = new RenderFullScreenPlaceholder(*this, WTFMove(*style));
    201201    m_placeholder->initializeStyle();
    202202    if (parent()) {

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

    r199964 r200041  
    3535class RenderFullScreen final : public RenderFlexibleBox {
    3636public:
    37     RenderFullScreen(Document&, std::unique_ptr<RenderStyle>);
     37    RenderFullScreen(Document&, RenderStyle&&);
    3838
    3939    const char* renderName() const override { return "RenderFullScreen"; }

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

    r199981 r200041  
    246246}
    247247
    248 RenderGrid::RenderGrid(Element& element, std::unique_ptr<RenderStyle> style)
     248RenderGrid::RenderGrid(Element& element, RenderStyle&& style)
    249249    : RenderBlock(element, WTFMove(style), 0)
    250250    , m_orderIterator(*this)

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

    r199981 r200041  
    4747class RenderGrid final : public RenderBlock {
    4848public:
    49     RenderGrid(Element&, std::unique_ptr<RenderStyle>);
     49    RenderGrid(Element&, RenderStyle&&);
    5050    virtual ~RenderGrid();
    5151

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

    r199964 r200041  
    4343using namespace HTMLNames;
    4444
    45 RenderHTMLCanvas::RenderHTMLCanvas(HTMLCanvasElement& element, std::unique_ptr<RenderStyle> style)
     45RenderHTMLCanvas::RenderHTMLCanvas(HTMLCanvasElement& element, RenderStyle&& style)
    4646    : RenderReplaced(element, WTFMove(style), element.size())
    4747{

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

    r199964 r200041  
    3535class RenderHTMLCanvas final : public RenderReplaced {
    3636public:
    37     RenderHTMLCanvas(HTMLCanvasElement&, std::unique_ptr<RenderStyle>);
     37    RenderHTMLCanvas(HTMLCanvasElement&, RenderStyle&&);
    3838
    3939    HTMLCanvasElement& canvasElement() const;

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

    r199964 r200041  
    4040using namespace HTMLNames;
    4141   
    42 RenderIFrame::RenderIFrame(HTMLIFrameElement& element, std::unique_ptr<RenderStyle> style)
     42RenderIFrame::RenderIFrame(HTMLIFrameElement& element, RenderStyle&& style)
    4343    : RenderFrameBase(element, WTFMove(style))
    4444{

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

    r199964 r200041  
    3535class RenderIFrame final : public RenderFrameBase {
    3636public:
    37     RenderIFrame(HTMLIFrameElement&, std::unique_ptr<RenderStyle>);
     37    RenderIFrame(HTMLIFrameElement&, RenderStyle&&);
    3838
    3939    HTMLIFrameElement& iframeElement() const;

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

    r199964 r200041  
    120120using namespace HTMLNames;
    121121
    122 RenderImage::RenderImage(Element& element, std::unique_ptr<RenderStyle> style, StyleImage* styleImage, const float imageDevicePixelRatio)
     122RenderImage::RenderImage(Element& element, RenderStyle&& style, StyleImage* styleImage, const float imageDevicePixelRatio)
    123123    : RenderReplaced(element, WTFMove(style), IntSize())
    124124    , m_imageResource(styleImage ? std::make_unique<RenderImageResourceStyleImage>(*styleImage) : std::make_unique<RenderImageResource>())
    … …  
    136136}
    137137
    138 RenderImage::RenderImage(Document& document, std::unique_ptr<RenderStyle> style, StyleImage* styleImage)
     138RenderImage::RenderImage(Document& document, RenderStyle&& style, StyleImage* styleImage)
    139139    : RenderReplaced(document, WTFMove(style), IntSize())
    140140    , m_imageResource(styleImage ? std::make_unique<RenderImageResourceStyleImage>(*styleImage) : std::make_unique<RenderImageResource>())

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

    r199964 r200041  
    4141class RenderImage : public RenderReplaced {
    4242public:
    43     RenderImage(Element&, std::unique_ptr<RenderStyle>, StyleImage* = nullptr, const float = 1.0f);
    44     RenderImage(Document&, std::unique_ptr<RenderStyle>, StyleImage* = nullptr);
     43    RenderImage(Element&, RenderStyle&&, StyleImage* = nullptr, const float = 1.0f);
     44    RenderImage(Document&, RenderStyle&&, StyleImage* = nullptr);
    4545    virtual ~RenderImage();
    4646

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

    r199964 r200041  
    5353namespace WebCore {
    5454
    55 RenderInline::RenderInline(Element& element, std::unique_ptr<RenderStyle> style)
     55RenderInline::RenderInline(Element& element, RenderStyle&& style)
    5656    : RenderBoxModelObject(element, WTFMove(style), RenderInlineFlag)
    5757{
    … …  
    5959}
    6060
    61 RenderInline::RenderInline(Document& document, std::unique_ptr<RenderStyle> style)
     61RenderInline::RenderInline(Document& document, RenderStyle&& style)
    6262    : RenderBoxModelObject(document, WTFMove(style), RenderInlineFlag)
    6363{
    … …  
    159159        if (oldStyle->hasInFlowPosition() && inFlowPositionedInlineAncestor(continuation))
    160160            continue;
    161         auto blockStyle = RenderStyle::createAnonymousStyleWithDisplay(&block.style(), BLOCK);
    162         blockStyle->setPosition(newStyle->position());
     161        auto blockStyle = RenderStyle::createAnonymousStyleWithDisplay(block.style(), BLOCK);
     162        blockStyle.setPosition(newStyle->position());
    163163        block.setStyle(WTFMove(blockStyle));
    164164    }
    … …  
    194194            RenderBoxModelObject* nextCont = currCont->continuation();
    195195            currCont->setContinuation(nullptr);
    196             currCont->setStyle(RenderStyle::clone(&newStyle));
     196            currCont->setStyle(RenderStyle::clone(newStyle));
    197197            currCont->setContinuation(nextCont);
    198198        }
    … …  
    332332        // |newChild|.  We then make that block box a continuation of this inline.  We take all of
    333333        // the children after |beforeChild| and put them in a clone of this object.
    334         auto newStyle = RenderStyle::createAnonymousStyleWithDisplay(&style(), BLOCK);
     334        auto newStyle = RenderStyle::createAnonymousStyleWithDisplay(style(), BLOCK);
    335335       
    336336        // If inside an inline affected by in-flow positioning the block needs to be affected by it too.
    337337        // Giving the block a layer like this allows it to collect the x/y offsets from inline parents later.
    338338        if (auto positionedAncestor = inFlowPositionedInlineAncestor(this))
    339             newStyle->setPosition(positionedAncestor->style().position());
     339            newStyle.setPosition(positionedAncestor->style().position());
    340340
    341341        RenderBlock* newBox = new RenderBlockFlow(document(), WTFMove(newStyle));
    … …  
    398398        if (!newChild->isFloatingOrOutOfFlowPositioned()) {
    399399            // There was no suitable existing anonymous inline-block. Create a new one.
    400             RenderBlockFlow* anonymousInlineBlock = new RenderBlockFlow(document(), RenderStyle::createAnonymousStyleWithDisplay(&style(), INLINE_BLOCK));
     400            RenderBlockFlow* anonymousInlineBlock = new RenderBlockFlow(document(), RenderStyle::createAnonymousStyleWithDisplay(style(), INLINE_BLOCK));
    401401            anonymousInlineBlock->initializeStyle();
    402402   
    … …  
    414414RenderPtr<RenderInline> RenderInline::clone() const
    415415{
    416     RenderPtr<RenderInline> cloneInline = createRenderer<RenderInline>(*element(), RenderStyle::clone(&style()));
     416    RenderPtr<RenderInline> cloneInline = createRenderer<RenderInline>(*element(), RenderStyle::clone(style()));
    417417    cloneInline->initializeStyle();
    418418    cloneInline->setFlowThreadState(flowThreadState());

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

    r199964 r200041  
    3535class RenderInline : public RenderBoxModelObject {
    3636public:
    37     RenderInline(Element&, std::unique_ptr<RenderStyle>);
    38     RenderInline(Document&, std::unique_ptr<RenderStyle>);
     37    RenderInline(Element&, RenderStyle&&);
     38    RenderInline(Document&, RenderStyle&&);
    3939
    4040    void addChild(RenderObject* newChild, RenderObject* beforeChild = 0) override;

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

    r199964 r200041  
    67986798
    67996799    if (!m_scrollCorner) {
    6800         m_scrollCorner = createRenderer<RenderScrollbarPart>(renderer().document(), WTFMove(corner));
     6800        m_scrollCorner = createRenderer<RenderScrollbarPart>(renderer().document(), WTFMove(*corner));
    68016801        m_scrollCorner->setParent(&renderer());
    68026802        m_scrollCorner->initializeStyle();
    68036803    } else
    6804         m_scrollCorner->setStyle(WTFMove(corner));
     6804        m_scrollCorner->setStyle(WTFMove(*corner));
    68056805}
    68066806
    … …  
    68166816
    68176817    if (!m_resizer) {
    6818         m_resizer = createRenderer<RenderScrollbarPart>(renderer().document(), WTFMove(resizer));
     6818        m_resizer = createRenderer<RenderScrollbarPart>(renderer().document(), WTFMove(*resizer));
    68196819        m_resizer->setParent(&renderer());
    68206820        m_resizer->initializeStyle();
    68216821    } else
    6822         m_resizer->setStyle(WTFMove(resizer));
     6822        m_resizer->setStyle(WTFMove(*resizer));
    68236823}
    68246824
    … …  
    68456845}
    68466846
    6847 std::unique_ptr<RenderStyle> RenderLayer::createReflectionStyle()
     6847RenderStyle RenderLayer::createReflectionStyle()
    68486848{
    68496849    auto newStyle = RenderStyle::create();
    6850     newStyle->inheritFrom(&renderer().style());
     6850    newStyle.inheritFrom(&renderer().style());
    68516851   
    68526852    // Map in our transform.
    … …  
    68746874            break;
    68756875    }
    6876     newStyle->setTransform(transform);
     6876    newStyle.setTransform(transform);
    68776877
    68786878    // Map in our mask.
    6879     newStyle->setMaskBoxImage(renderer().style().boxReflect()->mask());
     6879    newStyle.setMaskBoxImage(renderer().style().boxReflect()->mask());
    68806880
    68816881    return newStyle;

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

    r199964 r200041  
    925925    void removeReflection();
    926926
    927     std::unique_ptr<RenderStyle> createReflectionStyle();
     927    RenderStyle createReflectionStyle();
    928928    bool paintingInsideReflection() const { return m_paintingInsideReflection; }
    929929    void setPaintingInsideReflection(bool b) { m_paintingInsideReflection = b; }

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

    r199964 r200041  
    3737bool RenderLayerModelObject::s_layerWasSelfPainting = false;
    3838
    39 RenderLayerModelObject::RenderLayerModelObject(Element& element, std::unique_ptr<RenderStyle> style, BaseTypeFlags baseTypeFlags)
     39RenderLayerModelObject::RenderLayerModelObject(Element& element, RenderStyle&& style, BaseTypeFlags baseTypeFlags)
    4040    : RenderElement(element, WTFMove(style), baseTypeFlags | RenderLayerModelObjectFlag)
    4141{
    4242}
    4343
    44 RenderLayerModelObject::RenderLayerModelObject(Document& document, std::unique_ptr<RenderStyle> style, BaseTypeFlags baseTypeFlags)
     44RenderLayerModelObject::RenderLayerModelObject(Document& document, RenderStyle&& style, BaseTypeFlags baseTypeFlags)
    4545    : RenderElement(document, WTFMove(style), baseTypeFlags | RenderLayerModelObjectFlag)
    4646{

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

    r199964 r200041  
    5353
    5454protected:
    55     RenderLayerModelObject(Element&, std::unique_ptr<RenderStyle>, BaseTypeFlags);
    56     RenderLayerModelObject(Document&, std::unique_ptr<RenderStyle>, BaseTypeFlags);
     55    RenderLayerModelObject(Element&, RenderStyle&&, BaseTypeFlags);
     56    RenderLayerModelObject(Document&, RenderStyle&&, BaseTypeFlags);
    5757
    5858    void createLayer();

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

    r199964 r200041  
    5656}
    5757
    58 RenderLineBreak::RenderLineBreak(HTMLElement& element, std::unique_ptr<RenderStyle> style)
     58RenderLineBreak::RenderLineBreak(HTMLElement& element, RenderStyle&& style)
    5959    : RenderBoxModelObject(element, WTFMove(style), 0)
    6060    , m_inlineBoxWrapper(nullptr)

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

    r199964 r200041  
    3333class RenderLineBreak final : public RenderBoxModelObject {
    3434public:
    35     RenderLineBreak(HTMLElement&, std::unique_ptr<RenderStyle>);
     35    RenderLineBreak(HTMLElement&, RenderStyle&&);
    3636    virtual ~RenderLineBreak();
    3737

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

    r199964 r200041  
    8484const int baselineAdjustment = 7;
    8585
    86 RenderListBox::RenderListBox(HTMLSelectElement& element, std::unique_ptr<RenderStyle> style)
     86RenderListBox::RenderListBox(HTMLSelectElement& element, RenderStyle&& style)
    8787    : RenderBlockFlow(element, WTFMove(style))
    8888    , m_optionsChanged(true)

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

    r199964 r200041  
    4141class RenderListBox final : public RenderBlockFlow, public ScrollableArea {
    4242public:
    43     RenderListBox(HTMLSelectElement&, std::unique_ptr<RenderStyle>);
     43    RenderListBox(HTMLSelectElement&, RenderStyle&&);
    4444    virtual ~RenderListBox();
    4545

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

    r199964 r200041  
    4545using namespace HTMLNames;
    4646
    47 RenderListItem::RenderListItem(Element& element, std::unique_ptr<RenderStyle> style)
     47RenderListItem::RenderListItem(Element& element, RenderStyle&& style)
    4848    : RenderBlockFlow(element, WTFMove(style))
    4949    , m_marker(nullptr)
    … …  
    7979    // The marker always inherits from the list item, regardless of where it might end
    8080    // up (e.g., in some deeply nested line box). See CSS3 spec.
    81     newStyle->inheritFrom(&style());
     81    newStyle.inheritFrom(&style());
    8282    if (!m_marker) {
    8383        m_marker = createRenderer<RenderListMarker>(*this, WTFMove(newStyle)).leakPtr();

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

    r199964 r200041  
    3434class RenderListItem final : public RenderBlockFlow {
    3535public:
    36     RenderListItem(Element&, std::unique_ptr<RenderStyle>);
     36    RenderListItem(Element&, RenderStyle&&);
    3737    virtual ~RenderListItem();
    3838    Element& element() const { return downcast<Element>(nodeForNonAnonymous()); }

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

    r199964 r200041  
    11181118}
    11191119
    1120 RenderListMarker::RenderListMarker(RenderListItem& listItem, std::unique_ptr<RenderStyle> style)
     1120RenderListMarker::RenderListMarker(RenderListItem& listItem, RenderStyle&& style)
    11211121    : RenderBox(listItem.document(), WTFMove(style), 0)
    11221122    , m_listItem(listItem)

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

    r199964 r200041  
    3636class RenderListMarker final : public RenderBox {
    3737public:
    38     RenderListMarker(RenderListItem&, std::unique_ptr<RenderStyle>);
     38    RenderListMarker(RenderListItem&, RenderStyle&&);
    3939    virtual ~RenderListMarker();
    4040

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

    r199964 r200041  
    3535namespace WebCore {
    3636
    37 RenderMedia::RenderMedia(HTMLMediaElement& element, std::unique_ptr<RenderStyle> style)
     37RenderMedia::RenderMedia(HTMLMediaElement& element, RenderStyle&& style)
    3838    : RenderImage(element, WTFMove(style))
    3939{
    … …  
    4141}
    4242
    43 RenderMedia::RenderMedia(HTMLMediaElement& element, std::unique_ptr<RenderStyle> style, const IntSize& intrinsicSize)
     43RenderMedia::RenderMedia(HTMLMediaElement& element, RenderStyle&& style, const IntSize& intrinsicSize)
    4444    : RenderImage(element, WTFMove(style))
    4545{

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

    r199964 r200041  
    3636class RenderMedia : public RenderImage {
    3737public:
    38     RenderMedia(HTMLMediaElement&, std::unique_ptr<RenderStyle>);
    39     RenderMedia(HTMLMediaElement&, std::unique_ptr<RenderStyle>, const IntSize& intrinsicSize);
     38    RenderMedia(HTMLMediaElement&, RenderStyle&&);
     39    RenderMedia(HTMLMediaElement&, RenderStyle&&, const IntSize& intrinsicSize);
    4040    virtual ~RenderMedia();
    4141

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

    r199964 r200041  
    3636namespace WebCore {
    3737
    38 RenderMediaVolumeSliderContainer::RenderMediaVolumeSliderContainer(Element& element, std::unique_ptr<RenderStyle> style)
     38RenderMediaVolumeSliderContainer::RenderMediaVolumeSliderContainer(Element& element, RenderStyle&& style)
    3939    : RenderBlockFlow(element, WTFMove(style))
    4040{
    … …  
    6060// ----------------------------
    6161
    62 RenderMediaControlTimelineContainer::RenderMediaControlTimelineContainer(Element& element, std::unique_ptr<RenderStyle> style)
     62RenderMediaControlTimelineContainer::RenderMediaControlTimelineContainer(Element& element, RenderStyle&& style)
    6363    : RenderFlexibleBox(element, WTFMove(style))
    6464{
    … …  
    8282#if ENABLE(VIDEO_TRACK)
    8383
    84 RenderTextTrackContainerElement::RenderTextTrackContainerElement(Element& element, std::unique_ptr<RenderStyle> style)
     84RenderTextTrackContainerElement::RenderTextTrackContainerElement(Element& element, RenderStyle&& style)
    8585    : RenderBlockFlow(element, WTFMove(style))
    8686{

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

    r199964 r200041  
    3939class RenderMediaVolumeSliderContainer final : public RenderBlockFlow {
    4040public:
    41     RenderMediaVolumeSliderContainer(Element&, std::unique_ptr<RenderStyle>);
     41    RenderMediaVolumeSliderContainer(Element&, RenderStyle&&);
    4242
    4343private:
    … …  
    4949class RenderMediaControlTimelineContainer final : public RenderFlexibleBox {
    5050public:
    51     RenderMediaControlTimelineContainer(Element&, std::unique_ptr<RenderStyle>);
     51    RenderMediaControlTimelineContainer(Element&, RenderStyle&&);
    5252
    5353private:
    … …  
    6262class RenderTextTrackContainerElement final : public RenderBlockFlow {
    6363public:
    64     RenderTextTrackContainerElement(Element&, std::unique_ptr<RenderStyle>);
     64    RenderTextTrackContainerElement(Element&, RenderStyle&&);
    6565
    6666private:

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

    r199964 r200041  
    7171#endif
    7272
    73 RenderMenuList::RenderMenuList(HTMLSelectElement& element, std::unique_ptr<RenderStyle> style)
     73RenderMenuList::RenderMenuList(HTMLSelectElement& element, RenderStyle&& style)
    7474    : RenderFlexibleBox(element, WTFMove(style))
    7575    , m_buttonText(nullptr)
    … …  
    267267            text = downcast<HTMLOptionElement>(*element).textIndentedToRespectGroupLabel();
    268268            auto* style = element->computedStyle();
    269             m_optionStyle = style ? RenderStyle::clone(style) : nullptr;
     269            m_optionStyle = style ? RenderStyle::clonePtr(*style) : nullptr;
    270270        }
    271271    }

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

    r199964 r200041  
    4444
    4545public:
    46     RenderMenuList(HTMLSelectElement&, std::unique_ptr<RenderStyle>);
     46    RenderMenuList(HTMLSelectElement&, RenderStyle&&);
    4747    virtual ~RenderMenuList();
    4848

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

    r199964 r200041  
    3131using namespace HTMLNames;
    3232
    33 RenderMeter::RenderMeter(HTMLElement& element, std::unique_ptr<RenderStyle> style)
     33RenderMeter::RenderMeter(HTMLElement& element, RenderStyle&& style)
    3434    : RenderBlockFlow(element, WTFMove(style))
    3535{

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

    r199964 r200041  
    3333class RenderMeter final : public RenderBlockFlow {
    3434public:
    35     RenderMeter(HTMLElement&, std::unique_ptr<RenderStyle>);
     35    RenderMeter(HTMLElement&, RenderStyle&&);
    3636    virtual ~RenderMeter();
    3737

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

    r199964 r200041  
    3939bool RenderMultiColumnFlowThread::gShiftingSpanner = false;
    4040
    41 RenderMultiColumnFlowThread::RenderMultiColumnFlowThread(Document& document, std::unique_ptr<RenderStyle> style)
     41RenderMultiColumnFlowThread::RenderMultiColumnFlowThread(Document& document, RenderStyle&& style)
    4242    : RenderFlowThread(document, WTFMove(style))
    4343    , m_lastSetWorkedOn(nullptr)
    … …  
    339339    // another column set after a spanner. Even if it turns out that there are no renderers
    340340    // following the spanner, there may be bottom margins there, which take up space.
    341     RenderMultiColumnSet* newSet = new RenderMultiColumnSet(*this, RenderStyle::createAnonymousStyleWithDisplay(&multicolContainer->style(), BLOCK));
     341    RenderMultiColumnSet* newSet = new RenderMultiColumnSet(*this, RenderStyle::createAnonymousStyleWithDisplay(multicolContainer->style(), BLOCK));
    342342    newSet->initializeStyle();
    343343    multicolContainer->RenderBlock::addChild(newSet, insertBeforeMulticolChild);

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

    r199964 r200041  
    3939class RenderMultiColumnFlowThread final : public RenderFlowThread {
    4040public:
    41     RenderMultiColumnFlowThread(Document&, std::unique_ptr<RenderStyle>);
     41    RenderMultiColumnFlowThread(Document&, RenderStyle&&);
    4242    ~RenderMultiColumnFlowThread();
    4343

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

    r199964 r200041  
    3737namespace WebCore {
    3838
    39 RenderMultiColumnSet::RenderMultiColumnSet(RenderFlowThread& flowThread, std::unique_ptr<RenderStyle> style)
     39RenderMultiColumnSet::RenderMultiColumnSet(RenderFlowThread& flowThread, RenderStyle&& style)
    4040    : RenderRegionSet(flowThread.document(), WTFMove(style), flowThread)
    4141    , m_computedColumnCount(1)

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

    r199964 r200041  
    4747class RenderMultiColumnSet final : public RenderRegionSet {
    4848public:
    49     RenderMultiColumnSet(RenderFlowThread&, std::unique_ptr<RenderStyle>);
     49    RenderMultiColumnSet(RenderFlowThread&, RenderStyle&&);
    5050
    5151    RenderBlockFlow* multiColumnBlockFlow() const { return downcast<RenderBlockFlow>(parent()); }

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

    r199964 r200041  
    3737RenderMultiColumnSpannerPlaceholder* RenderMultiColumnSpannerPlaceholder::createAnonymous(RenderMultiColumnFlowThread* flowThread, RenderBox* spanner, RenderStyle* parentStyle)
    3838{
    39     std::unique_ptr<RenderStyle> newStyle(RenderStyle::createAnonymousStyleWithDisplay(parentStyle, BLOCK));
    40     newStyle->setClear(CBOTH); // We don't want floats in the row preceding the spanner to continue on the other side.
     39    auto newStyle = RenderStyle::createAnonymousStyleWithDisplay(*parentStyle, BLOCK);
     40    newStyle.setClear(CBOTH); // We don't want floats in the row preceding the spanner to continue on the other side.
    4141    auto placeholder = new RenderMultiColumnSpannerPlaceholder(flowThread, spanner, WTFMove(newStyle));
    4242    placeholder->initializeStyle();
    … …  
    4444}
    4545
    46 RenderMultiColumnSpannerPlaceholder::RenderMultiColumnSpannerPlaceholder(RenderMultiColumnFlowThread* flowThread, RenderBox* spanner, std::unique_ptr<RenderStyle> style)
     46RenderMultiColumnSpannerPlaceholder::RenderMultiColumnSpannerPlaceholder(RenderMultiColumnFlowThread* flowThread, RenderBox* spanner, RenderStyle&& style)
    4747    : RenderBox(flowThread->document(), WTFMove(style), RenderBoxModelObjectFlag)
    4848    , m_spanner(spanner)

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

    r199964 r200041  
    4545
    4646private:
    47     RenderMultiColumnSpannerPlaceholder(RenderMultiColumnFlowThread*, RenderBox* spanner, std::unique_ptr<RenderStyle>);
     47    RenderMultiColumnSpannerPlaceholder(RenderMultiColumnFlowThread*, RenderBox* spanner, RenderStyle&&);
    4848    bool isRenderMultiColumnSpannerPlaceholder() const override { return true; }
    4949

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

    r199964 r200041  
    4545namespace WebCore {
    4646
    47 RenderNamedFlowFragment::RenderNamedFlowFragment(Document& document, std::unique_ptr<RenderStyle> style)
     47RenderNamedFlowFragment::RenderNamedFlowFragment(Document& document, RenderStyle&& style)
    4848    : RenderRegion(document, WTFMove(style), nullptr)
    4949    , m_hasCustomRegionStyle(false)
    … …  
    5858}
    5959
    60 std::unique_ptr<RenderStyle> RenderNamedFlowFragment::createStyle(const RenderStyle& parentStyle)
    61 {
    62     auto style = RenderStyle::createAnonymousStyleWithDisplay(&parentStyle, BLOCK);
    63 
    64     style->setFlowThread(parentStyle.flowThread());
    65     style->setRegionThread(parentStyle.regionThread());
    66     style->setRegionFragment(parentStyle.regionFragment());
     60RenderStyle RenderNamedFlowFragment::createStyle(const RenderStyle& parentStyle)
     61{
     62    auto style = RenderStyle::createAnonymousStyleWithDisplay(parentStyle, BLOCK);
     63
     64    style.setFlowThread(parentStyle.flowThread());
     65    style.setRegionThread(parentStyle.regionThread());
     66    style.setRegionFragment(parentStyle.regionFragment());
    6767
    6868    return style;
    … …  
    367367        bool objectRegionStyleCached = false;
    368368        if (it != m_renderObjectRegionStyle.end()) {
    369             childStyleInRegion = RenderStyle::clone(it->value.style.get());
     369            childStyleInRegion = RenderStyle::clonePtr(*it->value.style);
    370370            objectRegionStyleCached = true;
    371371        } else {
    372372            if (child.isAnonymous() || child.isInFlowRenderFlowThread())
    373                 childStyleInRegion = RenderStyle::createAnonymousStyleWithDisplay(&renderer.style(), child.style().display());
     373                childStyleInRegion =  std::make_unique<RenderStyle>(RenderStyle::createAnonymousStyleWithDisplay(renderer.style(), child.style().display()));
    374374            else if (is<RenderText>(child))
    375                 childStyleInRegion = RenderStyle::clone(&renderer.style());
     375                childStyleInRegion = RenderStyle::clonePtr(renderer.style());
    376376            else
    377377                childStyleInRegion = computeStyleInRegion(downcast<RenderElement>(child), renderer.style());
    … …  
    389389    ASSERT(object->flowThreadContainingBlock());
    390390
    391     std::unique_ptr<RenderStyle> objectOriginalStyle = RenderStyle::clone(&object->style());
     391    std::unique_ptr<RenderStyle> objectOriginalStyle = RenderStyle::clonePtr(object->style());
    392392    if (is<RenderElement>(*object))
    393         downcast<RenderElement>(*object).setStyleInternal(WTFMove(styleInRegion));
     393        downcast<RenderElement>(*object).setStyleInternal(WTFMove(*styleInRegion));
    394394
    395395    if (is<RenderBoxModelObject>(*object) && !object->hasBoxDecorations()) {
    … …  
    444444        bool objectRegionStyleCached = false;
    445445        if (it != m_renderObjectRegionStyle.end()) {
    446             objectStyleInRegion = RenderStyle::clone(it->value.style.get());
     446            objectStyleInRegion = RenderStyle::clonePtr(*it->value.style);
    447447            ASSERT(it->value.cached);
    448448            objectRegionStyleCached = true;
    … …  
    464464    for (auto& objectPair : m_renderObjectRegionStyle) {
    465465        RenderObject* object = const_cast<RenderObject*>(objectPair.key);
    466         std::unique_ptr<RenderStyle> objectRegionStyle = RenderStyle::clone(&object->style());
    467         std::unique_ptr<RenderStyle> objectOriginalStyle = RenderStyle::clone(objectPair.value.style.get());
     466        std::unique_ptr<RenderStyle> objectRegionStyle = RenderStyle::clonePtr(object->style());
     467        std::unique_ptr<RenderStyle> objectOriginalStyle = RenderStyle::clonePtr(*objectPair.value.style);
    468468
    469469        bool shouldCacheRegionStyle = objectPair.value.cached;
    … …  
    482482        }
    483483        if (is<RenderElement>(*object))
    484             downcast<RenderElement>(*object).setStyleInternal(WTFMove(objectOriginalStyle));
     484            downcast<RenderElement>(*object).setStyleInternal(WTFMove(*objectOriginalStyle));
    485485    }
    486486

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

    r199964 r200041  
    5050class RenderNamedFlowFragment final : public RenderRegion {
    5151public:
    52     RenderNamedFlowFragment(Document&, std::unique_ptr<RenderStyle>);
     52    RenderNamedFlowFragment(Document&, RenderStyle&&);
    5353    virtual ~RenderNamedFlowFragment();
    5454
    55     static std::unique_ptr<RenderStyle> createStyle(const RenderStyle& parentStyle);
     55    static RenderStyle createStyle(const RenderStyle& parentStyle);
    5656
    5757    void styleDidChange(StyleDifference, const RenderStyle* oldStyle) override;

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

    r199964 r200041  
    4747namespace WebCore {
    4848
    49 RenderNamedFlowThread::RenderNamedFlowThread(Document& document, std::unique_ptr<RenderStyle> style, Ref<WebKitNamedFlow>&& namedFlow)
     49RenderNamedFlowThread::RenderNamedFlowThread(Document& document, RenderStyle&& style, Ref<WebKitNamedFlow>&& namedFlow)
    5050    : RenderFlowThread(document, WTFMove(style))
    5151    , m_hasRegionsWithStyling(false)
    … …  
    9393
    9494    // The first region defines the principal writing mode for the entire flow.
    95     auto newStyle = RenderStyle::clone(&style());
    96     newStyle->setWritingMode(firstFragment->style().writingMode());
     95    auto newStyle = RenderStyle::clone(style());
     96    newStyle.setWritingMode(firstFragment->style().writingMode());
    9797    setStyle(WTFMove(newStyle));
    9898}

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

    r199964 r200041  
    4747class RenderNamedFlowThread final : public RenderFlowThread, public SelectionSubtreeRoot {
    4848public:
    49     RenderNamedFlowThread(Document&, std::unique_ptr<RenderStyle>, Ref<WebKitNamedFlow>&&);
     49    RenderNamedFlowThread(Document&, RenderStyle&&, Ref<WebKitNamedFlow>&&);
    5050    virtual ~RenderNamedFlowThread();
    5151

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

    r199964 r200041  
    3131namespace WebCore {
    3232
    33 RenderProgress::RenderProgress(HTMLElement& element, std::unique_ptr<RenderStyle> style)
     33RenderProgress::RenderProgress(HTMLElement& element, RenderStyle&& style)
    3434    : RenderBlockFlow(element, WTFMove(style))
    3535    , m_position(HTMLProgressElement::InvalidPosition)

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

    r199964 r200041  
    3030class RenderProgress final : public RenderBlockFlow {
    3131public:
    32     RenderProgress(HTMLElement&, std::unique_ptr<RenderStyle>);
     32    RenderProgress(HTMLElement&, RenderStyle&&);
    3333    virtual ~RenderProgress();
    3434

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

    r199964 r200041  
    3232namespace WebCore {
    3333
    34 RenderQuote::RenderQuote(Document& document, std::unique_ptr<RenderStyle> style, QuoteType quote)
     34RenderQuote::RenderQuote(Document& document, RenderStyle&& style, QuoteType quote)
    3535    : RenderInline(document, WTFMove(style))
    3636    , m_type(quote)

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

    r199964 r200041  
    3030class RenderQuote final : public RenderInline {
    3131public:
    32     RenderQuote(Document&, std::unique_ptr<RenderStyle>, QuoteType);
     32    RenderQuote(Document&, RenderStyle&&, QuoteType);
    3333    virtual ~RenderQuote();
    3434

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

    r199964 r200041  
    4949namespace WebCore {
    5050
    51 RenderRegion::RenderRegion(Element& element, std::unique_ptr<RenderStyle> style, RenderFlowThread* flowThread)
     51RenderRegion::RenderRegion(Element& element, RenderStyle&& style, RenderFlowThread* flowThread)
    5252    : RenderBlockFlow(element, WTFMove(style))
    5353    , m_flowThread(flowThread)
    … …  
    5757}
    5858
    59 RenderRegion::RenderRegion(Document& document, std::unique_ptr<RenderStyle> style, RenderFlowThread* flowThread)
     59RenderRegion::RenderRegion(Document& document, RenderStyle&& style, RenderFlowThread* flowThread)
    6060    : RenderBlockFlow(document, WTFMove(style))
    6161    , m_flowThread(flowThread)

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

    r199964 r200041  
    128128
    129129protected:
    130     RenderRegion(Element&, std::unique_ptr<RenderStyle>, RenderFlowThread*);
    131     RenderRegion(Document&, std::unique_ptr<RenderStyle>, RenderFlowThread*);
     130    RenderRegion(Element&, RenderStyle&&, RenderFlowThread*);
     131    RenderRegion(Document&, RenderStyle&&, RenderFlowThread*);
    132132
    133133    void ensureOverflowForBox(const RenderBox*, RefPtr<RenderOverflow>&, bool);

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

    r199964 r200041  
    3131namespace WebCore {
    3232
    33 RenderRegionSet::RenderRegionSet(Document& document, std::unique_ptr<RenderStyle> style, RenderFlowThread& flowThread)
     33RenderRegionSet::RenderRegionSet(Document& document, RenderStyle&& style, RenderFlowThread& flowThread)
    3434    : RenderRegion(document, WTFMove(style), &flowThread)
    3535{

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

    r199964 r200041  
    5151
    5252protected:
    53     RenderRegionSet(Document&, std::unique_ptr<RenderStyle>, RenderFlowThread&);
     53    RenderRegionSet(Document&, RenderStyle&&, RenderFlowThread&);
    5454
    5555private:

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

    r199964 r200041  
    4747const int cDefaultHeight = 150;
    4848
    49 RenderReplaced::RenderReplaced(Element& element, std::unique_ptr<RenderStyle> style)
     49RenderReplaced::RenderReplaced(Element& element, RenderStyle&& style)
    5050    : RenderBox(element, WTFMove(style), RenderReplacedFlag)
    5151    , m_intrinsicSize(cDefaultWidth, cDefaultHeight)
    … …  
    5454}
    5555
    56 RenderReplaced::RenderReplaced(Element& element, std::unique_ptr<RenderStyle> style, const LayoutSize& intrinsicSize)
     56RenderReplaced::RenderReplaced(Element& element, RenderStyle&& style, const LayoutSize& intrinsicSize)
    5757    : RenderBox(element, WTFMove(style), RenderReplacedFlag)
    5858    , m_intrinsicSize(intrinsicSize)
    … …  
    6161}
    6262
    63 RenderReplaced::RenderReplaced(Document& document, std::unique_ptr<RenderStyle> style, const LayoutSize& intrinsicSize)
     63RenderReplaced::RenderReplaced(Document& document, RenderStyle&& style, const LayoutSize& intrinsicSize)
    6464    : RenderBox(document, WTFMove(style), RenderReplacedFlag)
    6565    , m_intrinsicSize(intrinsicSize)

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

    r199964 r200041  
    4040
    4141protected:
    42     RenderReplaced(Element&, std::unique_ptr<RenderStyle>);
    43     RenderReplaced(Element&, std::unique_ptr<RenderStyle>, const LayoutSize& intrinsicSize);
    44     RenderReplaced(Document&, std::unique_ptr<RenderStyle>, const LayoutSize& intrinsicSize);
     42    RenderReplaced(Element&, RenderStyle&&);
     43    RenderReplaced(Element&, RenderStyle&&, const LayoutSize& intrinsicSize);
     44    RenderReplaced(Document&, RenderStyle&&, const LayoutSize& intrinsicSize);
    4545
    4646    void layout() override;

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

    r199964 r200041  
    3535namespace WebCore {
    3636
    37 RenderReplica::RenderReplica(Document& document, std::unique_ptr<RenderStyle> style)
     37RenderReplica::RenderReplica(Document& document, RenderStyle&& style)
    3838    : RenderBox(document, WTFMove(style), 0)
    3939{

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

    r199964 r200041  
    3636class RenderReplica final : public RenderBox {
    3737public:
    38     RenderReplica(Document&, std::unique_ptr<RenderStyle>);
     38    RenderReplica(Document&, RenderStyle&&);
    3939    virtual ~RenderReplica();
    4040

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

    r199964 r200041  
    9999static RenderBlock* createAnonymousRubyInlineBlock(RenderObject& ruby)
    100100{
    101     RenderBlock* newBlock = new RenderBlockFlow(ruby.document(), RenderStyle::createAnonymousStyleWithDisplay(&ruby.style(), INLINE_BLOCK));
     101    RenderBlock* newBlock = new RenderBlockFlow(ruby.document(), RenderStyle::createAnonymousStyleWithDisplay(ruby.style(), INLINE_BLOCK));
    102102    newBlock->initializeStyle();
    103103    return newBlock;
    … …  
    123123//=== ruby as inline object ===
    124124
    125 RenderRubyAsInline::RenderRubyAsInline(Element& element, std::unique_ptr<RenderStyle> style)
     125RenderRubyAsInline::RenderRubyAsInline(Element& element, RenderStyle&& style)
    126126    : RenderInline(element, WTFMove(style))
    127127{
    … …  
    229229//=== ruby as block object ===
    230230
    231 RenderRubyAsBlock::RenderRubyAsBlock(Element& element, std::unique_ptr<RenderStyle> style)
     231RenderRubyAsBlock::RenderRubyAsBlock(Element& element, RenderStyle&& style)
    232232    : RenderBlockFlow(element, WTFMove(style))
    233233{

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

    r199964 r200041  
    5454class RenderRubyAsInline final : public RenderInline {
    5555public:
    56     RenderRubyAsInline(Element&, std::unique_ptr<RenderStyle>);
     56    RenderRubyAsInline(Element&, RenderStyle&&);
    5757    virtual ~RenderRubyAsInline();
    5858
    … …  
    7272class RenderRubyAsBlock final : public RenderBlockFlow {
    7373public:
    74     RenderRubyAsBlock(Element&, std::unique_ptr<RenderStyle>);
     74    RenderRubyAsBlock(Element&, RenderStyle&&);
    7575    virtual ~RenderRubyAsBlock();
    7676

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

    r199964 r200041  
    3737namespace WebCore {
    3838
    39 RenderRubyBase::RenderRubyBase(Document& document, std::unique_ptr<RenderStyle> style)
     39RenderRubyBase::RenderRubyBase(Document& document, RenderStyle&& style)
    4040    : RenderBlockFlow(document, WTFMove(style))
    4141    , m_initialOffset(0)

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

    r199964 r200041  
    4040class RenderRubyBase final : public RenderBlockFlow {
    4141public:
    42     RenderRubyBase(Document&, std::unique_ptr<RenderStyle>);
     42    RenderRubyBase(Document&, RenderStyle&&);
    4343    virtual ~RenderRubyBase();
    4444   

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

    r199964 r200041  
    4545using namespace std;
    4646
    47 RenderRubyRun::RenderRubyRun(Document& document, std::unique_ptr<RenderStyle> style)
     47RenderRubyRun::RenderRubyRun(Document& document, RenderStyle&& style)
    4848    : RenderBlockFlow(document, WTFMove(style))
    4949    , m_lastCharacter(0)
    … …  
    204204RenderRubyBase* RenderRubyRun::createRubyBase() const
    205205{
    206     auto newStyle = RenderStyle::createAnonymousStyleWithDisplay(&style(), BLOCK);
    207     newStyle->setTextAlign(CENTER); // FIXME: use WEBKIT_CENTER?
     206    auto newStyle = RenderStyle::createAnonymousStyleWithDisplay(style(), BLOCK);
     207    newStyle.setTextAlign(CENTER); // FIXME: use WEBKIT_CENTER?
    208208    auto renderer = new RenderRubyBase(document(), WTFMove(newStyle));
    209209    renderer->initializeStyle();
    … …  
    214214{
    215215    ASSERT(isRuby(parentRuby));
    216     auto renderer = new RenderRubyRun(parentRuby->document(), RenderStyle::createAnonymousStyleWithDisplay(&parentRuby->style(), INLINE_BLOCK));
     216    auto renderer = new RenderRubyRun(parentRuby->document(), RenderStyle::createAnonymousStyleWithDisplay(parentRuby->style(), INLINE_BLOCK));
    217217    renderer->initializeStyle();
    218218    return renderer;

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

    r199964 r200041  
    4444class RenderRubyRun final : public RenderBlockFlow {
    4545public:
    46     RenderRubyRun(Document&, std::unique_ptr<RenderStyle>);
     46    RenderRubyRun(Document&, RenderStyle&&);
    4747    virtual ~RenderRubyRun();
    4848

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

    r199964 r200041  
    3737namespace WebCore {
    3838
    39 RenderRubyText::RenderRubyText(Element& element, std::unique_ptr<RenderStyle> style)
     39RenderRubyText::RenderRubyText(Element& element, RenderStyle&& style)
    4040    : RenderBlockFlow(element, WTFMove(style))
    4141{

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

    r199964 r200041  
    3838class RenderRubyText final : public RenderBlockFlow {
    3939public:
    40     RenderRubyText(Element&, std::unique_ptr<RenderStyle>);
     40    RenderRubyText(Element&, RenderStyle&&);
    4141    virtual ~RenderRubyText();
    4242

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

    r199964 r200041  
    246246
    247247    if (auto& partRendererSlot = m_parts.add(partType, nullptr).iterator->value)
    248         partRendererSlot->setStyle(WTFMove(partStyle));
     248        partRendererSlot->setStyle(WTFMove(*partStyle));
    249249    else {
    250         partRendererSlot = createRenderer<RenderScrollbarPart>(owningRenderer()->document(), WTFMove(partStyle), this, partType);
     250        partRendererSlot = createRenderer<RenderScrollbarPart>(owningRenderer()->document(), WTFMove(*partStyle), this, partType);
    251251        partRendererSlot->initializeStyle();
    252252    }

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

    r199964 r200041  
    3535namespace WebCore {
    3636
    37 RenderScrollbarPart::RenderScrollbarPart(Document& document, std::unique_ptr<RenderStyle> style, RenderScrollbar* scrollbar, ScrollbarPart part)
     37RenderScrollbarPart::RenderScrollbarPart(Document& document, RenderStyle&& style, RenderScrollbar* scrollbar, ScrollbarPart part)
    3838    : RenderBlock(document, WTFMove(style), 0)
    3939    , m_scrollbar(scrollbar)

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

    r199964 r200041  
    3636class RenderScrollbarPart final : public RenderBlock {
    3737public:
    38     RenderScrollbarPart(Document&, std::unique_ptr<RenderStyle>, RenderScrollbar* = nullptr, ScrollbarPart = NoPart);
     38    RenderScrollbarPart(Document&, RenderStyle&&, RenderScrollbar* = nullptr, ScrollbarPart = NoPart);
    3939   
    4040    virtual ~RenderScrollbarPart();

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

    r199964 r200041  
    5151using namespace HTMLNames;
    5252
    53 RenderSearchField::RenderSearchField(HTMLInputElement& element, std::unique_ptr<RenderStyle> style)
     53RenderSearchField::RenderSearchField(HTMLInputElement& element, RenderStyle&& style)
    5454    : RenderTextControlSingleLine(element, WTFMove(style))
    5555    , m_searchPopupIsVisible(false)
    … …  
    179179        return;
    180180
    181     auto cancelButtonStyle = RenderStyle::clone(&curStyle);
    182     cancelButtonStyle->setVisibility(buttonVisibility);
     181    auto cancelButtonStyle = RenderStyle::clone(curStyle);
     182    cancelButtonStyle.setVisibility(buttonVisibility);
    183183    cancelButtonRenderer->setStyle(WTFMove(cancelButtonStyle));
    184184}

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

    r199964 r200041  
    3434class RenderSearchField final : public RenderTextControlSingleLine, private PopupMenuClient {
    3535public:
    36     RenderSearchField(HTMLInputElement&, std::unique_ptr<RenderStyle>);
     36    RenderSearchField(HTMLInputElement&, RenderStyle&&);
    3737    virtual ~RenderSearchField();
    3838

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

    r199964 r200041  
    4848const int RenderSlider::defaultTrackLength = 129;
    4949
    50 RenderSlider::RenderSlider(HTMLInputElement& element, std::unique_ptr<RenderStyle> style)
     50RenderSlider::RenderSlider(HTMLInputElement& element, RenderStyle&& style)
    5151    : RenderFlexibleBox(element, WTFMove(style))
    5252{

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

    r199964 r200041  
    3434    static const int defaultTrackLength;
    3535
    36     RenderSlider(HTMLInputElement&, std::unique_ptr<RenderStyle>);
     36    RenderSlider(HTMLInputElement&, RenderStyle&&);
    3737    virtual ~RenderSlider();
    3838

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

    r199964 r200041  
    4949namespace WebCore {
    5050
    51 RenderSnapshottedPlugIn::RenderSnapshottedPlugIn(HTMLPlugInImageElement& element, std::unique_ptr<RenderStyle> style)
     51RenderSnapshottedPlugIn::RenderSnapshottedPlugIn(HTMLPlugInImageElement& element, RenderStyle&& style)
    5252    : RenderEmbeddedObject(element, WTFMove(style))
    5353    , m_snapshotResource(std::make_unique<RenderImageResource>())

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

    r199964 r200041  
    3737class RenderSnapshottedPlugIn final : public RenderEmbeddedObject {
    3838public:
    39     RenderSnapshottedPlugIn(HTMLPlugInImageElement&, std::unique_ptr<RenderStyle>);
     39    RenderSnapshottedPlugIn(HTMLPlugInImageElement&, RenderStyle&&);
    4040    virtual ~RenderSnapshottedPlugIn();
    4141

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

    r199964 r200041  
    5151using namespace HTMLNames;
    5252
    53 RenderTable::RenderTable(Element& element, std::unique_ptr<RenderStyle> style)
     53RenderTable::RenderTable(Element& element, RenderStyle&& style)
    5454    : RenderBlock(element, WTFMove(style), 0)
    5555    , m_head(nullptr)
    … …  
    7373}
    7474
    75 RenderTable::RenderTable(Document& document, std::unique_ptr<RenderStyle> style)
     75RenderTable::RenderTable(Document& document, RenderStyle&& style)
    7676    : RenderBlock(document, WTFMove(style), 0)
    7777    , m_head(nullptr)
    … …  
    15501550RenderTable* RenderTable::createAnonymousWithParentRenderer(const RenderObject* parent)
    15511551{
    1552     auto table = new RenderTable(parent->document(), RenderStyle::createAnonymousStyleWithDisplay(&parent->style(), parent->style().display() == INLINE ? INLINE_TABLE : TABLE));
     1552    auto table = new RenderTable(parent->document(), RenderStyle::createAnonymousStyleWithDisplay(parent->style(), parent->style().display() == INLINE ? INLINE_TABLE : TABLE));
    15531553    table->initializeStyle();
    15541554    return table;

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

    r199964 r200041  
    4545class RenderTable : public RenderBlock {
    4646public:
    47     RenderTable(Element&, std::unique_ptr<RenderStyle>);
    48     RenderTable(Document&, std::unique_ptr<RenderStyle>);
     47    RenderTable(Element&, RenderStyle&&);
     48    RenderTable(Document&, RenderStyle&&);
    4949    virtual ~RenderTable();
    5050

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

    r199964 r200041  
    2525namespace WebCore {
    2626
    27 RenderTableCaption::RenderTableCaption(Element& element, std::unique_ptr<RenderStyle> style)
     27RenderTableCaption::RenderTableCaption(Element& element, RenderStyle&& style)
    2828    : RenderBlockFlow(element, WTFMove(style))
    2929{

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

    r199964 r200041  
    2929class RenderTableCaption final : public RenderBlockFlow {
    3030public:
    31     RenderTableCaption(Element&, std::unique_ptr<RenderStyle>);
     31    RenderTableCaption(Element&, RenderStyle&&);
    3232    virtual ~RenderTableCaption();
    3333

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

    r199964 r200041  
    5555COMPILE_ASSERT(sizeof(CollapsedBorderValue) == 12, CollapsedBorderValue_should_stay_small);
    5656
    57 RenderTableCell::RenderTableCell(Element& element, std::unique_ptr<RenderStyle> style)
     57RenderTableCell::RenderTableCell(Element& element, RenderStyle&& style)
    5858    : RenderBlockFlow(element, WTFMove(style))
    5959    , m_column(unsetColumnIndex)
    … …  
    7171}
    7272
    73 RenderTableCell::RenderTableCell(Document& document, std::unique_ptr<RenderStyle> style)
     73RenderTableCell::RenderTableCell(Document& document, RenderStyle&& style)
    7474    : RenderBlockFlow(document, WTFMove(style))
    7575    , m_column(unsetColumnIndex)
    … …  
    13451345RenderTableCell* RenderTableCell::createAnonymousWithParentRenderer(const RenderObject* parent)
    13461346{
    1347     auto cell = new RenderTableCell(parent->document(), RenderStyle::createAnonymousStyleWithDisplay(&parent->style(), TABLE_CELL));
     1347    auto cell = new RenderTableCell(parent->document(), RenderStyle::createAnonymousStyleWithDisplay(parent->style(), TABLE_CELL));
    13481348    cell->initializeStyle();
    13491349    return cell;

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

    r199964 r200041  
    4040class RenderTableCell final : public RenderBlockFlow {
    4141public:
    42     RenderTableCell(Element&, std::unique_ptr<RenderStyle>);
    43     RenderTableCell(Document&, std::unique_ptr<RenderStyle>);
     42    RenderTableCell(Element&, RenderStyle&&);
     43    RenderTableCell(Document&, RenderStyle&&);
    4444   
    4545    unsigned colSpan() const;

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

    r199964 r200041  
    3838using namespace HTMLNames;
    3939
    40 RenderTableCol::RenderTableCol(Element& element, std::unique_ptr<RenderStyle> style)
     40RenderTableCol::RenderTableCol(Element& element, RenderStyle&& style)
    4141    : RenderBox(element, WTFMove(style), 0)
    4242{

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

    r199964 r200041  
    3636class RenderTableCol final : public RenderBox {
    3737public:
    38     RenderTableCol(Element&, std::unique_ptr<RenderStyle>);
     38    RenderTableCol(Element&, RenderStyle&&);
    3939    Element& element() const { return downcast<Element>(nodeForNonAnonymous()); }
    4040

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

    r199964 r200041  
    3939using namespace HTMLNames;
    4040
    41 RenderTableRow::RenderTableRow(Element& element, std::unique_ptr<RenderStyle> style)
     41RenderTableRow::RenderTableRow(Element& element, RenderStyle&& style)
    4242    : RenderBox(element, WTFMove(style), 0)
    4343    , m_rowIndex(unsetRowIndex)
    … …  
    4646}
    4747
    48 RenderTableRow::RenderTableRow(Document& document, std::unique_ptr<RenderStyle> style)
     48RenderTableRow::RenderTableRow(Document& document, RenderStyle&& style)
    4949    : RenderBox(document, WTFMove(style), 0)
    5050    , m_rowIndex(unsetRowIndex)
    … …  
    263263RenderTableRow* RenderTableRow::createAnonymousWithParentRenderer(const RenderObject* parent)
    264264{
    265     auto newRow = new RenderTableRow(parent->document(), RenderStyle::createAnonymousStyleWithDisplay(&parent->style(), TABLE_ROW));
     265    auto newRow = new RenderTableRow(parent->document(), RenderStyle::createAnonymousStyleWithDisplay(parent->style(), TABLE_ROW));
    266266    newRow->initializeStyle();
    267267    return newRow;

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

    r199964 r200041  
    3535class RenderTableRow final : public RenderBox {
    3636public:
    37     RenderTableRow(Element&, std::unique_ptr<RenderStyle>);
    38     RenderTableRow(Document&, std::unique_ptr<RenderStyle>);
     37    RenderTableRow(Element&, RenderStyle&&);
     38    RenderTableRow(Document&, RenderStyle&&);
    3939
    4040    RenderTableRow* nextRow() const;

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

    r199964 r200041  
    8383}
    8484
    85 RenderTableSection::RenderTableSection(Element& element, std::unique_ptr<RenderStyle> style)
     85RenderTableSection::RenderTableSection(Element& element, RenderStyle&& style)
    8686    : RenderBox(element, WTFMove(style), 0)
    8787{
    … …  
    8989}
    9090
    91 RenderTableSection::RenderTableSection(Document& document, std::unique_ptr<RenderStyle> style)
     91RenderTableSection::RenderTableSection(Document& document, RenderStyle&& style)
    9292    : RenderBox(document, WTFMove(style), 0)
    9393{
    … …  
    15791579RenderTableSection* RenderTableSection::createAnonymousWithParentRenderer(const RenderObject* parent)
    15801580{
    1581     auto section = new RenderTableSection(parent->document(), RenderStyle::createAnonymousStyleWithDisplay(&parent->style(), TABLE_ROW_GROUP));
     1581    auto section = new RenderTableSection(parent->document(), RenderStyle::createAnonymousStyleWithDisplay(parent->style(), TABLE_ROW_GROUP));
    15821582    section->initializeStyle();
    15831583    return section;

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

    r199964 r200041  
    5656class RenderTableSection final : public RenderBox {
    5757public:
    58     RenderTableSection(Element&, std::unique_ptr<RenderStyle>);
    59     RenderTableSection(Document&, std::unique_ptr<RenderStyle>);
     58    RenderTableSection(Element&, RenderStyle&&);
     59    RenderTableSection(Document&, RenderStyle&&);
    6060    virtual ~RenderTableSection();
    6161

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

    r199964 r200041  
    3737namespace WebCore {
    3838
    39 RenderTextControl::RenderTextControl(HTMLTextFormControlElement& element, std::unique_ptr<RenderStyle> style)
     39RenderTextControl::RenderTextControl(HTMLTextFormControlElement& element, RenderStyle&& style)
    4040    : RenderBlockFlow(element, WTFMove(style))
    4141{

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

    r199964 r200041  
    4545
    4646protected:
    47     RenderTextControl(HTMLTextFormControlElement&, std::unique_ptr<RenderStyle>);
     47    RenderTextControl(HTMLTextFormControlElement&, RenderStyle&&);
    4848
    4949    // This convenience function should not be made public because innerTextElement may outlive the render tree.
    … …  
    9292class RenderTextControlInnerContainer final : public RenderFlexibleBox {
    9393public:
    94     explicit RenderTextControlInnerContainer(Element& element, std::unique_ptr<RenderStyle> style)
     94    explicit RenderTextControlInnerContainer(Element& element, RenderStyle&& style)
    9595        : RenderFlexibleBox(element, WTFMove(style))
    9696    { }

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

    r199964 r200041  
    3333namespace WebCore {
    3434
    35 RenderTextControlMultiLine::RenderTextControlMultiLine(HTMLTextAreaElement& element, std::unique_ptr<RenderStyle> style)
     35RenderTextControlMultiLine::RenderTextControlMultiLine(HTMLTextAreaElement& element, RenderStyle&& style)
    3636    : RenderTextControl(element, WTFMove(style))
    3737{

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

    r199964 r200041  
    3131class RenderTextControlMultiLine final : public RenderTextControl {
    3232public:
    33     RenderTextControlMultiLine(HTMLTextAreaElement&, std::unique_ptr<RenderStyle>);
     33    RenderTextControlMultiLine(HTMLTextAreaElement&, RenderStyle&&);
    3434    virtual ~RenderTextControlMultiLine();
    3535

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

    r199964 r200041  
    5454using namespace HTMLNames;
    5555
    56 RenderTextControlSingleLine::RenderTextControlSingleLine(HTMLInputElement& element, std::unique_ptr<RenderStyle> style)
     56RenderTextControlSingleLine::RenderTextControlSingleLine(HTMLInputElement& element, RenderStyle&& style)
    5757    : RenderTextControl(element, WTFMove(style))
    5858{

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

    r199964 r200041  
    3333class RenderTextControlSingleLine : public RenderTextControl {
    3434public:
    35     RenderTextControlSingleLine(HTMLInputElement&, std::unique_ptr<RenderStyle>);
     35    RenderTextControlSingleLine(HTMLInputElement&, RenderStyle&&);
    3636    virtual ~RenderTextControlSingleLine();
    3737
    … …  
    9191class RenderTextControlInnerBlock final : public RenderBlockFlow {
    9292public:
    93     RenderTextControlInnerBlock(Element& element, std::unique_ptr<RenderStyle> style)
     93    RenderTextControlInnerBlock(Element& element, RenderStyle&& style)
    9494        : RenderBlockFlow(element, WTFMove(style))
    9595    {

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

    r199964 r200041  
    3737namespace WebCore {
    3838
    39 RenderVTTCue::RenderVTTCue(VTTCueBox& element, std::unique_ptr<RenderStyle> style)
     39RenderVTTCue::RenderVTTCue(VTTCueBox& element, RenderStyle&& style)
    4040    : RenderBlockFlow(element, WTFMove(style))
    4141    , m_cue(element.getCue())

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

    r199964 r200041  
    4141class RenderVTTCue final : public RenderBlockFlow {
    4242public:
    43     RenderVTTCue(VTTCueBox&, std::unique_ptr<RenderStyle>);
     43    RenderVTTCue(VTTCueBox&, RenderStyle&&);
    4444
    4545private:

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

    r199964 r200041  
    4949using namespace HTMLNames;
    5050
    51 RenderVideo::RenderVideo(HTMLVideoElement& element, std::unique_ptr<RenderStyle> style)
     51RenderVideo::RenderVideo(HTMLVideoElement& element, RenderStyle&& style)
    5252    : RenderMedia(element, WTFMove(style))
    5353{

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

    r199964 r200041  
    3737class RenderVideo final : public RenderMedia {
    3838public:
    39     RenderVideo(HTMLVideoElement&, std::unique_ptr<RenderStyle>);
     39    RenderVideo(HTMLVideoElement&, RenderStyle&&);
    4040    virtual ~RenderVideo();
    4141

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

    r199964 r200041  
    116116};
    117117
    118 RenderView::RenderView(Document& document, std::unique_ptr<RenderStyle> style)
     118RenderView::RenderView(Document& document, RenderStyle&& style)
    119119    : RenderBlockFlow(document, WTFMove(style))
    120120    , m_frameView(*document.view())

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

    r199964 r200041  
    4545class RenderView final : public RenderBlockFlow, public SelectionSubtreeRoot {
    4646public:
    47     RenderView(Document&, std::unique_ptr<RenderStyle>);
     47    RenderView(Document&, RenderStyle&&);
    4848    virtual ~RenderView();
    4949

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

    r199964 r200041  
    8181}
    8282
    83 RenderWidget::RenderWidget(HTMLFrameOwnerElement& element, std::unique_ptr<RenderStyle> style)
     83RenderWidget::RenderWidget(HTMLFrameOwnerElement& element, RenderStyle&& style)
    8484    : RenderReplaced(element, WTFMove(style))
    8585    , m_weakPtrFactory(this)

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

    r199964 r200041  
    8080
    8181protected:
    82     RenderWidget(HTMLFrameOwnerElement&, std::unique_ptr<RenderStyle>);
     82    RenderWidget(HTMLFrameOwnerElement&, RenderStyle&&);
    8383
    8484    void styleDidChange(StyleDifference, const RenderStyle* oldStyle) final;

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

    r199964 r200041  
    3737namespace WebCore {
    3838
    39 static std::unique_ptr<RenderStyle> cloneRenderStyleWithState(const RenderStyle& currentStyle)
    40 {
    41     auto newStyle = RenderStyle::clone(&currentStyle);
     39static RenderStyle cloneRenderStyleWithState(const RenderStyle& currentStyle)
     40{
     41    auto newStyle = RenderStyle::clone(currentStyle);
    4242    if (currentStyle.lastChildState())
    43         newStyle->setLastChildState();
     43        newStyle.setLastChildState();
    4444    if (currentStyle.firstChildState())
    45         newStyle->setFirstChildState();
     45        newStyle.setFirstChildState();
    4646    return newStyle;
    4747}
    … …  
    5353
    5454TextAutoSizingKey::TextAutoSizingKey(RenderStyle* style)
    55     : m_style(RenderStyle::clone(style))
     55    : m_style(style ? RenderStyle::clonePtr(*style) : nullptr)
    5656{
    5757}
    … …  
    119119           
    120120            auto style = cloneRenderStyleWithState(text->style());
    121             auto fontDescription = style->fontDescription();
     121            auto fontDescription = style.fontDescription();
    122122            fontDescription.setComputedSize(averageSize);
    123             style->setFontDescription(fontDescription);
    124             style->fontCascade().update(&autoSizingNode->document().fontSelector());
     123            style.setFontDescription(fontDescription);
     124            style.fontCascade().update(&autoSizingNode->document().fontSelector());
    125125            text->parent()->setStyle(WTFMove(style));
    126126           
    … …  
    133133            if (listMarkerRenderer->isListMarker()) {
    134134                auto style = cloneRenderStyleWithState(listMarkerRenderer->style());
    135                 style->setFontDescription(fontDescription);
    136                 style->fontCascade().update(&autoSizingNode->document().fontSelector());
     135                style.setFontDescription(fontDescription);
     136                style.fontCascade().update(&autoSizingNode->document().fontSelector());
    137137                downcast<RenderListMarker>(*listMarkerRenderer).setStyle(WTFMove(style));
    138138            }
    … …  
    151151            if (!lineHeightLength.isFixed() || lineHeightLength.value() != lineHeight) {
    152152                auto newParentStyle = cloneRenderStyleWithState(parentStyle);
    153                 newParentStyle->setLineHeight(Length(lineHeight, Fixed));
    154                 newParentStyle->setSpecifiedLineHeight(lineHeightLength);
    155                 newParentStyle->setFontDescription(fontDescription);
    156                 newParentStyle->fontCascade().update(&autoSizingNode->document().fontSelector());
     153                newParentStyle.setLineHeight(Length(lineHeight, Fixed));
     154                newParentStyle.setSpecifiedLineHeight(lineHeightLength);
     155                newParentStyle.setFontDescription(fontDescription);
     156                newParentStyle.fontCascade().update(&autoSizingNode->document().fontSelector());
    157157                parentRenderer->setStyle(WTFMove(newParentStyle));
    158158            }
    … …  
    175175            fontDescription.setComputedSize(originalSize);
    176176            auto style = cloneRenderStyleWithState(text->style());
    177             style->setFontDescription(fontDescription);
    178             style->fontCascade().update(&autoSizingNode->document().fontSelector());
     177            style.setFontDescription(fontDescription);
     178            style.fontCascade().update(&autoSizingNode->document().fontSelector());
    179179            text->parent()->setStyle(WTFMove(style));
    180180        }
    … …  
    191191        if (originalLineHeight != parentStyle.lineHeight()) {
    192192            auto newParentStyle = cloneRenderStyleWithState(parentStyle);
    193             newParentStyle->setLineHeight(originalLineHeight);
    194             newParentStyle->setFontDescription(fontDescription);
    195             newParentStyle->fontCascade().update(&autoSizingNode->document().fontSelector());
     193            newParentStyle.setLineHeight(originalLineHeight);
     194            newParentStyle.setFontDescription(fontDescription);
     195            newParentStyle.fontCascade().update(&autoSizingNode->document().fontSelector());
    196196            parentRenderer->setStyle(WTFMove(newParentStyle));
    197197        }

  • trunk/Source/WebCore/rendering/mathml/RenderMathMLBlock.cpp

    r199964 r200041  
    4444using namespace MathMLNames;
    4545   
    46 RenderMathMLBlock::RenderMathMLBlock(Element& container, std::unique_ptr<RenderStyle> style)
     46RenderMathMLBlock::RenderMathMLBlock(Element& container, RenderStyle&& style)
    4747    : RenderFlexibleBox(container, WTFMove(style))
    4848{
    4949}
    5050
    51 RenderMathMLBlock::RenderMathMLBlock(Document& document, std::unique_ptr<RenderStyle> style)
     51RenderMathMLBlock::RenderMathMLBlock(Document& document, RenderStyle&& style)
    5252    : RenderFlexibleBox(document, WTFMove(style))
    5353{
    … …  
    6161RenderPtr<RenderMathMLBlock> RenderMathMLBlock::createAnonymousMathMLBlock()
    6262{
    63     RenderPtr<RenderMathMLBlock> newBlock = createRenderer<RenderMathMLBlock>(document(), RenderStyle::createAnonymousStyleWithDisplay(&style(), FLEX));
     63    RenderPtr<RenderMathMLBlock> newBlock = createRenderer<RenderMathMLBlock>(document(), RenderStyle::createAnonymousStyleWithDisplay(style(), FLEX));
    6464    newBlock->initializeStyle();
    6565    return newBlock;

  • trunk/Source/WebCore/rendering/mathml/RenderMathMLBlock.h

    r199964 r200041  
    4242class RenderMathMLBlock : public RenderFlexibleBox {
    4343public:
    44     RenderMathMLBlock(Element&, std::unique_ptr<RenderStyle>);
    45     RenderMathMLBlock(Document&, std::unique_ptr<RenderStyle>);
     44    RenderMathMLBlock(Element&, RenderStyle&&);
     45    RenderMathMLBlock(Document&, RenderStyle&&);
    4646
    4747    bool isChildAllowed(const RenderObject&, const RenderStyle&) const override;
    … …  
    8181class RenderMathMLTable final : public RenderTable {
    8282public:
    83     explicit RenderMathMLTable(Element& element, std::unique_ptr<RenderStyle> style)
     83    explicit RenderMathMLTable(Element& element, RenderStyle&& style)
    8484        : RenderTable(element, WTFMove(style))
    8585    {

  • trunk/Source/WebCore/rendering/mathml/RenderMathMLFenced.cpp

    r199964 r200041  
    4444static const char* gClosingBraceChar = ")";
    4545
    46 RenderMathMLFenced::RenderMathMLFenced(MathMLInlineContainerElement& element, std::unique_ptr<RenderStyle> style)
     46RenderMathMLFenced::RenderMathMLFenced(MathMLInlineContainerElement& element, RenderStyle&& style)
    4747    : RenderMathMLRow(element, WTFMove(style))
    4848    , m_closeFenceRenderer(nullptr)
    … …  
    8686RenderPtr<RenderMathMLOperator> RenderMathMLFenced::createMathMLOperator(const String& operatorString, MathMLOperatorDictionary::Form form, MathMLOperatorDictionary::Flag flag)
    8787{
    88     RenderPtr<RenderMathMLOperator> newOperator = createRenderer<RenderMathMLOperator>(document(), RenderStyle::createAnonymousStyleWithDisplay(&style(), FLEX), operatorString, form, flag);
     88    RenderPtr<RenderMathMLOperator> newOperator = createRenderer<RenderMathMLOperator>(document(), RenderStyle::createAnonymousStyleWithDisplay(style(), FLEX), operatorString, form, flag);
    8989    newOperator->initializeStyle();
    9090    return newOperator;

  • trunk/Source/WebCore/rendering/mathml/RenderMathMLFenced.h

    r199964 r200041  
    3737class RenderMathMLFenced final : public RenderMathMLRow {
    3838public:
    39     RenderMathMLFenced(MathMLInlineContainerElement&, std::unique_ptr<RenderStyle>);
     39    RenderMathMLFenced(MathMLInlineContainerElement&, RenderStyle&&);
    4040    MathMLInlineContainerElement& element() { return static_cast<MathMLInlineContainerElement&>(nodeForNonAnonymous()); }
    4141   

  • trunk/Source/WebCore/rendering/mathml/RenderMathMLFraction.cpp

    r199964 r200041  
    5050static const float gDenominatorGap = 0.2f;
    5151
    52 RenderMathMLFraction::RenderMathMLFraction(MathMLInlineContainerElement& element, std::unique_ptr<RenderStyle> style)
     52RenderMathMLFraction::RenderMathMLFraction(MathMLInlineContainerElement& element, RenderStyle&& style)
    5353    : RenderMathMLBlock(element, WTFMove(style))
    5454    , m_defaultLineThickness(1)

  • trunk/Source/WebCore/rendering/mathml/RenderMathMLFraction.h

    r199964 r200041  
    3838class RenderMathMLFraction final : public RenderMathMLBlock {
    3939public:
    40     RenderMathMLFraction(MathMLInlineContainerElement&, std::unique_ptr<RenderStyle>);
     40    RenderMathMLFraction(MathMLInlineContainerElement&, RenderStyle&&);
    4141
    4242    MathMLInlineContainerElement& element() { return static_cast<MathMLInlineContainerElement&>(nodeForNonAnonymous()); }

  • trunk/Source/WebCore/rendering/mathml/RenderMathMLMath.cpp

    r199964 r200041  
    3636using namespace MathMLNames;
    3737
    38 RenderMathMLMath::RenderMathMLMath(Element& element, std::unique_ptr<RenderStyle> style)
     38RenderMathMLMath::RenderMathMLMath(Element& element, RenderStyle&& style)
    3939    : RenderMathMLRow(element, WTFMove(style))
    4040{

  • trunk/Source/WebCore/rendering/mathml/RenderMathMLMath.h

    r199964 r200041  
    3535class RenderMathMLMath final : public RenderMathMLRow {
    3636public:
    37     RenderMathMLMath(Element&, std::unique_ptr<RenderStyle>);
     37    RenderMathMLMath(Element&, RenderStyle&&);
    3838
    3939private:

  • trunk/Source/WebCore/rendering/mathml/RenderMathMLMenclose.cpp

    r199980 r200041  
    4343const unsigned short longDivLeftSpace = 10;
    4444
    45 RenderMathMLMenclose::RenderMathMLMenclose(Element& element, std::unique_ptr<RenderStyle> style)
     45RenderMathMLMenclose::RenderMathMLMenclose(Element& element, RenderStyle&& style)
    4646    : RenderMathMLRow(element, WTFMove(style))
    4747    , m_ascent(0)

  • trunk/Source/WebCore/rendering/mathml/RenderMathMLMenclose.h

    r199980 r200041  
    3636class RenderMathMLMenclose final: public RenderMathMLRow {
    3737public:
    38     RenderMathMLMenclose(Element&, std::unique_ptr<RenderStyle>);
     38    RenderMathMLMenclose(Element&, RenderStyle&&);
    3939
    4040private:

  • trunk/Source/WebCore/rendering/mathml/RenderMathMLOperator.cpp

    r199978 r200041  
    7373};
    7474
    75 RenderMathMLOperator::RenderMathMLOperator(MathMLElement& element, std::unique_ptr<RenderStyle> style)
     75RenderMathMLOperator::RenderMathMLOperator(MathMLElement& element, RenderStyle&& style)
    7676    : RenderMathMLToken(element, WTFMove(style))
    7777    , m_stretchHeightAboveBaseline(0)
    … …  
    8383}
    8484
    85 RenderMathMLOperator::RenderMathMLOperator(Document& document, std::unique_ptr<RenderStyle> style, const String& operatorString, MathMLOperatorDictionary::Form form, unsigned short flags)
     85RenderMathMLOperator::RenderMathMLOperator(Document& document, RenderStyle&& style, const String& operatorString, MathMLOperatorDictionary::Form form, unsigned short flags)
    8686    : RenderMathMLToken(document, WTFMove(style))
    8787    , m_stretchHeightAboveBaseline(0)
    … …  
    632632    // FIXME: The spacing should only be added inside (perhaps inferred) mrow (http://www.w3.org/TR/MathML/chapter3.html#presm.opspacing).
    633633    const auto& wrapper = downcast<RenderElement>(firstChild());
    634     auto newStyle = RenderStyle::createAnonymousStyleWithDisplay(&style(), FLEX);
    635     newStyle->setMarginStart(Length(m_leadingSpace, Fixed));
    636     newStyle->setMarginEnd(Length(m_trailingSpace, Fixed));
     634    auto newStyle = RenderStyle::createAnonymousStyleWithDisplay(style(), FLEX);
     635    newStyle.setMarginStart(Length(m_leadingSpace, Fixed));
     636    newStyle.setMarginEnd(Length(m_trailingSpace, Fixed));
    637637    wrapper->setStyle(WTFMove(newStyle));
    638638    wrapper->setNeedsLayoutAndPrefWidthsRecalc();

  • trunk/Source/WebCore/rendering/mathml/RenderMathMLOperator.h

    r199964 r200041  
    4040class RenderMathMLOperator : public RenderMathMLToken {
    4141public:
    42     RenderMathMLOperator(MathMLElement&, std::unique_ptr<RenderStyle>);
    43     RenderMathMLOperator(Document&, std::unique_ptr<RenderStyle>, const String& operatorString, MathMLOperatorDictionary::Form, unsigned short flags = 0);
     42    RenderMathMLOperator(MathMLElement&, RenderStyle&&);
     43    RenderMathMLOperator(Document&, RenderStyle&&, const String& operatorString, MathMLOperatorDictionary::Form, unsigned short flags = 0);
    4444
    4545    virtual void stretchTo(LayoutUnit heightAboveBaseline, LayoutUnit depthBelowBaseline);

  • trunk/Source/WebCore/rendering/mathml/RenderMathMLRadicalOperator.cpp

    r199964 r200041  
    5757const float gRadicalThickLineThicknessEms = 0.1f;
    5858
    59 RenderMathMLRadicalOperator::RenderMathMLRadicalOperator(Document& document, std::unique_ptr<RenderStyle> style)
     59RenderMathMLRadicalOperator::RenderMathMLRadicalOperator(Document& document, RenderStyle&& style)
    6060    : RenderMathMLOperator(document, WTFMove(style), String(&gRadicalCharacter, 1), MathMLOperatorDictionary::Prefix)
    6161{

  • trunk/Source/WebCore/rendering/mathml/RenderMathMLRadicalOperator.h

    r199964 r200041  
    3636class RenderMathMLRadicalOperator final : public RenderMathMLOperator {
    3737public:
    38     RenderMathMLRadicalOperator(Document&, std::unique_ptr<RenderStyle>);
     38    RenderMathMLRadicalOperator(Document&, RenderStyle&&);
    3939    void stretchTo(LayoutUnit heightAboveBaseline, LayoutUnit depthBelowBaseline) override;
    4040    void computePreferredLogicalWidths() override;

  • trunk/Source/WebCore/rendering/mathml/RenderMathMLRoot.cpp

    r199980 r200041  
    5656// We will allow the IndexWrapper to be empty and it will always contain the last child of the <mroot> if there are at least 2 elements.
    5757
    58 RenderMathMLRoot::RenderMathMLRoot(Element& element, std::unique_ptr<RenderStyle> style)
     58RenderMathMLRoot::RenderMathMLRoot(Element& element, RenderStyle&& style)
    5959    : RenderMathMLBlock(element, WTFMove(style))
    6060{
    … …  
    105105    if (radical->isEmpty()) {
    106106        // We create the radical operator.
    107         RenderPtr<RenderMathMLRadicalOperator> radicalOperator = createRenderer<RenderMathMLRadicalOperator>(document(), RenderStyle::createAnonymousStyleWithDisplay(&style(), FLEX));
     107        RenderPtr<RenderMathMLRadicalOperator> radicalOperator = createRenderer<RenderMathMLRadicalOperator>(document(), RenderStyle::createAnonymousStyleWithDisplay(style(), FLEX));
    108108        radicalOperator->initializeStyle();
    109109        radical->addChild(radicalOperator.leakPtr());
    … …  
    221221
    222222    auto radical = radicalWrapper();
    223     auto radicalStyle = RenderStyle::createAnonymousStyleWithDisplay(&style(), FLEX);
    224     radicalStyle->setMarginTop(Length(0, Fixed)); // This will be updated in RenderMathMLRoot::layout().
     223    auto radicalStyle = RenderStyle::createAnonymousStyleWithDisplay(style(), FLEX);
     224    radicalStyle.setMarginTop(Length(0, Fixed)); // This will be updated in RenderMathMLRoot::layout().
    225225    radical->setStyle(WTFMove(radicalStyle));
    226226    radical->setNeedsLayoutAndPrefWidthsRecalc();
    227227
    228228    auto base = baseWrapper();
    229     auto baseStyle = RenderStyle::createAnonymousStyleWithDisplay(&style(), FLEX);
    230     baseStyle->setMarginTop(Length(0, Fixed)); // This will be updated in RenderMathMLRoot::layout().
    231     baseStyle->setAlignItemsPosition(ItemPositionBaseline);
     229    auto baseStyle = RenderStyle::createAnonymousStyleWithDisplay(style(), FLEX);
     230    baseStyle.setMarginTop(Length(0, Fixed)); // This will be updated in RenderMathMLRoot::layout().
     231    baseStyle.setAlignItemsPosition(ItemPositionBaseline);
    232232    base->setStyle(WTFMove(baseStyle));
    233233    base->setNeedsLayoutAndPrefWidthsRecalc();
    … …  
    236236        // For mroot, we also set the style of the index wrapper.
    237237        auto index = indexWrapper();
    238         auto indexStyle = RenderStyle::createAnonymousStyleWithDisplay(&style(), FLEX);
    239         indexStyle->setMarginTop(Length(0, Fixed)); // This will be updated in RenderMathMLRoot::layout().
    240         indexStyle->setMarginStart(Length(kernBeforeDegree, Fixed));
    241         indexStyle->setMarginEnd(Length(kernAfterDegree, Fixed));
    242         indexStyle->setAlignItemsPosition(ItemPositionBaseline);
     238        auto indexStyle = RenderStyle::createAnonymousStyleWithDisplay(style(), FLEX);
     239        indexStyle.setMarginTop(Length(0, Fixed)); // This will be updated in RenderMathMLRoot::layout().
     240        indexStyle.setMarginStart(Length(kernBeforeDegree, Fixed));
     241        indexStyle.setMarginEnd(Length(kernAfterDegree, Fixed));
     242        indexStyle.setAlignItemsPosition(ItemPositionBaseline);
    243243        index->setStyle(WTFMove(indexStyle));
    244244        index->setNeedsLayoutAndPrefWidthsRecalc();
    … …  
    338338RenderPtr<RenderMathMLRootWrapper> RenderMathMLRootWrapper::createAnonymousWrapper(RenderMathMLRoot* renderObject)
    339339{
    340     RenderPtr<RenderMathMLRootWrapper> newBlock = createRenderer<RenderMathMLRootWrapper>(renderObject->document(), RenderStyle::createAnonymousStyleWithDisplay(&renderObject->style(), FLEX));
     340    RenderPtr<RenderMathMLRootWrapper> newBlock = createRenderer<RenderMathMLRootWrapper>(renderObject->document(), RenderStyle::createAnonymousStyleWithDisplay(renderObject->style(), FLEX));
    341341    newBlock->initializeStyle();
    342342    return newBlock;

  • trunk/Source/WebCore/rendering/mathml/RenderMathMLRoot.h

    r199980 r200041  
    4343
    4444public:
    45     RenderMathMLRoot(Element&, std::unique_ptr<RenderStyle>);
     45    RenderMathMLRoot(Element&, RenderStyle&&);
    4646
    4747    void addChild(RenderObject* newChild, RenderObject* beforeChild = 0) override;
    … …  
    7979
    8080public:
    81     RenderMathMLRootWrapper(Document& document, std::unique_ptr<RenderStyle> style)
     81    RenderMathMLRootWrapper(Document& document, RenderStyle&& style)
    8282        : RenderMathMLRow(document, WTFMove(style)) { }
    8383

  • trunk/Source/WebCore/rendering/mathml/RenderMathMLRow.cpp

    r199980 r200041  
    4040using namespace MathMLNames;
    4141
    42 RenderMathMLRow::RenderMathMLRow(Element& element, std::unique_ptr<RenderStyle> style)
     42RenderMathMLRow::RenderMathMLRow(Element& element, RenderStyle&& style)
    4343    : RenderMathMLBlock(element, WTFMove(style))
    4444{
    4545}
    4646
    47 RenderMathMLRow::RenderMathMLRow(Document& document, std::unique_ptr<RenderStyle> style)
     47RenderMathMLRow::RenderMathMLRow(Document& document, RenderStyle&& style)
    4848    : RenderMathMLBlock(document, WTFMove(style))
    4949{

  • trunk/Source/WebCore/rendering/mathml/RenderMathMLRow.h

    r199980 r200041  
    3838class RenderMathMLRow : public RenderMathMLBlock {
    3939public:
    40     RenderMathMLRow(Element&, std::unique_ptr<RenderStyle>);
    41     RenderMathMLRow(Document&, std::unique_ptr<RenderStyle>);
     40    RenderMathMLRow(Element&, RenderStyle&&);
     41    RenderMathMLRow(Document&, RenderStyle&&);
    4242
    4343    void updateOperatorProperties();

  • trunk/Source/WebCore/rendering/mathml/RenderMathMLScripts.cpp

    r199964 r200041  
    4444}
    4545
    46 RenderMathMLScripts::RenderMathMLScripts(Element& element, std::unique_ptr<RenderStyle> style)
     46RenderMathMLScripts::RenderMathMLScripts(Element& element, RenderStyle&& style)
    4747    : RenderMathMLBlock(element, WTFMove(style))
    4848{

  • trunk/Source/WebCore/rendering/mathml/RenderMathMLScripts.h

    r199964 r200041  
    3737class RenderMathMLScripts final : public RenderMathMLBlock {
    3838public:
    39     RenderMathMLScripts(Element&, std::unique_ptr<RenderStyle>);
     39    RenderMathMLScripts(Element&, RenderStyle&&);
    4040    RenderMathMLOperator* unembellishedOperator() final;
    4141    Optional<int> firstLineBaseline() const final;

  • trunk/Source/WebCore/rendering/mathml/RenderMathMLSpace.cpp

    r199964 r200041  
    3737using namespace MathMLNames;
    3838
    39 RenderMathMLSpace::RenderMathMLSpace(MathMLTextElement& element, std::unique_ptr<RenderStyle> style)
     39RenderMathMLSpace::RenderMathMLSpace(MathMLTextElement& element, RenderStyle&& style)
    4040    : RenderMathMLBlock(element, WTFMove(style))
    4141    , m_width(0)

  • trunk/Source/WebCore/rendering/mathml/RenderMathMLSpace.h

    r199964 r200041  
    3636class RenderMathMLSpace final : public RenderMathMLBlock {
    3737public:
    38     RenderMathMLSpace(MathMLTextElement&, std::unique_ptr<RenderStyle>);
     38    RenderMathMLSpace(MathMLTextElement&, RenderStyle&&);
    3939    MathMLTextElement& element() { return static_cast<MathMLTextElement&>(nodeForNonAnonymous()); }
    4040

  • trunk/Source/WebCore/rendering/mathml/RenderMathMLSquareRoot.cpp

    r199980 r200041  
    3535namespace WebCore {
    3636   
    37 RenderMathMLSquareRoot::RenderMathMLSquareRoot(Element& element, std::unique_ptr<RenderStyle> style)
     37RenderMathMLSquareRoot::RenderMathMLSquareRoot(Element& element, RenderStyle&& style)
    3838    : RenderMathMLRoot(element, WTFMove(style))
    3939{

  • trunk/Source/WebCore/rendering/mathml/RenderMathMLSquareRoot.h

    r199980 r200041  
    3939class RenderMathMLSquareRoot final : public RenderMathMLRoot {
    4040public:
    41     RenderMathMLSquareRoot(Element&, std::unique_ptr<RenderStyle>);
    42     static RenderPtr<RenderMathMLSquareRoot> createAnonymousWithParentRenderer(RenderMathMLMenclose&);
     41    RenderMathMLSquareRoot(Element&, RenderStyle&&);
    4342   
    4443private:

  • trunk/Source/WebCore/rendering/mathml/RenderMathMLToken.cpp

    r199964 r200041  
    3737using namespace MathMLNames;
    3838
    39 RenderMathMLToken::RenderMathMLToken(Element& element, std::unique_ptr<RenderStyle> style)
     39RenderMathMLToken::RenderMathMLToken(Element& element, RenderStyle&& style)
    4040    : RenderMathMLBlock(element, WTFMove(style))
    4141    , m_containsElement(false)
    … …  
    4343}
    4444
    45 RenderMathMLToken::RenderMathMLToken(Document& document, std::unique_ptr<RenderStyle> style)
     45RenderMathMLToken::RenderMathMLToken(Document& document, RenderStyle&& style)
    4646    : RenderMathMLBlock(document, WTFMove(style))
    4747    , m_containsElement(false)
    … …  
    8383
    8484    const auto& wrapper = downcast<RenderElement>(firstChild());
    85     auto newStyle = RenderStyle::createAnonymousStyleWithDisplay(&style(), FLEX);
     85    auto newStyle = RenderStyle::createAnonymousStyleWithDisplay(style(), FLEX);
    8686
    8787    if (tokenElement.hasTagName(MathMLNames::miTag)) {
    8888        // This tries to emulate the default mathvariant value on <mi> using the CSS font-style property.
    8989        // FIXME: This should be revised when mathvariant is implemented (http://wkbug/85735) and when fonts with Mathematical Alphanumeric Symbols characters are more popular.
    90         auto fontDescription = newStyle->fontDescription();
    91         FontSelector* fontSelector = newStyle->fontCascade().fontSelector();
     90        auto fontDescription = newStyle.fontDescription();
     91        FontSelector* fontSelector = newStyle.fontCascade().fontSelector();
    9292        if (!m_containsElement && element().textContent().stripWhiteSpace().simplifyWhiteSpace().length() == 1 && !tokenElement.hasAttribute(mathvariantAttr))
    9393            fontDescription.setItalic(FontItalicOn);
    94         if (newStyle->setFontDescription(fontDescription))
    95             newStyle->fontCascade().update(fontSelector);
     94        if (newStyle.setFontDescription(fontDescription))
     95            newStyle.fontCascade().update(fontSelector);
    9696    }
    9797

  • trunk/Source/WebCore/rendering/mathml/RenderMathMLToken.h

    r199964 r200041  
    3737class RenderMathMLToken : public RenderMathMLBlock {
    3838public:
    39     RenderMathMLToken(Element&, std::unique_ptr<RenderStyle>);
    40     RenderMathMLToken(Document&, std::unique_ptr<RenderStyle>);
     39    RenderMathMLToken(Element&, RenderStyle&&);
     40    RenderMathMLToken(Document&, RenderStyle&&);
    4141
    4242    MathMLTextElement& element() { return static_cast<MathMLTextElement&>(nodeForNonAnonymous()); }

  • trunk/Source/WebCore/rendering/mathml/RenderMathMLUnderOver.cpp

    r199964 r200041  
    4040using namespace MathMLNames;
    4141   
    42 RenderMathMLUnderOver::RenderMathMLUnderOver(Element& element, std::unique_ptr<RenderStyle> style)
     42RenderMathMLUnderOver::RenderMathMLUnderOver(Element& element, RenderStyle&& style)
    4343    : RenderMathMLBlock(element, WTFMove(style))
    4444{

  • trunk/Source/WebCore/rendering/mathml/RenderMathMLUnderOver.h

    r199964 r200041  
    3636class RenderMathMLUnderOver final : public RenderMathMLBlock {
    3737public:
    38     RenderMathMLUnderOver(Element&, std::unique_ptr<RenderStyle>);
     38    RenderMathMLUnderOver(Element&, RenderStyle&&);
    3939   
    4040    RenderMathMLOperator* unembellishedOperator() override;

  • trunk/Source/WebCore/rendering/style/RenderStyle.cpp

    r199964 r200041  
    8787COMPILE_ASSERT(sizeof(RenderStyle) == sizeof(SameSizeAsRenderStyle), RenderStyle_should_stay_small);
    8888
    89 inline RenderStyle& defaultStyle()
    90 {
    91     static RenderStyle& style = *RenderStyle::createDefaultStyle().release();
     89RenderStyle& RenderStyle::defaultStyle()
     90{
     91    static RenderStyle& style = *new RenderStyle(CreateDefaultStyle);
    9292    return style;
    9393}
    9494
    95 std::unique_ptr<RenderStyle> RenderStyle::create()
    96 {
    97     return clone(&defaultStyle());
    98 }
    99 
    100 std::unique_ptr<RenderStyle> RenderStyle::createDefaultStyle()
    101 {
    102     return std::unique_ptr<RenderStyle>(new RenderStyle(true));
    103 }
    104 
    105 std::unique_ptr<RenderStyle> RenderStyle::createAnonymousStyleWithDisplay(const RenderStyle* parentStyle, EDisplay display)
    106 {
    107     auto newStyle = RenderStyle::create();
    108     newStyle->inheritFrom(parentStyle);
    109     newStyle->inheritUnicodeBidiFrom(parentStyle);
    110     newStyle->setDisplay(display);
     95RenderStyle RenderStyle::create()
     96{
     97    return clone(defaultStyle());
     98}
     99
     100std::unique_ptr<RenderStyle> RenderStyle::createPtr()
     101{
     102    return clonePtr(defaultStyle());
     103}
     104
     105RenderStyle RenderStyle::clone(const RenderStyle& style)
     106{
     107    return RenderStyle(style, Clone);
     108}
     109
     110std::unique_ptr<RenderStyle> RenderStyle::clonePtr(const RenderStyle& style)
     111{
     112    return std::make_unique<RenderStyle>(style, Clone);
     113}
     114
     115RenderStyle RenderStyle::createAnonymousStyleWithDisplay(const RenderStyle& parentStyle, EDisplay display)
     116{
     117    auto newStyle = create();
     118    newStyle.inheritFrom(&parentStyle);
     119    newStyle.inheritUnicodeBidiFrom(&parentStyle);
     120    newStyle.setDisplay(display);
    111121    return newStyle;
    112122}
    113123
    114 std::unique_ptr<RenderStyle> RenderStyle::clone(const RenderStyle* other)
    115 {
    116     return std::unique_ptr<RenderStyle>(new RenderStyle(*other));
    117 }
    118 
    119 std::unique_ptr<RenderStyle> RenderStyle::createStyleInheritingFromPseudoStyle(const RenderStyle& pseudoStyle)
     124RenderStyle RenderStyle::createStyleInheritingFromPseudoStyle(const RenderStyle& pseudoStyle)
    120125{
    121126    ASSERT(pseudoStyle.styleType() == BEFORE || pseudoStyle.styleType() == AFTER);
    122127
    123     auto style = RenderStyle::create();
    124     style->inheritFrom(&pseudoStyle);
     128    auto style = create();
     129    style.inheritFrom(&pseudoStyle);
    125130    return style;
    126131}
    127132
    128 ALWAYS_INLINE RenderStyle::RenderStyle(bool)
     133RenderStyle::RenderStyle(CreateDefaultStyleTag)
    129134    : m_box(StyleBoxData::create())
    130135    , visual(StyleVisualData::create())
    … …  
    163168}
    164169
    165 ALWAYS_INLINE RenderStyle::RenderStyle(const RenderStyle& o)
    166     : m_box(o.m_box)
    167     , visual(o.visual)
    168     , m_background(o.m_background)
    169     , surround(o.surround)
    170     , rareNonInheritedData(o.rareNonInheritedData)
    171     , rareInheritedData(o.rareInheritedData)
    172     , inherited(o.inherited)
    173     , m_svgStyle(o.m_svgStyle)
    174     , inherited_flags(o.inherited_flags)
    175     , noninherited_flags(o.noninherited_flags)
     170RenderStyle::RenderStyle(const RenderStyle& other, CloneTag)
     171    : m_box(other.m_box)
     172    , visual(other.visual)
     173    , m_background(other.m_background)
     174    , surround(other.surround)
     175    , rareNonInheritedData(other.rareNonInheritedData)
     176    , rareInheritedData(other.rareInheritedData)
     177    , inherited(other.inherited)
     178    , m_svgStyle(other.m_svgStyle)
     179    , inherited_flags(other.inherited_flags)
     180    , noninherited_flags(other.noninherited_flags)
    176181{
    177182}

  • trunk/Source/WebCore/rendering/style/RenderStyle.h

    r199964 r200041  
    5858#include "StyleFilterData.h"
    5959#include "StyleFlexibleBoxData.h"
     60#include "StyleInheritedData.h"
    6061#include "StyleMarqueeData.h"
    6162#include "StyleMultiColData.h"
    … …  
    480481// !END SYNC!
    481482private:
    482     // used to create the default style.
    483     ALWAYS_INLINE RenderStyle(bool);
    484     ALWAYS_INLINE RenderStyle(const RenderStyle&);
     483    enum CreateDefaultStyleTag { CreateDefaultStyle };
     484    RenderStyle(CreateDefaultStyleTag);
     485
     486    static RenderStyle& defaultStyle();
    485487
    486488public:
    487     static std::unique_ptr<RenderStyle> create();
    488     static std::unique_ptr<RenderStyle> createDefaultStyle();
    489     static std::unique_ptr<RenderStyle> createAnonymousStyleWithDisplay(const RenderStyle* parentStyle, EDisplay);
    490     static std::unique_ptr<RenderStyle> clone(const RenderStyle*);
     489    RenderStyle(RenderStyle&&) = default;
     490    RenderStyle& operator=(RenderStyle&&) = default;
     491
     492    // This is not a true copy constructor. It doesn't copy pseudo style caches for example.
     493    enum CloneTag { Clone };
     494    RenderStyle(const RenderStyle&, CloneTag);
    491495
    492496    ~RenderStyle();
    493497
    494     // Create a RenderStyle for generated content by inheriting from a pseudo style.
    495     static std::unique_ptr<RenderStyle> createStyleInheritingFromPseudoStyle(const RenderStyle& pseudoStyle);
     498    static RenderStyle create();
     499    static std::unique_ptr<RenderStyle> createPtr();
     500
     501    static RenderStyle clone(const RenderStyle&);
     502    static std::unique_ptr<RenderStyle> clonePtr(const RenderStyle&);
     503
     504    static RenderStyle createAnonymousStyleWithDisplay(const RenderStyle& parentStyle, EDisplay);
     505    static RenderStyle createStyleInheritingFromPseudoStyle(const RenderStyle& pseudoStyle);
    496506
    497507    ContentPosition resolvedJustifyContentPosition(const StyleContentAlignmentData& normalValueBehavior) const;

  • trunk/Source/WebCore/rendering/svg/RenderSVGBlock.cpp

    r199964 r200041  
    2929namespace WebCore {
    3030
    31 RenderSVGBlock::RenderSVGBlock(SVGGraphicsElement& element, std::unique_ptr<RenderStyle> style)
     31RenderSVGBlock::RenderSVGBlock(SVGGraphicsElement& element, RenderStyle&& style)
    3232    : RenderBlockFlow(element, WTFMove(style))
    3333{

  • trunk/Source/WebCore/rendering/svg/RenderSVGBlock.h

    r199964 r200041  
    3636
    3737protected:
    38     RenderSVGBlock(SVGGraphicsElement&, std::unique_ptr<RenderStyle>);
     38    RenderSVGBlock(SVGGraphicsElement&, RenderStyle&&);
    3939    void willBeDestroyed() override;
    4040

  • trunk/Source/WebCore/rendering/svg/RenderSVGContainer.cpp

    r199964 r200041  
    3838namespace WebCore {
    3939
    40 RenderSVGContainer::RenderSVGContainer(SVGElement& element, std::unique_ptr<RenderStyle> style)
     40RenderSVGContainer::RenderSVGContainer(SVGElement& element, RenderStyle&& style)
    4141    : RenderSVGModelObject(element, WTFMove(style))
    4242    , m_objectBoundingBoxValid(false)

  • trunk/Source/WebCore/rendering/svg/RenderSVGContainer.h

    r199964 r200041  
    4141
    4242protected:
    43     RenderSVGContainer(SVGElement&, std::unique_ptr<RenderStyle>);
     43    RenderSVGContainer(SVGElement&, RenderStyle&&);
    4444
    4545    const char* renderName() const override { return "RenderSVGContainer"; }

  • trunk/Source/WebCore/rendering/svg/RenderSVGEllipse.cpp

    r199964 r200041  
    3434namespace WebCore {
    3535
    36 RenderSVGEllipse::RenderSVGEllipse(SVGGraphicsElement& element, std::unique_ptr<RenderStyle> style)
     36RenderSVGEllipse::RenderSVGEllipse(SVGGraphicsElement& element, RenderStyle&& style)
    3737    : RenderSVGShape(element, WTFMove(style))
    3838    , m_usePathFallback(false)

  • trunk/Source/WebCore/rendering/svg/RenderSVGEllipse.h

    r199964 r200041  
    3434class RenderSVGEllipse final : public RenderSVGShape {
    3535public:
    36     RenderSVGEllipse(SVGGraphicsElement&, std::unique_ptr<RenderStyle>);
     36    RenderSVGEllipse(SVGGraphicsElement&, RenderStyle&&);
    3737    virtual ~RenderSVGEllipse();
    3838

  • trunk/Source/WebCore/rendering/svg/RenderSVGForeignObject.cpp

    r199964 r200041  
    3737namespace WebCore {
    3838
    39 RenderSVGForeignObject::RenderSVGForeignObject(SVGForeignObjectElement& element, std::unique_ptr<RenderStyle> style)
     39RenderSVGForeignObject::RenderSVGForeignObject(SVGForeignObjectElement& element, RenderStyle&& style)
    4040    : RenderSVGBlock(element, WTFMove(style))
    4141    , m_needsTransformUpdate(true)

  • trunk/Source/WebCore/rendering/svg/RenderSVGForeignObject.h

    r199964 r200041  
    3333class RenderSVGForeignObject final : public RenderSVGBlock {
    3434public:
    35     RenderSVGForeignObject(SVGForeignObjectElement&, std::unique_ptr<RenderStyle>);
     35    RenderSVGForeignObject(SVGForeignObjectElement&, RenderStyle&&);
    3636    virtual ~RenderSVGForeignObject();
    3737

  • trunk/Source/WebCore/rendering/svg/RenderSVGGradientStop.cpp

    r199964 r200041  
    3232using namespace SVGNames;
    3333
    34 RenderSVGGradientStop::RenderSVGGradientStop(SVGStopElement& element, std::unique_ptr<RenderStyle> style)
     34RenderSVGGradientStop::RenderSVGGradientStop(SVGStopElement& element, RenderStyle&& style)
    3535    : RenderElement(element, WTFMove(style), 0)
    3636{

  • trunk/Source/WebCore/rendering/svg/RenderSVGGradientStop.h

    r199964 r200041  
    3333class RenderSVGGradientStop final : public RenderElement {
    3434public:
    35     RenderSVGGradientStop(SVGStopElement&, std::unique_ptr<RenderStyle>);
     35    RenderSVGGradientStop(SVGStopElement&, RenderStyle&&);
    3636    virtual ~RenderSVGGradientStop();
    3737

  • trunk/Source/WebCore/rendering/svg/RenderSVGHiddenContainer.cpp

    r199964 r200041  
    2626namespace WebCore {
    2727
    28 RenderSVGHiddenContainer::RenderSVGHiddenContainer(SVGElement& element, std::unique_ptr<RenderStyle> style)
     28RenderSVGHiddenContainer::RenderSVGHiddenContainer(SVGElement& element, RenderStyle&& style)
    2929    : RenderSVGContainer(element, WTFMove(style))
    3030{

  • trunk/Source/WebCore/rendering/svg/RenderSVGHiddenContainer.h

    r199964 r200041  
    3131class RenderSVGHiddenContainer : public RenderSVGContainer {
    3232public:
    33     RenderSVGHiddenContainer(SVGElement&, std::unique_ptr<RenderStyle>);
     33    RenderSVGHiddenContainer(SVGElement&, RenderStyle&&);
    3434
    3535protected:

  • trunk/Source/WebCore/rendering/svg/RenderSVGImage.cpp

    r199964 r200041  
    4444namespace WebCore {
    4545
    46 RenderSVGImage::RenderSVGImage(SVGImageElement& element, std::unique_ptr<RenderStyle> style)
     46RenderSVGImage::RenderSVGImage(SVGImageElement& element, RenderStyle&& style)
    4747    : RenderSVGModelObject(element, WTFMove(style))
    4848    , m_needsBoundariesUpdate(true)

  • trunk/Source/WebCore/rendering/svg/RenderSVGImage.h

    r199964 r200041  
    3737class RenderSVGImage final : public RenderSVGModelObject {
    3838public:
    39     RenderSVGImage(SVGImageElement&, std::unique_ptr<RenderStyle>);
     39    RenderSVGImage(SVGImageElement&, RenderStyle&&);
    4040    virtual ~RenderSVGImage();
    4141

  • trunk/Source/WebCore/rendering/svg/RenderSVGInline.cpp

    r199964 r200041  
    3131namespace WebCore {
    3232   
    33 RenderSVGInline::RenderSVGInline(SVGGraphicsElement& element, std::unique_ptr<RenderStyle> style)
     33RenderSVGInline::RenderSVGInline(SVGGraphicsElement& element, RenderStyle&& style)
    3434    : RenderInline(element, WTFMove(style))
    3535{

  • trunk/Source/WebCore/rendering/svg/RenderSVGInline.h

    r199964 r200041  
    2929class RenderSVGInline : public RenderInline {
    3030public:
    31     RenderSVGInline(SVGGraphicsElement&, std::unique_ptr<RenderStyle>);
     31    RenderSVGInline(SVGGraphicsElement&, RenderStyle&&);
    3232
    3333    SVGGraphicsElement& graphicsElement() const { return downcast<SVGGraphicsElement>(nodeForNonAnonymous()); }

  • trunk/Source/WebCore/rendering/svg/RenderSVGModelObject.cpp

    r199964 r200041  
    4040namespace WebCore {
    4141
    42 RenderSVGModelObject::RenderSVGModelObject(SVGElement& element, std::unique_ptr<RenderStyle> style)
     42RenderSVGModelObject::RenderSVGModelObject(SVGElement& element, RenderStyle&& style)
    4343    : RenderElement(element, WTFMove(style), 0)
    4444    , m_hasSVGShadow(false)

  • trunk/Source/WebCore/rendering/svg/RenderSVGModelObject.h

    r199964 r200041  
    6868
    6969protected:
    70     RenderSVGModelObject(SVGElement&, std::unique_ptr<RenderStyle>);
     70    RenderSVGModelObject(SVGElement&, RenderStyle&&);
    7171
    7272    void willBeDestroyed() override;

  • trunk/Source/WebCore/rendering/svg/RenderSVGPath.cpp

    r199964 r200041  
    3434namespace WebCore {
    3535
    36 RenderSVGPath::RenderSVGPath(SVGGraphicsElement& element, std::unique_ptr<RenderStyle> style)
     36RenderSVGPath::RenderSVGPath(SVGGraphicsElement& element, RenderStyle&& style)
    3737    : RenderSVGShape(element, WTFMove(style))
    3838{

  • trunk/Source/WebCore/rendering/svg/RenderSVGPath.h

    r199964 r200041  
    3333class RenderSVGPath final : public RenderSVGShape {
    3434public:
    35     RenderSVGPath(SVGGraphicsElement&, std::unique_ptr<RenderStyle>);
     35    RenderSVGPath(SVGGraphicsElement&, RenderStyle&&);
    3636    virtual ~RenderSVGPath();
    3737

  • trunk/Source/WebCore/rendering/svg/RenderSVGRect.cpp

    r199964 r200041  
    3333namespace WebCore {
    3434
    35 RenderSVGRect::RenderSVGRect(SVGRectElement& element, std::unique_ptr<RenderStyle> style)
     35RenderSVGRect::RenderSVGRect(SVGRectElement& element, RenderStyle&& style)
    3636    : RenderSVGShape(element, WTFMove(style))
    3737    , m_usePathFallback(false)

  • trunk/Source/WebCore/rendering/svg/RenderSVGRect.h

    r199964 r200041  
    3636class RenderSVGRect final : public RenderSVGShape {
    3737public:
    38     RenderSVGRect(SVGRectElement&, std::unique_ptr<RenderStyle>);
     38    RenderSVGRect(SVGRectElement&, RenderStyle&&);
    3939    virtual ~RenderSVGRect();
    4040

  • trunk/Source/WebCore/rendering/svg/RenderSVGResourceClipper.cpp

    r199964 r200041  
    4141namespace WebCore {
    4242
    43 RenderSVGResourceClipper::RenderSVGResourceClipper(SVGClipPathElement& element, std::unique_ptr<RenderStyle> style)
     43RenderSVGResourceClipper::RenderSVGResourceClipper(SVGClipPathElement& element, RenderStyle&& style)
    4444    : RenderSVGResourceContainer(element, WTFMove(style))
    4545{

  • trunk/Source/WebCore/rendering/svg/RenderSVGResourceClipper.h

    r199964 r200041  
    3636class RenderSVGResourceClipper final : public RenderSVGResourceContainer {
    3737public:
    38     RenderSVGResourceClipper(SVGClipPathElement&, std::unique_ptr<RenderStyle>);
     38    RenderSVGResourceClipper(SVGClipPathElement&, RenderStyle&&);
    3939    virtual ~RenderSVGResourceClipper();
    4040

  • trunk/Source/WebCore/rendering/svg/RenderSVGResourceContainer.cpp

    r199964 r200041  
    3535}
    3636
    37 RenderSVGResourceContainer::RenderSVGResourceContainer(SVGElement& element, std::unique_ptr<RenderStyle> style)
     37RenderSVGResourceContainer::RenderSVGResourceContainer(SVGElement& element, RenderStyle&& style)
    3838    : RenderSVGHiddenContainer(element, WTFMove(style))
    3939    , m_id(element.getIdAttribute())

  • trunk/Source/WebCore/rendering/svg/RenderSVGResourceContainer.h

    r199964 r200041  
    4646
    4747protected:
    48     RenderSVGResourceContainer(SVGElement&, std::unique_ptr<RenderStyle>);
     48    RenderSVGResourceContainer(SVGElement&, RenderStyle&&);
    4949
    5050    enum InvalidationMode {

  • trunk/Source/WebCore/rendering/svg/RenderSVGResourceFilter.cpp

    r199964 r200041  
    4444namespace WebCore {
    4545
    46 RenderSVGResourceFilter::RenderSVGResourceFilter(SVGFilterElement& element, std::unique_ptr<RenderStyle> style)
     46RenderSVGResourceFilter::RenderSVGResourceFilter(SVGFilterElement& element, RenderStyle&& style)
    4747    : RenderSVGResourceContainer(element, WTFMove(style))
    4848{

  • trunk/Source/WebCore/rendering/svg/RenderSVGResourceFilter.h

    r199964 r200041  
    6363class RenderSVGResourceFilter final : public RenderSVGResourceContainer {
    6464public:
    65     RenderSVGResourceFilter(SVGFilterElement&, std::unique_ptr<RenderStyle>);
     65    RenderSVGResourceFilter(SVGFilterElement&, RenderStyle&&);
    6666    virtual ~RenderSVGResourceFilter();
    6767

  • trunk/Source/WebCore/rendering/svg/RenderSVGResourceFilterPrimitive.cpp

    r199964 r200041  
    3838namespace WebCore {
    3939
    40 RenderSVGResourceFilterPrimitive::RenderSVGResourceFilterPrimitive(SVGFilterPrimitiveStandardAttributes& filterPrimitiveElement, std::unique_ptr<RenderStyle> style)
     40RenderSVGResourceFilterPrimitive::RenderSVGResourceFilterPrimitive(SVGFilterPrimitiveStandardAttributes& filterPrimitiveElement, RenderStyle&& style)
    4141    : RenderSVGHiddenContainer(filterPrimitiveElement, WTFMove(style))
    4242{

  • trunk/Source/WebCore/rendering/svg/RenderSVGResourceFilterPrimitive.h

    r199964 r200041  
    3737class RenderSVGResourceFilterPrimitive final : public RenderSVGHiddenContainer {
    3838public:
    39     RenderSVGResourceFilterPrimitive(SVGFilterPrimitiveStandardAttributes&, std::unique_ptr<RenderStyle>);
     39    RenderSVGResourceFilterPrimitive(SVGFilterPrimitiveStandardAttributes&, RenderStyle&&);
    4040    SVGFilterPrimitiveStandardAttributes& filterPrimitiveElement() const;
    4141

  • trunk/Source/WebCore/rendering/svg/RenderSVGResourceGradient.cpp

    r199964 r200041  
    3131namespace WebCore {
    3232
    33 RenderSVGResourceGradient::RenderSVGResourceGradient(SVGGradientElement& node, std::unique_ptr<RenderStyle> style)
     33RenderSVGResourceGradient::RenderSVGResourceGradient(SVGGradientElement& node, RenderStyle&& style)
    3434    : RenderSVGResourceContainer(node, WTFMove(style))
    3535    , m_shouldCollectGradientAttributes(true)

  • trunk/Source/WebCore/rendering/svg/RenderSVGResourceGradient.h

    r199964 r200041  
    5353
    5454protected:
    55     RenderSVGResourceGradient(SVGGradientElement&, std::unique_ptr<RenderStyle>);
     55    RenderSVGResourceGradient(SVGGradientElement&, RenderStyle&&);
    5656
    5757    void element() const = delete;

  • trunk/Source/WebCore/rendering/svg/RenderSVGResourceLinearGradient.cpp

    r199964 r200041  
    2525namespace WebCore {
    2626
    27 RenderSVGResourceLinearGradient::RenderSVGResourceLinearGradient(SVGLinearGradientElement& element, std::unique_ptr<RenderStyle> style)
     27RenderSVGResourceLinearGradient::RenderSVGResourceLinearGradient(SVGLinearGradientElement& element, RenderStyle&& style)
    2828    : RenderSVGResourceGradient(element, WTFMove(style))
    2929{

  • trunk/Source/WebCore/rendering/svg/RenderSVGResourceLinearGradient.h

    r199964 r200041  
    3030class RenderSVGResourceLinearGradient final : public RenderSVGResourceGradient {
    3131public:
    32     RenderSVGResourceLinearGradient(SVGLinearGradientElement&, std::unique_ptr<RenderStyle>);
     32    RenderSVGResourceLinearGradient(SVGLinearGradientElement&, RenderStyle&&);
    3333    virtual ~RenderSVGResourceLinearGradient();
    3434

  • trunk/Source/WebCore/rendering/svg/RenderSVGResourceMarker.cpp

    r199964 r200041  
    2929namespace WebCore {
    3030
    31 RenderSVGResourceMarker::RenderSVGResourceMarker(SVGMarkerElement& element, std::unique_ptr<RenderStyle> style)
     31RenderSVGResourceMarker::RenderSVGResourceMarker(SVGMarkerElement& element, RenderStyle&& style)
    3232    : RenderSVGResourceContainer(element, WTFMove(style))
    3333{

  • trunk/Source/WebCore/rendering/svg/RenderSVGResourceMarker.h

    r199964 r200041  
    3333class RenderSVGResourceMarker final : public RenderSVGResourceContainer {
    3434public:
    35     RenderSVGResourceMarker(SVGMarkerElement&, std::unique_ptr<RenderStyle>);
     35    RenderSVGResourceMarker(SVGMarkerElement&, RenderStyle&&);
    3636    virtual ~RenderSVGResourceMarker();
    3737

  • trunk/Source/WebCore/rendering/svg/RenderSVGResourceMasker.cpp

    r199964 r200041  
    3030namespace WebCore {
    3131
    32 RenderSVGResourceMasker::RenderSVGResourceMasker(SVGMaskElement& element, std::unique_ptr<RenderStyle> style)
     32RenderSVGResourceMasker::RenderSVGResourceMasker(SVGMaskElement& element, RenderStyle&& style)
    3333    : RenderSVGResourceContainer(element, WTFMove(style))
    3434{

  • trunk/Source/WebCore/rendering/svg/RenderSVGResourceMasker.h

    r199964 r200041  
    3838class RenderSVGResourceMasker final : public RenderSVGResourceContainer {
    3939public:
    40     RenderSVGResourceMasker(SVGMaskElement&, std::unique_ptr<RenderStyle>);
     40    RenderSVGResourceMasker(SVGMaskElement&, RenderStyle&&);
    4141    virtual ~RenderSVGResourceMasker();
    4242

  • trunk/Source/WebCore/rendering/svg/RenderSVGResourcePattern.cpp

    r199964 r200041  
    3333namespace WebCore {
    3434
    35 RenderSVGResourcePattern::RenderSVGResourcePattern(SVGPatternElement& element, std::unique_ptr<RenderStyle> style)
     35RenderSVGResourcePattern::RenderSVGResourcePattern(SVGPatternElement& element, RenderStyle&& style)
    3636    : RenderSVGResourceContainer(element, WTFMove(style))
    3737    , m_shouldCollectPatternAttributes(true)

  • trunk/Source/WebCore/rendering/svg/RenderSVGResourcePattern.h

    r199964 r200041  
    4242class RenderSVGResourcePattern final : public RenderSVGResourceContainer {
    4343public:
    44     RenderSVGResourcePattern(SVGPatternElement&, std::unique_ptr<RenderStyle>);
     44    RenderSVGResourcePattern(SVGPatternElement&, RenderStyle&&);
    4545    SVGPatternElement& patternElement() const;
    4646

  • trunk/Source/WebCore/rendering/svg/RenderSVGResourceRadialGradient.cpp

    r199964 r200041  
    2525namespace WebCore {
    2626
    27 RenderSVGResourceRadialGradient::RenderSVGResourceRadialGradient(SVGRadialGradientElement& element, std::unique_ptr<RenderStyle> style)
     27RenderSVGResourceRadialGradient::RenderSVGResourceRadialGradient(SVGRadialGradientElement& element, RenderStyle&& style)
    2828    : RenderSVGResourceGradient(element, WTFMove(style))
    2929{

  • trunk/Source/WebCore/rendering/svg/RenderSVGResourceRadialGradient.h

    r199964 r200041  
    3232class RenderSVGResourceRadialGradient final : public RenderSVGResourceGradient {
    3333public:
    34     RenderSVGResourceRadialGradient(SVGRadialGradientElement&, std::unique_ptr<RenderStyle>);
     34    RenderSVGResourceRadialGradient(SVGRadialGradientElement&, RenderStyle&&);
    3535    virtual ~RenderSVGResourceRadialGradient();
    3636

  • trunk/Source/WebCore/rendering/svg/RenderSVGRoot.cpp

    r199964 r200041  
    5151namespace WebCore {
    5252
    53 RenderSVGRoot::RenderSVGRoot(SVGSVGElement& element, std::unique_ptr<RenderStyle> style)
     53RenderSVGRoot::RenderSVGRoot(SVGSVGElement& element, RenderStyle&& style)
    5454    : RenderReplaced(element, WTFMove(style))
    5555    , m_objectBoundingBoxValid(false)

  • trunk/Source/WebCore/rendering/svg/RenderSVGRoot.h

    r199964 r200041  
    3737class RenderSVGRoot final : public RenderReplaced {
    3838public:
    39     RenderSVGRoot(SVGSVGElement&, std::unique_ptr<RenderStyle>);
     39    RenderSVGRoot(SVGSVGElement&, RenderStyle&&);
    4040    virtual ~RenderSVGRoot();
    4141

  • trunk/Source/WebCore/rendering/svg/RenderSVGShape.cpp

    r199964 r200041  
    6464};
    6565
    66 RenderSVGShape::RenderSVGShape(SVGGraphicsElement& element, std::unique_ptr<RenderStyle> style)
     66RenderSVGShape::RenderSVGShape(SVGGraphicsElement& element, RenderStyle&& style)
    6767    : RenderSVGModelObject(element, WTFMove(style))
    6868    , m_needsBoundariesUpdate(false) // Default is false, the cached rects are empty from the beginning.

  • trunk/Source/WebCore/rendering/svg/RenderSVGShape.h

    r199964 r200041  
    4646class RenderSVGShape : public RenderSVGModelObject {
    4747public:
    48     RenderSVGShape(SVGGraphicsElement&, std::unique_ptr<RenderStyle>);
     48    RenderSVGShape(SVGGraphicsElement&, RenderStyle&&);
    4949    virtual ~RenderSVGShape();
    5050

  • trunk/Source/WebCore/rendering/svg/RenderSVGTSpan.h

    r199964 r200041  
    2929class RenderSVGTSpan final : public RenderSVGInline {
    3030public:
    31     explicit RenderSVGTSpan(SVGTextPositioningElement& element, std::unique_ptr<RenderStyle> style)
     31    explicit RenderSVGTSpan(SVGTextPositioningElement& element, RenderStyle&& style)
    3232        : RenderSVGInline(element, WTFMove(style))
    3333    {

  • trunk/Source/WebCore/rendering/svg/RenderSVGText.cpp

    r199964 r200041  
    5252namespace WebCore {
    5353
    54 RenderSVGText::RenderSVGText(SVGTextElement& element, std::unique_ptr<RenderStyle> style)
     54RenderSVGText::RenderSVGText(SVGTextElement& element, RenderStyle&& style)
    5555    : RenderSVGBlock(element, WTFMove(style))
    5656    , m_needsReordering(false)

  • trunk/Source/WebCore/rendering/svg/RenderSVGText.h

    r199964 r200041  
    3535class RenderSVGText final : public RenderSVGBlock {
    3636public:
    37     RenderSVGText(SVGTextElement&, std::unique_ptr<RenderStyle>);
     37    RenderSVGText(SVGTextElement&, RenderStyle&&);
    3838    virtual ~RenderSVGText();
    3939

  • trunk/Source/WebCore/rendering/svg/RenderSVGTextPath.cpp

    r199964 r200041  
    3333namespace WebCore {
    3434
    35 RenderSVGTextPath::RenderSVGTextPath(SVGTextPathElement& element, std::unique_ptr<RenderStyle> style)
     35RenderSVGTextPath::RenderSVGTextPath(SVGTextPathElement& element, RenderStyle&& style)
    3636    : RenderSVGInline(element, WTFMove(style))
    3737{

  • trunk/Source/WebCore/rendering/svg/RenderSVGTextPath.h

    r199964 r200041  
    2828class RenderSVGTextPath final : public RenderSVGInline {
    2929public:
    30     RenderSVGTextPath(SVGTextPathElement&, std::unique_ptr<RenderStyle>);
     30    RenderSVGTextPath(SVGTextPathElement&, RenderStyle&&);
    3131
    3232    SVGTextPathElement& textPathElement() const;

  • trunk/Source/WebCore/rendering/svg/RenderSVGTransformableContainer.cpp

    r199964 r200041  
    2828namespace WebCore {
    2929   
    30 RenderSVGTransformableContainer::RenderSVGTransformableContainer(SVGGraphicsElement& element, std::unique_ptr<RenderStyle> style)
     30RenderSVGTransformableContainer::RenderSVGTransformableContainer(SVGGraphicsElement& element, RenderStyle&& style)
    3131    : RenderSVGContainer(element, WTFMove(style))
    3232    , m_needsTransformUpdate(true)

  • trunk/Source/WebCore/rendering/svg/RenderSVGTransformableContainer.h

    r199964 r200041  
    3030class RenderSVGTransformableContainer final : public RenderSVGContainer {
    3131public:
    32     RenderSVGTransformableContainer(SVGGraphicsElement&, std::unique_ptr<RenderStyle>);
     32    RenderSVGTransformableContainer(SVGGraphicsElement&, RenderStyle&&);
    3333    SVGGraphicsElement& graphicsElement() { return downcast<SVGGraphicsElement>(RenderSVGContainer::element()); }
    3434

  • trunk/Source/WebCore/rendering/svg/RenderSVGViewportContainer.cpp

    r199964 r200041  
    3131namespace WebCore {
    3232
    33 RenderSVGViewportContainer::RenderSVGViewportContainer(SVGSVGElement& element, std::unique_ptr<RenderStyle> style)
     33RenderSVGViewportContainer::RenderSVGViewportContainer(SVGSVGElement& element, RenderStyle&& style)
    3434    : RenderSVGContainer(element, WTFMove(style))
    3535    , m_didTransformToRootUpdate(false)

  • trunk/Source/WebCore/rendering/svg/RenderSVGViewportContainer.h

    r199964 r200041  
    3232class RenderSVGViewportContainer final : public RenderSVGContainer {
    3333public:
    34     RenderSVGViewportContainer(SVGSVGElement&, std::unique_ptr<RenderStyle>);
     34    RenderSVGViewportContainer(SVGSVGElement&, RenderStyle&&);
    3535
    3636    SVGSVGElement& svgSVGElement() const;

  • trunk/Source/WebCore/style/RenderTreeUpdater.cpp

    r199964 r200041  
    252252        if (element.hasCustomStyleResolveCallbacks())
    253253            element.willAttachRenderers();
    254         createRenderer(element, WTFMove(update.style));
     254        createRenderer(element, WTFMove(*update.style));
    255255        invalidateWhitespaceOnlyTextSiblingsAfterAttachIfNeeded(element);
    256256        return;
    … …  
    262262
    263263    if (update.isSynthetic) {
    264         renderer.setStyle(WTFMove(update.style), StyleDifferenceRecompositeLayer);
     264        renderer.setStyle(WTFMove(*update.style), StyleDifferenceRecompositeLayer);
    265265        return;
    266266    }
    … …  
    268268    if (update.change == Style::NoChange) {
    269269        if (pseudoStyleCacheIsInvalid(&renderer, update.style.get()) || (parent().styleChange == Style::Force && renderer.requiresForcedStyleRecalcPropagation())) {
    270             renderer.setStyle(WTFMove(update.style), StyleDifferenceEqual);
     270            renderer.setStyle(WTFMove(*update.style), StyleDifferenceEqual);
    271271            return;
    272272        }
    … …  
    274274    }
    275275
    276     renderer.setStyle(WTFMove(update.style), StyleDifferenceEqual);
     276    renderer.setStyle(WTFMove(*update.style), StyleDifferenceEqual);
    277277}
    278278
    … …  
    290290#endif
    291291
    292 void RenderTreeUpdater::createRenderer(Element& element, std::unique_ptr<RenderStyle> style)
     292void RenderTreeUpdater::createRenderer(Element& element, RenderStyle&& style)
    293293{
    294294    if (!shouldCreateRenderer(element, renderTreePosition().parent()))
    … …  
    297297    RenderNamedFlowThread* parentFlowRenderer = nullptr;
    298298#if ENABLE(CSS_REGIONS)
    299     parentFlowRenderer = moveToFlowThreadIfNeeded(element, *style);
     299    parentFlowRenderer = moveToFlowThreadIfNeeded(element, style);
    300300#endif
    301301
    302     if (!element.rendererIsNeeded(*style))
     302    if (!element.rendererIsNeeded(style))
    303303        return;
    304304
    … …  
    327327    newRenderer->animation().updateAnimations(*newRenderer, initialStyle, animatedStyle);
    328328    if (animatedStyle)
    329         newRenderer->setStyleInternal(WTFMove(animatedStyle));
     329        newRenderer->setStyleInternal(WTFMove(*animatedStyle));
    330330
    331331    newRenderer->initializeStyle();
    … …  
    483483    Style::ElementUpdate elementUpdate;
    484484
    485     auto newStyle = RenderStyle::clone(current.renderer()->getCachedPseudoStyle(pseudoId, &current.renderer()->style()));
     485    auto newStyle = RenderStyle::clonePtr(*current.renderer()->getCachedPseudoStyle(pseudoId, &current.renderer()->style()));
    486486
    487487    std::unique_ptr<RenderStyle> animatedStyle;

  • trunk/Source/WebCore/style/RenderTreeUpdater.h

    r199964 r200041  
    5959    void updateTextRenderer(Text&);
    6060    void updateElementRenderer(Element&, Style::ElementUpdate&);
    61     void createRenderer(Element&, std::unique_ptr<RenderStyle>);
     61    void createRenderer(Element&, RenderStyle&&);
    6262    void invalidateWhitespaceOnlyTextSiblingsAfterAttachIfNeeded(Node&);
    6363    void updateBeforeOrAfterPseudoElement(Element&, PseudoId);

  • trunk/Source/WebCore/style/StyleResolveForDocument.cpp

    r199964 r200041  
    4848namespace Style {
    4949
    50 std::unique_ptr<RenderStyle> resolveForDocument(const Document& document)
     50RenderStyle resolveForDocument(const Document& document)
    5151{
    5252    ASSERT(document.hasLivingRenderTree());
    … …  
    5656    auto documentStyle = RenderStyle::create();
    5757
    58     documentStyle->setDisplay(BLOCK);
    59     documentStyle->setRTLOrdering(document.visuallyOrdered() ? VisualOrder : LogicalOrder);
    60     documentStyle->setZoom(!document.printing() ? renderView.frame().pageZoomFactor() : 1);
    61     documentStyle->setPageScaleTransform(renderView.frame().frameScaleFactor());
    62     FontCascadeDescription documentFontDescription = documentStyle->fontDescription();
     58    documentStyle.setDisplay(BLOCK);
     59    documentStyle.setRTLOrdering(document.visuallyOrdered() ? VisualOrder : LogicalOrder);
     60    documentStyle.setZoom(!document.printing() ? renderView.frame().pageZoomFactor() : 1);
     61    documentStyle.setPageScaleTransform(renderView.frame().frameScaleFactor());
     62    FontCascadeDescription documentFontDescription = documentStyle.fontDescription();
    6363    documentFontDescription.setLocale(document.contentLanguage());
    64     documentStyle->setFontDescription(WTFMove(documentFontDescription));
     64    documentStyle.setFontDescription(WTFMove(documentFontDescription));
    6565
    6666    // This overrides any -webkit-user-modify inherited from the parent iframe.
    67     documentStyle->setUserModify(document.inDesignMode() ? READ_WRITE : READ_ONLY);
     67    documentStyle.setUserModify(document.inDesignMode() ? READ_WRITE : READ_ONLY);
    6868#if PLATFORM(IOS)
    6969    if (document.inDesignMode())
    70         documentStyle->setTextSizeAdjust(TextSizeAdjustment(NoTextSizeAdjustment));
     70        documentStyle.setTextSizeAdjust(TextSizeAdjustment(NoTextSizeAdjustment));
    7171#endif
    7272
    … …  
    8080        RenderObject* bodyRenderer = body ? body->renderer() : nullptr;
    8181        if (bodyRenderer && !docElementRenderer->style().hasExplicitlySetWritingMode())
    82             documentStyle->setWritingMode(bodyRenderer->style().writingMode());
     82            documentStyle.setWritingMode(bodyRenderer->style().writingMode());
    8383        else
    84             documentStyle->setWritingMode(docElementRenderer->style().writingMode());
     84            documentStyle.setWritingMode(docElementRenderer->style().writingMode());
    8585        if (bodyRenderer && !docElementRenderer->style().hasExplicitlySetDirection())
    86             documentStyle->setDirection(bodyRenderer->style().direction());
     86            documentStyle.setDirection(bodyRenderer->style().direction());
    8787        else
    88             documentStyle->setDirection(docElementRenderer->style().direction());
     88            documentStyle.setDirection(docElementRenderer->style().direction());
    8989    }
    9090
    9191    const Pagination& pagination = renderView.frameView().pagination();
    9292    if (pagination.mode != Pagination::Unpaginated) {
    93         documentStyle->setColumnStylesFromPaginationMode(pagination.mode);
    94         documentStyle->setColumnGap(pagination.gap);
     93        documentStyle.setColumnStylesFromPaginationMode(pagination.mode);
     94        documentStyle.setColumnGap(pagination.gap);
    9595        if (renderView.multiColumnFlowThread())
    96             renderView.updateColumnProgressionFromStyle(*documentStyle);
     96            renderView.updateColumnProgressionFromStyle(documentStyle);
    9797        if (renderView.frame().page()->paginationLineGridEnabled()) {
    98             documentStyle->setLineGrid("-webkit-default-pagination-grid");
    99             documentStyle->setLineSnap(LineSnapContain);
     98            documentStyle.setLineGrid("-webkit-default-pagination-grid");
     99            documentStyle.setLineSnap(LineSnapContain);
    100100        }
    101101    }
    … …  
    112112    fontDescription.setSpecifiedSize(size);
    113113    bool useSVGZoomRules = document.isSVGDocument();
    114     fontDescription.setComputedSize(computedFontSizeFromSpecifiedSize(size, fontDescription.isAbsoluteSize(), useSVGZoomRules, documentStyle.get(), document));
     114    fontDescription.setComputedSize(computedFontSizeFromSpecifiedSize(size, fontDescription.isAbsoluteSize(), useSVGZoomRules, &documentStyle, document));
    115115
    116116    FontOrientation fontOrientation;
    117117    NonCJKGlyphOrientation glyphOrientation;
    118     std::tie(fontOrientation, glyphOrientation) = documentStyle->fontAndGlyphOrientation();
     118    std::tie(fontOrientation, glyphOrientation) = documentStyle.fontAndGlyphOrientation();
    119119    fontDescription.setOrientation(fontOrientation);
    120120    fontDescription.setNonCJKGlyphOrientation(glyphOrientation);
    121121
    122     documentStyle->setFontDescription(fontDescription);
     122    documentStyle.setFontDescription(fontDescription);
    123123
    124     documentStyle->fontCascade().update(&const_cast<Document&>(document).fontSelector());
     124    documentStyle.fontCascade().update(&const_cast<Document&>(document).fontSelector());
    125125
    126126    return documentStyle;

  • trunk/Source/WebCore/style/StyleResolveForDocument.h

    r199964 r200041  
    3636namespace Style {
    3737
    38 std::unique_ptr<RenderStyle> resolveForDocument(const Document&);
     38RenderStyle resolveForDocument(const Document&);
    3939
    4040}

  • trunk/Source/WebCore/style/StyleSharingResolver.cpp

    r199964 r200041  
    137137    m_elementsSharingStyle.add(&element, shareElement);
    138138
    139     return RenderStyle::clone(update.elementStyle(*shareElement));
     139    return RenderStyle::clonePtr(*update.elementStyle(*shareElement));
    140140}
    141141

  • trunk/Source/WebCore/style/StyleTreeResolver.cpp

    r199964 r200041  
    5757    if (placeholderStyle)
    5858        return;
    59     placeholderStyle = RenderStyle::create().release();
     59    placeholderStyle = RenderStyle::createPtr().release();
    6060    placeholderStyle->setDisplay(NONE);
    6161    placeholderStyle->setIsPlaceholderStyle();
    … …  
    124124    if (!m_document.haveStylesheetsLoaded() && !element.renderer()) {
    125125        m_document.setHasNodesWithPlaceholderStyle();
    126         return RenderStyle::clone(placeholderStyle);
     126        return RenderStyle::clonePtr(*placeholderStyle);
    127127    }
    128128
    … …  
    206206
    207207    if (&element == m_document.documentElement()) {
    208         m_documentElementStyle = RenderStyle::clone(update.style.get());
     208        m_documentElementStyle = RenderStyle::clonePtr(*update.style);
    209209        scope().styleResolver.setOverrideDocumentElementStyle(m_documentElementStyle.get());
    210210

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

    r199964 r200041  
    106106}
    107107
    108 RenderPtr<RenderElement> SVGAElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     108RenderPtr<RenderElement> SVGAElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    109109{
    110110    if (parentNode() && parentNode()->isSVGElement() && downcast<SVGElement>(*parentNode()).isTextContent())

  • trunk/Source/WebCore/svg/SVGAElement.h

    r199964 r200041  
    4747    void svgAttributeChanged(const QualifiedName&) override;
    4848
    49     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     49    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    5050    bool childShouldCreateRenderer(const Node&) const override;
    5151

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

    r199964 r200041  
    8383}
    8484
    85 RenderPtr<RenderElement> SVGAltGlyphElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     85RenderPtr<RenderElement> SVGAltGlyphElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    8686{
    8787    return createRenderer<RenderSVGTSpan>(*this, WTFMove(style));

  • trunk/Source/WebCore/svg/SVGAltGlyphElement.h

    r199964 r200041  
    4848    SVGAltGlyphElement(const QualifiedName&, Document&);
    4949
    50     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     50    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    5151    bool childShouldCreateRenderer(const Node&) const override;
    5252

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

    r199964 r200041  
    9999}
    100100
    101 RenderPtr<RenderElement> SVGCircleElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     101RenderPtr<RenderElement> SVGCircleElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    102102{
    103103    return createRenderer<RenderSVGEllipse>(*this, WTFMove(style));

  • trunk/Source/WebCore/svg/SVGCircleElement.h

    r199964 r200041  
    4444    bool selfHasRelativeLengths() const override { return true; }
    4545
    46     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     46    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    4747
    4848    BEGIN_DECLARE_ANIMATED_PROPERTIES(SVGCircleElement)

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

    r199964 r200041  
    103103}
    104104
    105 RenderPtr<RenderElement> SVGClipPathElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     105RenderPtr<RenderElement> SVGClipPathElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    106106{
    107107    return createRenderer<RenderSVGResourceClipper>(*this, WTFMove(style));

  • trunk/Source/WebCore/svg/SVGClipPathElement.h

    r199964 r200041  
    4949    void childrenChanged(const ChildChange&) override;
    5050
    51     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     51    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    5252
    5353    BEGIN_DECLARE_ANIMATED_PROPERTIES(SVGClipPathElement)

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

    r199964 r200041  
    5252}
    5353
    54 RenderPtr<RenderElement> SVGDefsElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     54RenderPtr<RenderElement> SVGDefsElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    5555{
    5656    return createRenderer<RenderSVGHiddenContainer>(*this, WTFMove(style));

  • trunk/Source/WebCore/svg/SVGDefsElement.h

    r199964 r200041  
    3939    bool supportsFocus() const override { return false; }
    4040
    41     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     41    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    4242
    4343    BEGIN_DECLARE_ANIMATED_PROPERTIES(SVGDefsElement)

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

    r199964 r200041  
    101101}
    102102
    103 RenderPtr<RenderElement> SVGEllipseElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     103RenderPtr<RenderElement> SVGEllipseElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    104104{
    105105    return createRenderer<RenderSVGEllipse>(*this, WTFMove(style));

  • trunk/Source/WebCore/svg/SVGEllipseElement.h

    r199964 r200041  
    4444    bool selfHasRelativeLengths() const override { return true; };
    4545
    46     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     46    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    4747
    4848    BEGIN_DECLARE_ANIMATED_PROPERTIES(SVGEllipseElement)

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

    r199964 r200041  
    184184}
    185185
    186 RenderPtr<RenderElement> SVGFilterElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     186RenderPtr<RenderElement> SVGFilterElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    187187{
    188188    return createRenderer<RenderSVGResourceFilter>(*this, WTFMove(style));

  • trunk/Source/WebCore/svg/SVGFilterElement.h

    r199964 r200041  
    5454    void childrenChanged(const ChildChange&) override;
    5555
    56     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     56    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    5757    bool childShouldCreateRenderer(const Node&) const override;
    5858

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

    r199964 r200041  
    138138}
    139139
    140 RenderPtr<RenderElement> SVGFilterPrimitiveStandardAttributes::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     140RenderPtr<RenderElement> SVGFilterPrimitiveStandardAttributes::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    141141{
    142142    return createRenderer<RenderSVGResourceFilterPrimitive>(*this, WTFMove(style));

  • trunk/Source/WebCore/svg/SVGFilterPrimitiveStandardAttributes.h

    r199964 r200041  
    5757    bool isFilterEffect() const override { return true; }
    5858
    59     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     59    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    6060    bool rendererIsNeeded(const RenderStyle&) override;
    6161    bool childShouldCreateRenderer(const Node&) const override { return false; }

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

    r199964 r200041  
    123123}
    124124
    125 RenderPtr<RenderElement> SVGForeignObjectElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     125RenderPtr<RenderElement> SVGForeignObjectElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    126126{
    127127    return createRenderer<RenderSVGForeignObject>(*this, WTFMove(style));

  • trunk/Source/WebCore/svg/SVGForeignObjectElement.h

    r199964 r200041  
    4545    bool rendererIsNeeded(const RenderStyle&) override;
    4646    bool childShouldCreateRenderer(const Node&) const override;
    47     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     47    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    4848
    4949    bool selfHasRelativeLengths() const override { return true; }

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

    r199964 r200041  
    8484}
    8585
    86 RenderPtr<RenderElement> SVGGElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     86RenderPtr<RenderElement> SVGGElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    8787{
    8888    // SVG 1.1 testsuite explicitely uses constructs like <g display="none"><linearGradient>
    … …  
    9090    // subtree may be hidden - we only want the resource renderers to exist so they can be
    9191    // referenced from somewhere else.
    92     if (style->display() == NONE)
     92    if (style.display() == NONE)
    9393        return createRenderer<RenderSVGHiddenContainer>(*this, WTFMove(style));
    9494

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

    r199964 r200041  
    3737    SVGGElement(const QualifiedName&, Document&);
    3838
    39     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     39    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    4040
    4141    bool isValid() const override { return SVGTests::isValid(); }

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

    r199964 r200041  
    162162}
    163163
    164 RenderPtr<RenderElement> SVGGraphicsElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     164RenderPtr<RenderElement> SVGGraphicsElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    165165{
    166166    // By default, any subclass is expected to do path-based drawing

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

    r199964 r200041  
    5252    // "base class" methods for all the elements which render as paths
    5353    virtual void toClipPath(Path&);
    54     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     54    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    5555
    5656protected:

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

    r199964 r200041  
    170170}
    171171
    172 RenderPtr<RenderElement> SVGImageElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     172RenderPtr<RenderElement> SVGImageElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    173173{
    174174    return createRenderer<RenderSVGImage>(*this, WTFMove(style));

  • trunk/Source/WebCore/svg/SVGImageElement.h

    r199964 r200041  
    5252    InsertionNotificationRequest insertedInto(ContainerNode&) override;
    5353
    54     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     54    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    5555
    5656    const AtomicString& imageSourceURL() const override;

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

    r199964 r200041  
    114114}
    115115
    116 RenderPtr<RenderElement> SVGLinearGradientElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     116RenderPtr<RenderElement> SVGLinearGradientElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    117117{
    118118    return createRenderer<RenderSVGResourceLinearGradient>(*this, WTFMove(style));

  • trunk/Source/WebCore/svg/SVGLinearGradientElement.h

    r199964 r200041  
    4343    void svgAttributeChanged(const QualifiedName&) override;
    4444
    45     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     45    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    4646
    4747    bool selfHasRelativeLengths() const override;

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

    r199964 r200041  
    212212}
    213213
    214 RenderPtr<RenderElement> SVGMarkerElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     214RenderPtr<RenderElement> SVGMarkerElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    215215{
    216216    return createRenderer<RenderSVGResourceMarker>(*this, WTFMove(style));

  • trunk/Source/WebCore/svg/SVGMarkerElement.h

    r199964 r200041  
    140140    void childrenChanged(const ChildChange&) override;
    141141
    142     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     142    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    143143    bool rendererIsNeeded(const RenderStyle&) override { return true; }
    144144

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

    r199964 r200041  
    158158}
    159159
    160 RenderPtr<RenderElement> SVGMaskElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     160RenderPtr<RenderElement> SVGMaskElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    161161{
    162162    return createRenderer<RenderSVGResourceMasker>(*this, WTFMove(style));

  • trunk/Source/WebCore/svg/SVGMaskElement.h

    r199964 r200041  
    4949    void childrenChanged(const ChildChange&) override;
    5050
    51     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     51    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    5252
    5353    bool selfHasRelativeLengths() const override { return true; }

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

    r199964 r200041  
    405405}
    406406
    407 RenderPtr<RenderElement> SVGPathElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     407RenderPtr<RenderElement> SVGPathElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    408408{
    409409    // By default, any subclass is expected to do path-based drawing

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

    r199964 r200041  
    121121    END_DECLARE_ANIMATED_PROPERTIES
    122122
    123     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     123    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    124124
    125125    Node::InsertionNotificationRequest insertedInto(ContainerNode&) override;

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

    r199964 r200041  
    183183}
    184184
    185 RenderPtr<RenderElement> SVGPatternElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     185RenderPtr<RenderElement> SVGPatternElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    186186{
    187187    return createRenderer<RenderSVGResourcePattern>(*this, WTFMove(style));

  • trunk/Source/WebCore/svg/SVGPatternElement.h

    r199964 r200041  
    6363    void childrenChanged(const ChildChange&) override;
    6464
    65     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     65    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    6666
    6767    bool selfHasRelativeLengths() const override { return true; }

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

    r199964 r200041  
    126126}
    127127
    128 RenderPtr<RenderElement> SVGRadialGradientElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     128RenderPtr<RenderElement> SVGRadialGradientElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    129129{
    130130    return createRenderer<RenderSVGResourceRadialGradient>(*this, WTFMove(style));

  • trunk/Source/WebCore/svg/SVGRadialGradientElement.h

    r199964 r200041  
    4343    void svgAttributeChanged(const QualifiedName&) override;
    4444
    45     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     45    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    4646
    4747    bool selfHasRelativeLengths() const override;

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

    r199964 r200041  
    111111}
    112112
    113 RenderPtr<RenderElement> SVGRectElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     113RenderPtr<RenderElement> SVGRectElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    114114{
    115115    return createRenderer<RenderSVGRect>(*this, WTFMove(style));

  • trunk/Source/WebCore/svg/SVGRectElement.h

    r199964 r200041  
    4545    bool selfHasRelativeLengths() const override { return true; }
    4646
    47     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     47    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    4848
    4949    BEGIN_DECLARE_ANIMATED_PROPERTIES(SVGRectElement)

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

    r199964 r200041  
    440440}
    441441
    442 RenderPtr<RenderElement> SVGSVGElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     442RenderPtr<RenderElement> SVGSVGElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    443443{
    444444    if (isOutermostSVGSVGElement())

  • trunk/Source/WebCore/svg/SVGSVGElement.h

    r199964 r200041  
    135135    void parseAttribute(const QualifiedName&, const AtomicString&) override;
    136136    bool rendererIsNeeded(const RenderStyle&) override;
    137     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     137    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    138138    InsertionNotificationRequest insertedInto(ContainerNode&) override;
    139139    void removedFrom(ContainerNode&) override;

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

    r199964 r200041  
    7777}
    7878
    79 RenderPtr<RenderElement> SVGStopElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     79RenderPtr<RenderElement> SVGStopElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    8080{
    8181    return createRenderer<RenderSVGGradientStop>(*this, WTFMove(style));

  • trunk/Source/WebCore/svg/SVGStopElement.h

    r199964 r200041  
    4141    bool isGradientStop() const override { return true; }
    4242
    43     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     43    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    4444    bool rendererIsNeeded(const RenderStyle&) override;
    4545

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

    r199964 r200041  
    6161}
    6262
    63 RenderPtr<RenderElement> SVGSwitchElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     63RenderPtr<RenderElement> SVGSwitchElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    6464{
    6565    return createRenderer<RenderSVGTransformableContainer>(*this, WTFMove(style));

  • trunk/Source/WebCore/svg/SVGSwitchElement.h

    r199964 r200041  
    3939
    4040    bool childShouldCreateRenderer(const Node&) const override;
    41     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     41    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    4242
    4343    BEGIN_DECLARE_ANIMATED_PROPERTIES(SVGSwitchElement)

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

    r199964 r200041  
    7575}
    7676
    77 RenderPtr<RenderElement> SVGSymbolElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     77RenderPtr<RenderElement> SVGSymbolElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    7878{
    7979    return createRenderer<RenderSVGHiddenContainer>(*this, WTFMove(style));

  • trunk/Source/WebCore/svg/SVGSymbolElement.h

    r199964 r200041  
    4242    void parseAttribute(const QualifiedName&, const AtomicString&) override;
    4343    void svgAttributeChanged(const QualifiedName&) override;
    44     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     44    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    4545
    4646    bool selfHasRelativeLengths() const override;

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

    r199964 r200041  
    195195}
    196196
    197 RenderPtr<RenderElement> SVGTRefElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     197RenderPtr<RenderElement> SVGTRefElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    198198{
    199199    return createRenderer<RenderSVGInline>(*this, WTFMove(style));

  • trunk/Source/WebCore/svg/SVGTRefElement.h

    r199964 r200041  
    4242    void svgAttributeChanged(const QualifiedName&) override;
    4343
    44     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     44    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    4545    bool childShouldCreateRenderer(const Node&) const override;
    4646    bool rendererIsNeeded(const RenderStyle&) override;

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

    r199964 r200041  
    3939}
    4040
    41 RenderPtr<RenderElement> SVGTSpanElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     41RenderPtr<RenderElement> SVGTSpanElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    4242{
    4343    return createRenderer<RenderSVGTSpan>(*this, WTFMove(style));

  • trunk/Source/WebCore/svg/SVGTSpanElement.h

    r199964 r200041  
    3333    SVGTSpanElement(const QualifiedName&, Document&);
    3434           
    35     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     35    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    3636    bool childShouldCreateRenderer(const Node&) const override;
    3737    bool rendererIsNeeded(const RenderStyle&) override;

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

    r199964 r200041  
    6565}
    6666
    67 RenderPtr<RenderElement> SVGTextElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     67RenderPtr<RenderElement> SVGTextElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    6868{
    6969    return createRenderer<RenderSVGText>(*this, WTFMove(style));

  • trunk/Source/WebCore/svg/SVGTextElement.h

    r199964 r200041  
    3535    SVGTextElement(const QualifiedName&, Document&);
    3636
    37     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     37    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    3838    bool childShouldCreateRenderer(const Node&) const override;
    3939};

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

    r199964 r200041  
    124124}
    125125
    126 RenderPtr<RenderElement> SVGTextPathElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     126RenderPtr<RenderElement> SVGTextPathElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    127127{
    128128    return createRenderer<RenderSVGTextPath>(*this, WTFMove(style));

  • trunk/Source/WebCore/svg/SVGTextPathElement.h

    r199964 r200041  
    130130    void svgAttributeChanged(const QualifiedName&) override;
    131131
    132     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     132    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    133133    bool childShouldCreateRenderer(const Node&) const override;
    134134    bool rendererIsNeeded(const RenderStyle&) override;

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

    r199964 r200041  
    264264}
    265265
    266 RenderPtr<RenderElement> SVGUseElement::createElementRenderer(std::unique_ptr<RenderStyle> style, const RenderTreePosition&)
     266RenderPtr<RenderElement> SVGUseElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
    267267{
    268268    return createRenderer<RenderSVGTransformableContainer>(*this, WTFMove(style));

  • trunk/Source/WebCore/svg/SVGUseElement.h

    r199964 r200041  
    6565    void svgAttributeChanged(const QualifiedName&) override;
    6666    bool willRecalcStyle(Style::Change) override;
    67     RenderPtr<RenderElement> createElementRenderer(std::unique_ptr<RenderStyle>, const RenderTreePosition&) override;
     67    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
    6868    void toClipPath(Path&) override;
    6969    bool haveLoadedRequiredResources() override;
Note: See TracChangeset for help on using the changeset viewer.