Changeset 189776 in webkit


Ignore:
Timestamp:
Sep 14, 2015, 11:00:54 PM (10 years ago)
Author:
Gyuyoung Kim
Message:

Remove all uses of PassRefPtr in WebCore/xml
​https://bugs.webkit.org/show_bug.cgi?id=149114

Reviewed by Darin Adler.

  • dom/DecodedDataDocumentParser.h:
  • dom/DocumentParser.h:
  • dom/RawDataDocumentParser.h:
  • html/FTPDirectoryDocument.cpp:

(WebCore::FTPDirectoryDocumentParser::append):

  • html/parser/HTMLDocumentParser.cpp:

(WebCore::HTMLDocumentParser::append):

  • html/parser/HTMLDocumentParser.h:
  • html/parser/TextDocumentParser.cpp:

(WebCore::TextDocumentParser::append):

  • html/parser/TextDocumentParser.h:
  • xml/NativeXPathNSResolver.cpp:

(WebCore::NativeXPathNSResolver::NativeXPathNSResolver):

  • xml/NativeXPathNSResolver.h:

(WebCore::NativeXPathNSResolver::create):

  • xml/XMLErrors.cpp:

(WebCore::createXHTMLParserErrorHeader):

  • xml/XMLHttpRequestProgressEventThrottle.cpp:

(WebCore::XMLHttpRequestProgressEventThrottle::dispatchReadyStateChangeEvent):
(WebCore::XMLHttpRequestProgressEventThrottle::dispatchEvent):
(WebCore::XMLHttpRequestProgressEventThrottle::dispatchDeferredEvents):

  • xml/XMLHttpRequestProgressEventThrottle.h:
  • xml/XMLSerializer.h:
  • xml/XPathEvaluator.cpp:

(WebCore::XPathEvaluator::createExpression):
(WebCore::XPathEvaluator::createNSResolver):
(WebCore::XPathEvaluator::evaluate):

  • xml/XPathEvaluator.h:
  • xml/XPathNodeSet.h: Fix style errors.

(WebCore::XPath::NodeSet::NodeSet):
(WebCore::XPath::NodeSet::append):

  • xml/XPathPath.cpp:

(WebCore::XPath::Filter::evaluate):
(WebCore::XPath::LocationPath::evaluate):

  • xml/XPathValue.h: ditto.

(WebCore::XPath::Value::Value):
(WebCore::XPath::Value::Data::create):
(WebCore::XPath::Value::Data::Data):

  • xml/XSLTProcessor.cpp:

(WebCore::XSLTProcessor::transformToDocument):
(WebCore::XSLTProcessor::transformToFragment):

  • xml/XSLTProcessor.h:

(WebCore::XSLTProcessor::setXSLStyleSheet):
(WebCore::XSLTProcessor::importStylesheet):

  • xml/parser/XMLDocumentParser.cpp:

(WebCore::XMLDocumentParser::append):

  • xml/parser/XMLDocumentParser.h:
