Changeset 141905 in webkit


Ignore:
Timestamp:
Feb 5, 2013 11:06:26 AM (11 years ago)
Author:
tonyg@chromium.org
Message:

Call XSSAuditor's didBlockScript() for the threaded HTML parser
​https://bugs.webkit.org/show_bug.cgi?id=108726

Reviewed by Adam Barth.

Source/WebCore:

This patch causes us to call didBlockScript() on the main thread if the CompactHTML token has XSSInfo.
To do so, we:

  1. Rename DidBlockScriptRequest to XSSInfo.
  2. Add an OwnPtr<XSSInfo> field to CompactHTMLToken.
  3. Add an isSafeToSendToAnotherThread() method to String and KURL.

We don't yet populate didBlockScriptRequest on the background thread, but this should just work once we do.

No new tests because no new functionality.

  • html/parser/BackgroundHTMLParser.cpp:

(WebCore::BackgroundHTMLParser::pumpTokenizer): Update comment for rename.

  • html/parser/CompactHTMLToken.cpp:

(SameSizeAsCompactHTMLToken):
(WebCore::CompactHTMLToken::CompactHTMLToken): Add a copy constructor used by Vector.
(WebCore::CompactHTMLToken::isSafeToSendToAnotherThread): Include new m_xssInfo field in safety check.
(WebCore):
(WebCore::CompactHTMLToken::xssInfo): Added.
(WebCore::CompactHTMLToken::setXSSInfo): Added.

  • html/parser/CompactHTMLToken.h: Add an OwnPtr<XSSInfo> field to CompactHTMLToken.

(WebCore):
(CompactHTMLToken):
(WTF): Add VectorTraits necessary for copying Vector fields objects that contain an OwnPtr.

  • html/parser/HTMLDocumentParser.cpp:

(WebCore::HTMLDocumentParser::processParsedChunkFromBackgroundParser): Add new didBlockScript() call.
(WebCore::HTMLDocumentParser::pumpTokenizer):

  • html/parser/XSSAuditor.cpp: Renaming.

(WebCore::XSSAuditor::filterToken):

  • html/parser/XSSAuditor.h: Renaming.

(WebCore):
(XSSAuditor):

  • html/parser/XSSAuditorDelegate.cpp:

(WebCore::XSSInfo::isSafeToSendToAnotherThread):
(WebCore):
(WebCore::XSSAuditorDelegate::didBlockScript):

  • html/parser/XSSAuditorDelegate.h:

(WebCore::XSSInfo::create):
(XSSInfo):
(WebCore::XSSInfo::XSSInfo):
(XSSAuditorDelegate):

  • platform/KURL.cpp:

(WebCore::KURL::isSafeToSendToAnotherThread): Added.
(WebCore):

  • platform/KURL.h:

(KURL):

  • platform/KURLGoogle.cpp:

(WebCore):
(WebCore::KURLGooglePrivate::isSafeToSendToAnotherThread): Added.

  • platform/KURLGooglePrivate.h:

(KURLGooglePrivate):

  • platform/KURLWTFURLImpl.h:

(WebCore::KURLWTFURLImpl::isSafeToSendToAnotherThread): Added.

Source/WTF:

This patch adds isSafeToSendToAnotherThread() methods to CString, String, ParsedURL and URLString.
These methods check to ensure there are 0 or 1 references.

  • wtf/text/CString.cpp:

(WTF::CString::isSafeToSendToAnotherThread): Added.
(WTF):

  • wtf/text/CString.h:

(CString):

  • wtf/text/WTFString.cpp:

(WTF::String::isSafeToSendToAnotherThread): Added.
(WTF):

  • wtf/text/WTFString.h:

(String):

  • wtf/url/api/ParsedURL.h:

(WTF::ParsedURL::isSafeToSendToAnotherThread): Added.

  • wtf/url/api/URLString.h:

(WTF::URLString::isSafeToSendToAnotherThread): Added.

Location:
trunk/Source
Files:
21 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WTF/ChangeLog

    r141819 r141905  
     12013-02-05  Tony Gentilcore  <tonyg@chromium.org>
     2
     3        Call XSSAuditor's didBlockScript() for the threaded HTML parser
     4        https://bugs.webkit.org/show_bug.cgi?id=108726
     5
     6        Reviewed by Adam Barth.
     7
     8        This patch adds isSafeToSendToAnotherThread() methods to CString, String, ParsedURL and URLString.
     9        These methods check to ensure there are 0 or 1 references.
     10
     11        * wtf/text/CString.cpp:
     12        (WTF::CString::isSafeToSendToAnotherThread): Added.
     13        (WTF):
     14        * wtf/text/CString.h:
     15        (CString):
     16        * wtf/text/WTFString.cpp:
     17        (WTF::String::isSafeToSendToAnotherThread): Added.
     18        (WTF):
     19        * wtf/text/WTFString.h:
     20        (String):
     21        * wtf/url/api/ParsedURL.h:
     22        (WTF::ParsedURL::isSafeToSendToAnotherThread): Added.
     23        * wtf/url/api/URLString.h:
     24        (WTF::URLString::isSafeToSendToAnotherThread): Added.
     25
    1262013-02-04  Benjamin Poulain  <bpoulain@apple.com>
    227

  • trunk/Source/WTF/wtf/text/CString.cpp

    r126191 r141905  
    100100}
    101101
     102bool CString::isSafeToSendToAnotherThread() const
     103{
     104    return !m_buffer || m_buffer->hasOneRef();
     105}
     106
    102107bool operator==(const CString& a, const CString& b)
    103108{

  • trunk/Source/WTF/wtf/text/CString.h

    r130144 r141905  
    7373
    7474    bool isNull() const { return !m_buffer; }
     75    bool isSafeToSendToAnotherThread() const;
    7576
    7677    CStringBuffer* buffer() const { return m_buffer.get(); }

  • trunk/Source/WTF/wtf/text/WTFString.cpp

    r136601 r141905  
    662662}
    663663
     664bool String::isSafeToSendToAnotherThread() const
     665{
     666    if (!impl())
     667        return true;
     668    if (impl()->hasOneRef())
     669        return true;
     670    if (isEmpty())
     671        return true;
     672    return false;
     673}
     674
    664675void String::split(const String& separator, bool allowEmptyEntries, Vector<String>& result) const
    665676{

  • trunk/Source/WTF/wtf/text/WTFString.h

    r136601 r141905  
    395395
    396396    WTF_EXPORT_STRING_API String isolatedCopy() const;
     397    bool isSafeToSendToAnotherThread() const;
    397398
    398399    // Prevent Strings from being implicitly convertable to bool as it will be ambiguous on any platform that

  • trunk/Source/WTF/wtf/url/api/ParsedURL.h

    r132261 r141905  
    5050
    5151    WTF_EXPORT_PRIVATE ParsedURL isolatedCopy() const;
     52    bool isSafeToSendToAnotherThread() const { return m_spec.isSafeToSendToAnotherThread(); }
    5253
    5354    bool isValid() const { return !m_spec.string().isNull(); }

  • trunk/Source/WTF/wtf/url/api/URLString.h

    r130187 r141905  
    4040
    4141    const String& string() const { return m_string;}
     42    bool isSafeToSendToAnotherThread() const { return m_string.isSafeToSendToAnotherThread(); }
    4243
    4344#ifndef NDEBUG

  • trunk/Source/WebCore/ChangeLog

    r141901 r141905  
     12013-02-05  Tony Gentilcore  <tonyg@chromium.org>
     2
     3        Call XSSAuditor's didBlockScript() for the threaded HTML parser
     4        https://bugs.webkit.org/show_bug.cgi?id=108726
     5
     6        Reviewed by Adam Barth.
     7
     8        This patch causes us to call didBlockScript() on the main thread if the CompactHTML token has XSSInfo.
     9        To do so, we:
     10        1. Rename DidBlockScriptRequest to XSSInfo.
     11        2. Add an OwnPtr<XSSInfo> field to CompactHTMLToken.
     12        3. Add an isSafeToSendToAnotherThread() method to String and KURL.
     13
     14        We don't yet populate didBlockScriptRequest on the background thread, but this should just work once we do.
     15
     16        No new tests because no new functionality.
     17
     18        * html/parser/BackgroundHTMLParser.cpp:
     19        (WebCore::BackgroundHTMLParser::pumpTokenizer): Update comment for rename.
     20        * html/parser/CompactHTMLToken.cpp:
     21        (SameSizeAsCompactHTMLToken):
     22        (WebCore::CompactHTMLToken::CompactHTMLToken): Add a copy constructor used by Vector.
     23        (WebCore::CompactHTMLToken::isSafeToSendToAnotherThread): Include new m_xssInfo field in safety check.
     24        (WebCore):
     25        (WebCore::CompactHTMLToken::xssInfo): Added.
     26        (WebCore::CompactHTMLToken::setXSSInfo): Added.
     27        * html/parser/CompactHTMLToken.h: Add an OwnPtr<XSSInfo> field to CompactHTMLToken.
     28        (WebCore):
     29        (CompactHTMLToken):
     30        (WTF): Add VectorTraits necessary for copying Vector fields objects that contain an OwnPtr.
     31        * html/parser/HTMLDocumentParser.cpp:
     32        (WebCore::HTMLDocumentParser::processParsedChunkFromBackgroundParser): Add new didBlockScript() call.
     33        (WebCore::HTMLDocumentParser::pumpTokenizer):
     34        * html/parser/XSSAuditor.cpp: Renaming.
     35        (WebCore::XSSAuditor::filterToken):
     36        * html/parser/XSSAuditor.h: Renaming.
     37        (WebCore):
     38        (XSSAuditor):
     39        * html/parser/XSSAuditorDelegate.cpp:
     40        (WebCore::XSSInfo::isSafeToSendToAnotherThread):
     41        (WebCore):
     42        (WebCore::XSSAuditorDelegate::didBlockScript):
     43        * html/parser/XSSAuditorDelegate.h:
     44        (WebCore::XSSInfo::create):
     45        (XSSInfo):
     46        (WebCore::XSSInfo::XSSInfo):
     47        (XSSAuditorDelegate):
     48        * platform/KURL.cpp:
     49        (WebCore::KURL::isSafeToSendToAnotherThread): Added.
     50        (WebCore):
     51        * platform/KURL.h:
     52        (KURL):
     53        * platform/KURLGoogle.cpp:
     54        (WebCore):
     55        (WebCore::KURLGooglePrivate::isSafeToSendToAnotherThread): Added.
     56        * platform/KURLGooglePrivate.h:
     57        (KURLGooglePrivate):
     58        * platform/KURLWTFURLImpl.h:
     59        (WebCore::KURLWTFURLImpl::isSafeToSendToAnotherThread): Added.
     60
    1612013-02-05  Anton Vayvod  <avayvod@chromium.org>
    262

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

    r141686 r141905  
    154154{
    155155    while (m_tokenizer->nextToken(m_input.current(), *m_token.get())) {
    156         // FIXME: Call m_xssAuditor.filterToken(m_token) and put resulting DidBlockScriptRequest into CompactHTMLToken.
     156        // FIXME: Call m_xssAuditor.filterToken(m_token) and put resulting XSSInfo into CompactHTMLToken.
    157157        m_pendingTokens->append(CompactHTMLToken(m_token.get(), TextPosition(m_input.current().currentLine(), m_input.current().currentColumn())));
    158158        m_token->clear();

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

    r141070 r141905  
    3131
    3232#include "HTMLToken.h"
     33#include "XSSAuditorDelegate.h"
    3334
    3435namespace WebCore {
    … …  
    3940    Vector<CompactAttribute> vector;
    4041    TextPosition textPosition;
     42    OwnPtr<XSSInfo> xssInfo;
    4143};
    4244
    … …  
    8789}
    8890
    89 static bool isStringSafeToSendToAnotherThread(const String& string)
     91CompactHTMLToken::CompactHTMLToken(const CompactHTMLToken& other)
     92    : m_type(other.type())
     93    , m_isAll8BitData(other.isAll8BitData())
     94    , m_doctypeForcesQuirks(other.doctypeForcesQuirks())
     95    , m_textPosition(other.textPosition())
    9096{
    91     StringImpl* impl = string.impl();
    92     if (!impl)
    93         return true;
    94     if (impl->hasOneRef())
    95         return true;
    96     if (string.isEmpty())
    97         return true;
    98     return false;
     97    if (other.xssInfo())
     98        m_xssInfo = adoptPtr(new XSSInfo(*other.xssInfo()));
    9999}
    100100
    … …  
    102102{
    103103    for (Vector<CompactAttribute>::const_iterator it = m_attributes.begin(); it != m_attributes.end(); ++it) {
    104         if (!isStringSafeToSendToAnotherThread(it->name()))
     104        if (!it->name().isSafeToSendToAnotherThread())
    105105            return false;
    106         if (!isStringSafeToSendToAnotherThread(it->value()))
     106        if (!it->value().isSafeToSendToAnotherThread())
    107107            return false;
    108108    }
    109     return isStringSafeToSendToAnotherThread(m_data);
     109    if (m_xssInfo && !m_xssInfo->isSafeToSendToAnotherThread())
     110        return false;
     111    return m_data.isSafeToSendToAnotherThread();
     112}
     113
     114XSSInfo* CompactHTMLToken::xssInfo() const
     115{
     116    return m_xssInfo.get();
     117}
     118
     119void CompactHTMLToken::setXSSInfo(PassOwnPtr<XSSInfo> xssInfo)
     120{
     121    m_xssInfo = xssInfo;
    110122}
    111123

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

    r141070 r141905  
    3030
    3131#include "HTMLTokenTypes.h"
     32#include <wtf/OwnPtr.h>
     33#include <wtf/PassOwnPtr.h>
    3234#include <wtf/RefCounted.h>
    3335#include <wtf/RefPtr.h>
    … …  
    3941
    4042class HTMLToken;
     43class XSSInfo;
    4144
    4245class CompactAttribute {
    … …  
    5962public:
    6063    CompactHTMLToken(const HTMLToken*, const TextPosition&);
     64    CompactHTMLToken(const CompactHTMLToken&);
    6165
    6266    bool isSafeToSendToAnotherThread() const;
    … …  
    7478    const String& systemIdentifier() const { return m_attributes[0].value(); }
    7579    bool doctypeForcesQuirks() const { return m_doctypeForcesQuirks; }
     80    XSSInfo* xssInfo() const;
     81    void setXSSInfo(PassOwnPtr<XSSInfo>);
    7682
    7783private:
    … …  
    8490    Vector<CompactAttribute> m_attributes;
    8591    TextPosition m_textPosition;
     92    OwnPtr<XSSInfo> m_xssInfo;
    8693};
    8794
    … …  
    9097}
    9198
     99namespace WTF {
     100// This is required for a struct with OwnPtr. We know CompactHTMLToken is simple enough that
     101// initializing to 0 and moving with memcpy (and then not destructing the original) will work.
     102template<> struct VectorTraits<WebCore::CompactHTMLToken> : SimpleClassVectorTraits { };
     103}
     104
    92105#endif // ENABLE(THREADED_HTML_PARSER)
    93106

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

    r141897 r141905  
    303303    ASSERT(shouldUseThreading());
    304304
    305     // didReceiveTokensFromBackgroundParser can cause this parser to be detached from the Document,
     305    // This method can cause this parser to be detached from the Document,
    306306    // but we need to ensure it isn't deleted yet.
    307307    RefPtr<HTMLDocumentParser> protect(this);
    … …  
    317317        ASSERT(!isWaitingForScripts());
    318318
    319         // FIXME: Call m_xssAuditorDelegate.didBlockScript() with DidBlockScriptRequest from the CompactHTMLToken.
    320319        m_textPosition = it->textPosition();
     320
     321        if (XSSInfo* xssInfo = it->xssInfo())
     322            m_xssAuditorDelegate.didBlockScript(*xssInfo);
    321323        constructTreeFromCompactHTMLToken(*it);
    322324
    … …  
    379381            // We do not XSS filter innerHTML, which means we (intentionally) fail
    380382            // http/tests/security/xssAuditor/dom-write-innerHTML.html
    381             OwnPtr<DidBlockScriptRequest> request = m_xssAuditor.filterToken(FilterTokenRequest(token(), m_sourceTracker, document()->decoder()));
    382             if (request)
    383                 m_xssAuditorDelegate.didBlockScript(request.release());
     383            OwnPtr<XSSInfo> xssInfo = m_xssAuditor.filterToken(FilterTokenRequest(token(), m_sourceTracker, document()->decoder()));
     384            if (xssInfo)
     385                m_xssAuditorDelegate.didBlockScript(*xssInfo);
    384386        }
    385387

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

    r141897 r141905  
    279279}
    280280
    281 PassOwnPtr<DidBlockScriptRequest> XSSAuditor::filterToken(const FilterTokenRequest& request)
     281PassOwnPtr<XSSInfo> XSSAuditor::filterToken(const FilterTokenRequest& request)
    282282{
    283283    ASSERT(m_state == Initialized);
    … …  
    297297    if (didBlockScript) {
    298298        bool didBlockEntirePage = (m_xssProtection == XSSProtectionBlockEnabled);
    299         OwnPtr<DidBlockScriptRequest> didBlockScriptRequest = DidBlockScriptRequest::create(m_reportURL, m_originalURL, m_originalHTTPBody, didBlockEntirePage);
     299        OwnPtr<XSSInfo> xssInfo = XSSInfo::create(m_reportURL, m_originalURL, m_originalHTTPBody, didBlockEntirePage);
    300300        if (!m_reportURL.isEmpty()) {
    301301            m_reportURL = KURL();
    … …  
    303303            m_originalHTTPBody = String();
    304304        }
    305         return didBlockScriptRequest.release();
     305        return xssInfo.release();
    306306    }
    307307    return nullptr;

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

    r141897 r141905  
    3434namespace WebCore {
    3535
    36 class DidBlockScriptRequest;
    3736class Document;
    3837class HTMLDocumentParser;
    3938class HTMLSourceTracker;
    4039class TextResourceDecoder;
     40class XSSInfo;
    4141
    4242struct FilterTokenRequest {
    … …  
    5858
    5959    void init(Document*);
    60     PassOwnPtr<DidBlockScriptRequest> filterToken(const FilterTokenRequest&);
     60    PassOwnPtr<XSSInfo> filterToken(const FilterTokenRequest&);
    6161
    6262private:

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

    r141494 r141905  
    3333#include "Frame.h"
    3434#include "FrameLoaderClient.h"
     35#include "HTMLParserIdioms.h"
    3536#include "InspectorValues.h"
    3637#include "PingLoader.h"
    … …  
    3839
    3940namespace WebCore {
     41
     42bool XSSInfo::isSafeToSendToAnotherThread() const
     43{
     44    return m_reportURL.isSafeToSendToAnotherThread()
     45        && m_originalURL.isSafeToSendToAnotherThread()
     46        && m_originalHTTPBody.isSafeToSendToAnotherThread();
     47}
    4048
    4149XSSAuditorDelegate::XSSAuditorDelegate(Document* document)
    … …  
    4755}
    4856
    49 void XSSAuditorDelegate::didBlockScript(PassOwnPtr<DidBlockScriptRequest> request)
     57void XSSAuditorDelegate::didBlockScript(const XSSInfo& xssInfo)
    5058{
    5159    ASSERT(isMainThread());
    … …  
    5563    m_document->addConsoleMessage(JSMessageSource, ErrorMessageLevel, consoleMessage);
    5664
    57     if (request->m_didBlockEntirePage)
     65    if (xssInfo.m_didBlockEntirePage)
    5866        m_document->frame()->loader()->stopAllLoaders();
    5967
    6068    if (!m_didNotifyClient) {
    61         m_document->frame()->loader()->client()->didDetectXSS(m_document->url(), request->m_didBlockEntirePage);
     69        m_document->frame()->loader()->client()->didDetectXSS(m_document->url(), xssInfo.m_didBlockEntirePage);
    6270        m_didNotifyClient = true;
    6371    }
    6472
    65     if (!request->m_reportURL.isEmpty()) {
     73    if (!xssInfo.m_reportURL.isEmpty()) {
    6674        RefPtr<InspectorObject> reportDetails = InspectorObject::create();
    67         reportDetails->setString("request-url", request->m_originalURL);
    68         reportDetails->setString("request-body", request->m_originalHTTPBody);
     75        reportDetails->setString("request-url", xssInfo.m_originalURL);
     76        reportDetails->setString("request-body", xssInfo.m_originalHTTPBody);
    6977
    7078        RefPtr<InspectorObject> reportObject = InspectorObject::create();
    … …  
    7280
    7381        RefPtr<FormData> report = FormData::create(reportObject->toJSONString().utf8().data());
    74         PingLoader::sendViolationReport(m_document->frame(), request->m_reportURL, report);
     82        PingLoader::sendViolationReport(m_document->frame(), xssInfo.m_reportURL, report);
    7583    }
    7684
    77     if (request->m_didBlockEntirePage)
     85    if (xssInfo.m_didBlockEntirePage)
    7886        m_document->frame()->navigationScheduler()->scheduleLocationChange(m_document->securityOrigin(), blankURL(), String());
    7987}

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

    r141494 r141905  
    3535class Document;
    3636
    37 class DidBlockScriptRequest {
     37class XSSInfo {
    3838public:
    39     static PassOwnPtr<DidBlockScriptRequest> create(const KURL& reportURL, const String& originalURL, const String& originalHTTPBody, bool didBlockEntirePage)
     39    static PassOwnPtr<XSSInfo> create(const KURL& reportURL, const String& originalURL, const String& originalHTTPBody, bool didBlockEntirePage)
    4040    {
    41         return adoptPtr(new DidBlockScriptRequest(reportURL, originalURL, originalHTTPBody, didBlockEntirePage));
     41        return adoptPtr(new XSSInfo(reportURL, originalURL, originalHTTPBody, didBlockEntirePage));
    4242    }
     43
     44    bool isSafeToSendToAnotherThread() const;
    4345
    4446    KURL m_reportURL;
    … …  
    4850
    4951private:
    50     DidBlockScriptRequest(const KURL& reportURL, const String& originalURL, const String& originalHTTPBody, bool didBlockEntirePage)
     52    XSSInfo(const KURL& reportURL, const String& originalURL, const String& originalHTTPBody, bool didBlockEntirePage)
    5153        : m_reportURL(reportURL)
    5254        , m_originalURL(originalURL)
    … …  
    6163    explicit XSSAuditorDelegate(Document*);
    6264
    63     void didBlockScript(PassOwnPtr<DidBlockScriptRequest>);
     65    void didBlockScript(const XSSInfo&);
    6466
    6567private:

  • trunk/Source/WebCore/platform/KURL.cpp

    r141570 r141905  
    19361936}
    19371937
    1938 }
     1938bool KURL::isSafeToSendToAnotherThread() const
     1939{
     1940#if USE(GOOGLEURL)
     1941    return m_url.isSafeToSendToAnotherThread();
     1942#elif USE(WTFURL)
     1943    return m_urlImpl.isSafeToSendToAnotherThread();
     1944#else // !USE(GOOGLEURL)
     1945    return m_string.isSafeToSendToAnotherThread();
     1946#endif
     1947}
     1948
     1949}

  • trunk/Source/WebCore/platform/KURL.h

    r137573 r141905  
    228228
    229229    void reportMemoryUsage(MemoryObjectInfo*) const;
     230    bool isSafeToSendToAnotherThread() const;
    230231
    231232private:

  • trunk/Source/WebCore/platform/KURLGoogle.cpp

    r141570 r141905  
    400400    info.addMember(m_parsed, "parsed");
    401401}
     402
     403bool KURLGooglePrivate::isSafeToSendToAnotherThread() const
     404{
     405    return m_string.isSafeToSendToAnotherThread()
     406        && m_utf8.isSafeToSendToAnotherThread()
     407        && (!m_innerURL || m_innerURL->isSafeToSendToAnotherThread());
     408}
     409
    402410// KURL ------------------------------------------------------------------------
    403411

  • trunk/Source/WebCore/platform/KURLGooglePrivate.h

    r128448 r141905  
    102102
    103103        void reportMemoryUsage(MemoryObjectInfo*) const;
     104        bool isSafeToSendToAnotherThread() const;
    104105
    105106    private:

  • trunk/Source/WebCore/platform/KURLWTFURLImpl.h

    r141570 r141905  
    5050        info.addMember(m_invalidUrlString, "invalidUrlString");
    5151    }
     52    bool isSafeToSendToAnotherThread() const
     53    {
     54        return m_invalidUrlString.isSafeToSendToAnotherThread()
     55            && m_parsedURL.isSafeToSendToAnotherThread();
     56    }
    5257    PassRefPtr<KURLWTFURLImpl> copy() const;
    5358};
Note: See TracChangeset for help on using the changeset viewer.