Location:
trunk/Source/WebCore
Files:
24 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r189771 r189776  
     12015-09-14  Gyuyoung Kim  <gyuyoung.kim@webkit.org>
     2
     3        Remove all uses of PassRefPtr in WebCore/xml
     4        https://bugs.webkit.org/show_bug.cgi?id=149114
     5
     6        Reviewed by Darin Adler.
     7
     8        * dom/DecodedDataDocumentParser.h:
     9        * dom/DocumentParser.h:
     10        * dom/RawDataDocumentParser.h:
     11        * html/FTPDirectoryDocument.cpp:
     12        (WebCore::FTPDirectoryDocumentParser::append):
     13        * html/parser/HTMLDocumentParser.cpp:
     14        (WebCore::HTMLDocumentParser::append):
     15        * html/parser/HTMLDocumentParser.h:
     16        * html/parser/TextDocumentParser.cpp:
     17        (WebCore::TextDocumentParser::append):
     18        * html/parser/TextDocumentParser.h:
     19        * xml/NativeXPathNSResolver.cpp:
     20        (WebCore::NativeXPathNSResolver::NativeXPathNSResolver):
     21        * xml/NativeXPathNSResolver.h:
     22        (WebCore::NativeXPathNSResolver::create):
     23        * xml/XMLErrors.cpp:
     24        (WebCore::createXHTMLParserErrorHeader):
     25        * xml/XMLHttpRequestProgressEventThrottle.cpp:
     26        (WebCore::XMLHttpRequestProgressEventThrottle::dispatchReadyStateChangeEvent):
     27        (WebCore::XMLHttpRequestProgressEventThrottle::dispatchEvent):
     28        (WebCore::XMLHttpRequestProgressEventThrottle::dispatchDeferredEvents):
     29        * xml/XMLHttpRequestProgressEventThrottle.h:
     30        * xml/XMLSerializer.h:
     31        * xml/XPathEvaluator.cpp:
     32        (WebCore::XPathEvaluator::createExpression):
     33        (WebCore::XPathEvaluator::createNSResolver):
     34        (WebCore::XPathEvaluator::evaluate):
     35        * xml/XPathEvaluator.h:
     36        * xml/XPathNodeSet.h: Fix style errors.
     37        (WebCore::XPath::NodeSet::NodeSet):
     38        (WebCore::XPath::NodeSet::append):
     39        * xml/XPathPath.cpp:
     40        (WebCore::XPath::Filter::evaluate):
     41        (WebCore::XPath::LocationPath::evaluate):
     42        * xml/XPathValue.h: ditto.
     43        (WebCore::XPath::Value::Value):
     44        (WebCore::XPath::Value::Data::create):
     45        (WebCore::XPath::Value::Data::Data):
     46        * xml/XSLTProcessor.cpp:
     47        (WebCore::XSLTProcessor::transformToDocument):
     48        (WebCore::XSLTProcessor::transformToFragment):
     49        * xml/XSLTProcessor.h:
     50        (WebCore::XSLTProcessor::setXSLStyleSheet):
     51        (WebCore::XSLTProcessor::importStylesheet):
     52        * xml/parser/XMLDocumentParser.cpp:
     53        (WebCore::XMLDocumentParser::append):
     54        * xml/parser/XMLDocumentParser.h:
     55
    1562015-09-14  Dewei Zhu  <dewei_zhu@apple.com>
    257

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

    r184068 r189776  
    4242private:
    4343    // append is used by DocumentWriter::replaceDocument.
    44     virtual void append(PassRefPtr<StringImpl>) override = 0;
     44    virtual void append(RefPtr<StringImpl>&&) override = 0;
    4545
    4646    // appendBytes and flush are used by DocumentWriter (the loader).

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

    r183169 r189776  
    5454    // FIXME: This really should take a std::unique_ptr to signify that it expects to take
    5555    // ownership of the buffer. The parser expects the PassRefPtr to hold the only ref of the StringImpl.
    56     virtual void append(PassRefPtr<StringImpl>) = 0;
     56    virtual void append(RefPtr<StringImpl>&&) = 0;
    5757
    5858    virtual void finish() = 0;

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

    r175148 r189776  
    5757    }
    5858
    59     virtual void append(PassRefPtr<StringImpl>) override
     59    virtual void append(RefPtr<StringImpl>&&) override
    6060    {
    6161        ASSERT_NOT_REACHED();

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

    r189576 r189776  
    5151
    5252private:
    53     virtual void append(PassRefPtr<StringImpl>) override;
     53    virtual void append(RefPtr<StringImpl>&&) override;
    5454    virtual void finish() override;
    5555
    … …  
    340340}
    341341
    342 void FTPDirectoryDocumentParser::append(PassRefPtr<StringImpl> inputSource)
    343 {
    344     String source(inputSource);
     342void FTPDirectoryDocumentParser::append(RefPtr<StringImpl>&& inputSource)
     343{
     344    String source(WTF::move(inputSource));
    345345
    346346    // Make sure we have the table element to append to by loading the template set in the pref, or

  • trunk/Source/WebCore/html/parser/HTMLDocumentParser.cpp

    r182266 r189776  
    357357}
    358358
    359 void HTMLDocumentParser::append(PassRefPtr<StringImpl> inputSource)
     359void HTMLDocumentParser::append(RefPtr<StringImpl>&& inputSource)
    360360{
    361361    if (isStopped())
    … …  
    366366    Ref<HTMLDocumentParser> protect(*this);
    367367
    368     String source(inputSource);
     368    String source(WTF::move(inputSource));
    369369
    370370    if (m_preloadScanner) {

  • trunk/Source/WebCore/html/parser/HTMLDocumentParser.h

    r178648 r189776  
    6767
    6868    virtual void insert(const SegmentedString&) override final;
    69     virtual void append(PassRefPtr<StringImpl>) override;
     69    virtual void append(RefPtr<StringImpl>&&) override;
    7070    virtual void finish() override;
    7171

  • trunk/Source/WebCore/html/parser/TextDocumentParser.cpp

    r178265 r189776  
    3737}
    3838
    39 void TextDocumentParser::append(PassRefPtr<StringImpl> text)
     39void TextDocumentParser::append(RefPtr<StringImpl>&& text)
    4040{
    4141    if (!m_haveInsertedFakePreElement)
    4242        insertFakePreElement();
    43     HTMLDocumentParser::append(text);
     43    HTMLDocumentParser::append(WTF::move(text));
    4444}
    4545

  • trunk/Source/WebCore/html/parser/TextDocumentParser.h

    r177883 r189776  
    4040    explicit TextDocumentParser(HTMLDocument&);
    4141
    42     virtual void append(PassRefPtr<StringImpl>) override;
     42    virtual void append(RefPtr<StringImpl>&&) override;
    4343
    4444    void insertFakePreElement();

  • trunk/Source/WebCore/xml/NativeXPathNSResolver.cpp

    r165676 r189776  
    3333namespace WebCore {
    3434
    35 NativeXPathNSResolver::NativeXPathNSResolver(PassRefPtr<Node> node)
    36     : m_node(node)
     35NativeXPathNSResolver::NativeXPathNSResolver(RefPtr<Node>&& node)
     36    : m_node(WTF::move(node))
    3737{
    3838}

  • trunk/Source/WebCore/xml/NativeXPathNSResolver.h

    r177733 r189776  
    3636class NativeXPathNSResolver : public XPathNSResolver {
    3737public:
    38     static Ref<NativeXPathNSResolver> create(PassRefPtr<Node> node) { return adoptRef(*new NativeXPathNSResolver(node)); }
     38    static Ref<NativeXPathNSResolver> create(RefPtr<Node>&& node) { return adoptRef(*new NativeXPathNSResolver(WTF::move(node))); }
    3939    virtual ~NativeXPathNSResolver();
    4040
    … …  
    4242
    4343private:
    44     explicit NativeXPathNSResolver(PassRefPtr<Node>);
     44    explicit NativeXPathNSResolver(RefPtr<Node>&&);
    4545    RefPtr<Node> m_node;
    4646};

  • trunk/Source/WebCore/xml/XMLErrors.cpp

    r168350 r189776  
    8585}
    8686
    87 static inline PassRefPtr<Element> createXHTMLParserErrorHeader(Document* doc, const String& errorMessages)
     87static inline RefPtr<Element> createXHTMLParserErrorHeader(Document* doc, const String& errorMessages)
    8888{
    8989    RefPtr<Element> reportElement = doc->createElement(QualifiedName(nullAtom, "parsererror", xhtmlNamespaceURI), true);
    … …  
    109109    h3->parserAppendChild(doc->createTextNode("Below is a rendering of the page up to the first error."));
    110110
    111     return reportElement.release();
     111    return reportElement;
    112112}
    113113

  • trunk/Source/WebCore/xml/XMLHttpRequestProgressEventThrottle.cpp

    r184622 r189776  
    8282}
    8383
    84 void XMLHttpRequestProgressEventThrottle::dispatchReadyStateChangeEvent(PassRefPtr<Event> event, ProgressEventAction progressEventAction)
     84void XMLHttpRequestProgressEventThrottle::dispatchReadyStateChangeEvent(RefPtr<Event>&& event, ProgressEventAction progressEventAction)
    8585{
    8686    if (progressEventAction == FlushProgressEvent)
    8787        flushProgressEvent();
    8888
    89     dispatchEvent(event);
    90 }
    91 
    92 void XMLHttpRequestProgressEventThrottle::dispatchEvent(PassRefPtr<Event> event)
     89    dispatchEvent(WTF::move(event));
     90}
     91
     92void XMLHttpRequestProgressEventThrottle::dispatchEvent(RefPtr<Event>&& event)
    9393{
    9494    ASSERT(event);
    … …  
    9898            return;
    9999        }
    100         m_deferredEvents.append(event);
     100        m_deferredEvents.append(WTF::move(event));
    101101    } else
    102         m_target->dispatchEvent(event);
     102        m_target->dispatchEvent(WTF::move(event));
    103103}
    104104
    … …  
    154154    // If not, just send the most up-to-date progress on resume.
    155155    if (deferredProgressEvent)
    156         dispatchEvent(deferredProgressEvent);
     156        dispatchEvent(WTF::move(deferredProgressEvent));
    157157}
    158158

  • trunk/Source/WebCore/xml/XMLHttpRequestProgressEventThrottle.h

    r176459 r189776  
    2929
    3030#include "Timer.h"
    31 #include "wtf/PassRefPtr.h"
    3231#include "wtf/Vector.h"
    3332#include <wtf/Forward.h>
    … …  
    5150
    5251    void dispatchThrottledProgressEvent(bool lengthComputable, unsigned long long loaded, unsigned long long total);
    53     void dispatchReadyStateChangeEvent(PassRefPtr<Event>, ProgressEventAction = DoNotFlushProgressEvent);
     52    void dispatchReadyStateChangeEvent(RefPtr<Event>&&, ProgressEventAction = DoNotFlushProgressEvent);
    5453    void dispatchProgressEvent(const AtomicString&);
    5554
    … …  
    6362    void dispatchDeferredEvents();
    6463    void flushProgressEvent();
    65     void dispatchEvent(PassRefPtr<Event>);
     64    void dispatchEvent(RefPtr<Event>&&);
    6665
    6766    bool hasEventToDispatch() const;

  • trunk/Source/WebCore/xml/XMLSerializer.h

    r177733 r189776  
    2222
    2323#include <wtf/Forward.h>
    24 #include <wtf/PassRefPtr.h>
     24#include <wtf/Ref.h>
    2525#include <wtf/RefCounted.h>
    2626

  • trunk/Source/WebCore/xml/XPathEvaluator.cpp

    r165676 r189776  
    3838using namespace XPath;
    3939
    40 PassRefPtr<XPathExpression> XPathEvaluator::createExpression(const String& expression,
     40RefPtr<XPathExpression> XPathEvaluator::createExpression(const String& expression,
    4141                                                             XPathNSResolver* resolver,
    4242                                                             ExceptionCode& ec)
    … …  
    4545}
    4646
    47 PassRefPtr<XPathNSResolver> XPathEvaluator::createNSResolver(Node* nodeResolver)
     47Ref<XPathNSResolver> XPathEvaluator::createNSResolver(Node* nodeResolver)
    4848{
    4949    return NativeXPathNSResolver::create(nodeResolver);
    5050}
    5151
    52 PassRefPtr<XPathResult> XPathEvaluator::evaluate(const String& expression,
     52RefPtr<XPathResult> XPathEvaluator::evaluate(const String& expression,
    5353                                                 Node* contextNode,
    5454                                                 XPathNSResolver* resolver,
    … …  
    5959    if (!isValidContextNode(contextNode)) {
    6060        ec = NOT_SUPPORTED_ERR;
    61         return 0;
     61        return nullptr;
    6262    }
    6363
    … …  
    6565    RefPtr<XPathExpression> expr = createExpression(expression, resolver, ec);
    6666    if (ec)
    67         return 0;
     67        return nullptr;
    6868   
    6969    return expr->evaluate(contextNode, type, result, ec);

  • trunk/Source/WebCore/xml/XPathEvaluator.h

    r177733 r189776  
    2929
    3030#include <wtf/Forward.h>
     31#include <wtf/Ref.h>
    3132#include <wtf/RefCounted.h>
    32 #include <wtf/PassRefPtr.h>
    3333
    3434namespace WebCore {
    … …  
    4545        static Ref<XPathEvaluator> create() { return adoptRef(*new XPathEvaluator); }
    4646       
    47         PassRefPtr<XPathExpression> createExpression(const String& expression, XPathNSResolver*, ExceptionCode&);
    48         PassRefPtr<XPathNSResolver> createNSResolver(Node* nodeResolver);
    49         PassRefPtr<XPathResult> evaluate(const String& expression, Node* contextNode,
     47        RefPtr<XPathExpression> createExpression(const String& expression, XPathNSResolver*, ExceptionCode&);
     48        Ref<XPathNSResolver> createNSResolver(Node* nodeResolver);
     49        RefPtr<XPathResult> evaluate(const String& expression, Node* contextNode,
    5050            XPathNSResolver*, unsigned short type, XPathResult*, ExceptionCode&);
    5151

  • trunk/Source/WebCore/xml/XPathNodeSet.h

    r177316 r189776  
    3737        public:
    3838            NodeSet() : m_isSorted(true), m_subtreesAreDisjoint(false) { }
    39             explicit NodeSet(PassRefPtr<Node> node) : m_isSorted(true), m_subtreesAreDisjoint(false), m_nodes(1, node) { }
     39            explicit NodeSet(RefPtr<Node>&& node)
     40                : m_isSorted(true), m_subtreesAreDisjoint(false), m_nodes(1, WTF::move(node))
     41            { }
    4042           
    4143            size_t size() const { return m_nodes.size(); }
    … …  
    4648
    4749            // NodeSet itself does not verify that nodes in it are unique.
    48             void append(PassRefPtr<Node> node) { m_nodes.append(node); }
     50            void append(RefPtr<Node>&& node) { m_nodes.append(WTF::move(node)); }
    4951            void append(const NodeSet& nodeSet) { m_nodes.appendVector(nodeSet.m_nodes); }
    5052

  • trunk/Source/WebCore/xml/XPathPath.cpp

    r184566 r189776  
    6262           
    6363            if (evaluatePredicate(*predicate))
    64                 newNodes.append(node);
     64                newNodes.append(node.copyRef());
    6565        }
    6666        nodes = WTF::move(newNodes);
    … …  
    131131            for (auto& match : matches) {
    132132                if (!needToCheckForDuplicateNodes || newNodesSet.add(match.get()).isNewEntry)
    133                     newNodes.append(match);
     133                    newNodes.append(match.copyRef());
    134134            }
    135135        }

  • trunk/Source/WebCore/xml/XPathValue.h

    r170774 r189776  
    4545            Value(const char* value) : m_type(StringValue), m_data(Data::create(value)) { }
    4646
    47             explicit Value(NodeSet value) : m_type(NodeSetValue), m_data(Data::create(WTF::move(value))) { }
    48             explicit Value(Node* value) : m_type(NodeSetValue), m_data(Data::create(value)) { }
    49             explicit Value(PassRefPtr<Node> value) : m_type(NodeSetValue), m_data(Data::create(value)) { }
     47            explicit Value(NodeSet&& value)
     48                : m_type(NodeSetValue), m_data(Data::create(WTF::move(value)))
     49            { }
     50            explicit Value(Node* value)
     51                : m_type(NodeSetValue), m_data(Data::create(value))
     52            { }
     53            explicit Value(RefPtr<Node>&& value)
     54                : m_type(NodeSetValue), m_data(Data::create(WTF::move(value)))
     55            { }
    5056
    5157            Type type() const { return m_type; }
    … …  
    6975
    7076            struct Data : public RefCounted<Data> {
    71                 static PassRefPtr<Data> create() { return adoptRef(new Data); }
    72                 static PassRefPtr<Data> create(const String& string) { return adoptRef(new Data(string)); }
    73                 static PassRefPtr<Data> create(NodeSet nodeSet) { return adoptRef(new Data(WTF::move(nodeSet))); }
    74                 static PassRefPtr<Data> create(PassRefPtr<Node> node) { return adoptRef(new Data(node)); }
     77                static Ref<Data> create() { return adoptRef(*new Data); }
     78                static Ref<Data> create(const String& string) { return adoptRef(*new Data(string)); }
     79                static Ref<Data> create(NodeSet&& nodeSet) { return adoptRef(*new Data(WTF::move(nodeSet))); }
     80                static Ref<Data> create(RefPtr<Node>&& node) { return adoptRef(*new Data(WTF::move(node))); }
    7581
    7682                String string;
    … …  
    7985            private:
    8086                Data() { }
    81                 explicit Data(const String& string) : string(string) { }
    82                 explicit Data(NodeSet nodeSet) : nodeSet(WTF::move(nodeSet)) { }
    83                 explicit Data(PassRefPtr<Node> node) : nodeSet(node) { }
     87                explicit Data(const String& string)
     88                    : string(string)
     89                { }
     90                explicit Data(NodeSet&& nodeSet)
     91                    : nodeSet(WTF::move(nodeSet))
     92                { }
     93                explicit Data(RefPtr<Node>&& node)
     94                    : nodeSet(WTF::move(node))
     95                { }
    8496            };
    8597

  • trunk/Source/WebCore/xml/XSLTProcessor.cpp

    r188193 r189776  
    110110}
    111111
    112 PassRefPtr<Document> XSLTProcessor::transformToDocument(Node* sourceNode)
     112RefPtr<Document> XSLTProcessor::transformToDocument(Node* sourceNode)
    113113{
    114114    if (!sourceNode)
    115         return 0;
     115        return nullptr;
    116116
    117117    String resultMIMEType;
    … …  
    119119    String resultEncoding;
    120120    if (!transformToString(*sourceNode, resultMIMEType, resultString, resultEncoding))
    121         return 0;
     121        return nullptr;
    122122    return createDocumentFromSource(resultString, resultEncoding, resultMIMEType, sourceNode, 0);
    123123}
    124124
    125 PassRefPtr<DocumentFragment> XSLTProcessor::transformToFragment(Node* sourceNode, Document* outputDoc)
     125RefPtr<DocumentFragment> XSLTProcessor::transformToFragment(Node* sourceNode, Document* outputDoc)
    126126{
    127127    if (!sourceNode || !outputDoc)
    128         return 0;
     128        return nullptr;
    129129
    130130    String resultMIMEType;
    … …  
    137137
    138138    if (!transformToString(*sourceNode, resultMIMEType, resultString, resultEncoding))
    139         return 0;
     139        return nullptr;
    140140    return createFragmentForTransformToFragment(resultString, resultMIMEType, outputDoc);
    141141}

  • trunk/Source/WebCore/xml/XSLTProcessor.h

    r188193 r189776  
    4545    ~XSLTProcessor();
    4646
    47     void setXSLStyleSheet(PassRefPtr<XSLStyleSheet> styleSheet) { m_stylesheet = styleSheet; }
     47    void setXSLStyleSheet(RefPtr<XSLStyleSheet>&& styleSheet) { m_stylesheet = WTF::move(styleSheet); }
    4848    bool transformToString(Node& source, String& resultMIMEType, String& resultString, String& resultEncoding);
    4949    Ref<Document> createDocumentFromSource(const String& source, const String& sourceEncoding, const String& sourceMIMEType, Node* sourceNode, Frame* frame);
    5050   
    5151    // DOM methods
    52     void importStylesheet(PassRefPtr<Node> style)
     52    void importStylesheet(RefPtr<Node>&& style)
    5353    {
    5454        if (style)
    55             m_stylesheetRootNode = style;
     55            m_stylesheetRootNode = WTF::move(style);
    5656    }
    57     PassRefPtr<DocumentFragment> transformToFragment(Node* source, Document* ouputDoc);
    58     PassRefPtr<Document> transformToDocument(Node* source);
     57    RefPtr<DocumentFragment> transformToFragment(Node* source, Document* ouputDoc);
     58    RefPtr<Document> transformToDocument(Node* source);
    5959   
    6060    void setParameter(const String& namespaceURI, const String& localName, const String& value);

  • trunk/Source/WebCore/xml/parser/XMLDocumentParser.cpp

    r189676 r189776  
    106106}
    107107
    108 void XMLDocumentParser::append(PassRefPtr<StringImpl> inputSource)
    109 {
    110     SegmentedString source(inputSource);
     108void XMLDocumentParser::append(RefPtr<StringImpl>&& inputSource)
     109{
     110    SegmentedString source(WTF::move(inputSource));
    111111    if (m_sawXSLTransform || !m_sawFirstElement)
    112112        m_originalSourceForTransform.append(source);

  • trunk/Source/WebCore/xml/parser/XMLDocumentParser.h

    r184622 r189776  
    9999        // From DocumentParser
    100100        virtual void insert(const SegmentedString&) override;
    101         virtual void append(PassRefPtr<StringImpl>) override;
     101        virtual void append(RefPtr<StringImpl>&&) override;
    102102        virtual void finish() override;
    103103        virtual bool isWaitingForScripts() const override;
Note: See TracChangeset for help on using the changeset viewer.