Attachment #287683 for bug #161511

View Details Raw Unified Return to Bug 161511



2016-09-01  Alex Christensen  <achristensen@webkit.org>

        Avoid unneeded string copy when parsing URL hosts
        https://bugs.webkit.org/show_bug.cgi?id=161511

        Reviewed by NOBODY (OOPS!).

        No change in behavior.  Covered by existing API tests.

        * platform/URLParser.cpp:
        (WebCore::URLParser::parse):
        (WebCore::URLParser::parseAuthority):
        (WebCore::URLParser::parseHost):
        (WebCore::URLParser::authorityEndReached): Deleted.
        (WebCore::URLParser::hostEndReached): Deleted.
        * platform/URLParser.h:

2016-09-01  Ryosuke Niwa  <rniwa@webkit.org>

        Add "whenDefined" to CustomElementRegistry



    LOG(URLParser, "Parsing URL <%s> base <%s>", input.utf8().data(), base.string().utf8().data());
    m_url = { };
    m_buffer.clear();
    m_authorityOrHostBuffer.clear();

    auto codePoints = StringView(input).codePoints();
    auto c = codePoints.begin();
    auto end = codePoints.end();
    auto authorityOrHostBegin = codePoints.begin();
    while (c != end && isC0ControlOrSpace(*c))
        ++c;
    

            if (*c == '/') {
                state = State::AuthorityOrHost;
                ++c;
                authorityOrHostBegin = c;
            } else
                state = State::Path;
            break;

            }
            m_url.m_userStart = m_buffer.length();
            state = State::AuthorityOrHost;
            authorityOrHostBegin = c;
            break;
        case State::AuthorityOrHost:
            LOG_STATE("AuthorityOrHost");
            if (*c == '@') {
                parseAuthority(authorityOrHostBegin, c);
                ++c;
                authorityOrHostBegin = c;
                state = State::Host;
            } else if (*c == '/' || *c == '?' || *c == '#') {
                m_url.m_userEnd = m_buffer.length();
                m_url.m_passwordEnd = m_url.m_userEnd;
                parseHost(authorityOrHostBegin, c);
                state = State::Path;
                break;
            }
                m_authorityOrHostBuffer.append(*c);
            ++c;
            break;
        case State::Host:
            LOG_STATE("Host");
            if (*c == '/' || *c == '?' || *c == '#') {
                parseHost(authorityOrHostBegin, c);
                state = State::Path;
                break;
            }
            m_authorityOrHostBuffer.append(*c);
            ++c;
            break;
        case State::File:

    case State::Host:
        if (state == State::Host)
            LOG_FINAL_STATE("Host");
        parseHost(authorityOrHostBegin, end);
        m_buffer.append('/');
        m_url.m_pathEnd = m_url.m_portEnd + 1;
        m_url.m_pathAfterLastSlash = m_url.m_pathEnd;

    return m_url;
}

void URLParser::parseAuthority(StringView::CodePoints::Iterator& iterator, const StringView::CodePoints::Iterator& end)
{
    auto codePoints = StringView(m_authorityOrHostBuffer.toString()).codePoints();
    auto iterator = codePoints.begin();
    auto end = codePoints.end();
    for (; iterator != end; ++iterator) {
        m_buffer.append(*iterator);
        if (*iterator == ':') {

        m_buffer.append(*iterator);
    m_url.m_passwordEnd = m_buffer.length();
    m_buffer.append('@');
    m_authorityOrHostBuffer.clear();
}

static void serializeIPv4(uint32_t address, StringBuilder& buffer)

    return address;
}

void URLParser::parseHost(StringView::CodePoints::Iterator& iterator, const StringView::CodePoints::Iterator& end)
{
    auto codePoints = StringView(m_authorityOrHostBuffer.toString()).codePoints();
    auto iterator = codePoints.begin();
    auto end = codePoints.end();
    if (iterator == end)
        return;
    if (*iterator == '[') {

    }
    m_url.m_hostEnd = m_buffer.length();
    m_url.m_portEnd = m_url.m_hostEnd;
    m_authorityOrHostBuffer.clear();
}

bool URLParser::allValuesEqual(const URL& a, const URL& b)



private:
    URL m_url;
    StringBuilder m_buffer;
    void parseAuthority(StringView::CodePoints::Iterator&, const StringView::CodePoints::Iterator& end);
    void parseHost(StringView::CodePoints::Iterator&, const StringView::CodePoints::Iterator& end);
    void hostEndReached();

    enum class URLPart;
    void copyURLPartsUntil(const URL& base, URLPart);

Return to Bug 161511

Lines 237-247 URL URLParser::parse(const String& input Source/WebCore/platform/URLParser.cpp_sec1
- Source/WebCore/platform/URLParser.cpp -18 / +12 lines
237	LOG(URLParser, "Parsing URL <%s> base <%s>", input.utf8().data(), base.string().utf8().data());	237	LOG(URLParser, "Parsing URL <%s> base <%s>", input.utf8().data(), base.string().utf8().data());
238	m_url = { };	238	m_url = { };
239	m_buffer.clear();	239	m_buffer.clear();
240	m_authorityOrHostBuffer.clear();
241		240
242	auto codePoints = StringView(input).codePoints();	241	auto codePoints = StringView(input).codePoints();
243	auto c = codePoints.begin();	242	auto c = codePoints.begin();
244	auto end = codePoints.end();	243	auto end = codePoints.end();
		244	auto authorityOrHostBegin = codePoints.begin();
245	while (c != end && isC0ControlOrSpace(*c))	245	while (c != end && isC0ControlOrSpace(*c))
246	++c;	246	++c;
247		247
Lines 371-376 URL URLParser::parse(const String& input Source/WebCore/platform/URLParser.cpp_sec2
371	if (*c == '/') {	371	if (*c == '/') {
372	state = State::AuthorityOrHost;	372	state = State::AuthorityOrHost;
373	++c;	373	++c;
		374	authorityOrHostBegin = c;
374	} else	375	} else
375	state = State::Path;	376	state = State::Path;
376	break;	377	break;
Lines 436-465 URL URLParser::parse(const String& input Source/WebCore/platform/URLParser.cpp_sec3
436	}	437	}
437	m_url.m_userStart = m_buffer.length();	438	m_url.m_userStart = m_buffer.length();
438	state = State::AuthorityOrHost;	439	state = State::AuthorityOrHost;
		440	authorityOrHostBegin = c;
439	break;	441	break;
440	case State::AuthorityOrHost:	442	case State::AuthorityOrHost:
441	LOG_STATE("AuthorityOrHost");	443	LOG_STATE("AuthorityOrHost");
442	if (*c == '@') {	444	if (*c == '@') {
443	authorityEndReached();	445	parseAuthority(authorityOrHostBegin, c);
		446	++c;
		447	authorityOrHostBegin = c;
444	state = State::Host;	448	state = State::Host;
445	} else if (c == '/' \|\| c == '?' \|\| *c == '#') {	449	} else if (c == '/' \|\| c == '?' \|\| *c == '#') {
446	m_url.m_userEnd = m_buffer.length();	450	m_url.m_userEnd = m_buffer.length();
447	m_url.m_passwordEnd = m_url.m_userEnd;	451	m_url.m_passwordEnd = m_url.m_userEnd;
448	hostEndReached();	452	parseHost(authorityOrHostBegin, c);
449	state = State::Path;	453	state = State::Path;
450	break;	454	break;
451	} else	455	}
452	m_authorityOrHostBuffer.append(*c);
453	++c;	456	++c;
454	break;	457	break;
455	case State::Host:	458	case State::Host:
456	LOG_STATE("Host");	459	LOG_STATE("Host");
457	if (c == '/' \|\| c == '?' \|\| *c == '#') {	460	if (c == '/' \|\| c == '?' \|\| *c == '#') {
458	hostEndReached();	461	parseHost(authorityOrHostBegin, c);
459	state = State::Path;	462	state = State::Path;
460	break;	463	break;
461	}	464	}
462	m_authorityOrHostBuffer.append(*c);
463	++c;	465	++c;
464	break;	466	break;
465	case State::File:	467	case State::File:
Lines 589-595 URL URLParser::parse(const String& input Source/WebCore/platform/URLParser.cpp_sec4
589	case State::Host:	591	case State::Host:
590	if (state == State::Host)	592	if (state == State::Host)
591	LOG_FINAL_STATE("Host");	593	LOG_FINAL_STATE("Host");
592	hostEndReached();	594	parseHost(authorityOrHostBegin, end);
593	m_buffer.append('/');	595	m_buffer.append('/');
594	m_url.m_pathEnd = m_url.m_portEnd + 1;	596	m_url.m_pathEnd = m_url.m_portEnd + 1;
595	m_url.m_pathAfterLastSlash = m_url.m_pathEnd;	597	m_url.m_pathAfterLastSlash = m_url.m_pathEnd;
Lines 637-647 URL URLParser::parse(const String& input Source/WebCore/platform/URLParser.cpp_sec5
637	return m_url;	639	return m_url;
638	}	640	}
639		641
640	void URLParser::authorityEndReached()	642	void URLParser::parseAuthority(StringView::CodePoints::Iterator& iterator, const StringView::CodePoints::Iterator& end)
641	{	643	{
642	auto codePoints = StringView(m_authorityOrHostBuffer.toString()).codePoints();
643	auto iterator = codePoints.begin();
644	auto end = codePoints.end();
645	for (; iterator != end; ++iterator) {	644	for (; iterator != end; ++iterator) {
646	m_buffer.append(*iterator);	645	m_buffer.append(*iterator);
647	if (*iterator == ':') {	646	if (*iterator == ':') {
Lines 654-660 void URLParser::authorityEndReached() Source/WebCore/platform/URLParser.cpp_sec6
654	m_buffer.append(*iterator);	653	m_buffer.append(*iterator);
655	m_url.m_passwordEnd = m_buffer.length();	654	m_url.m_passwordEnd = m_buffer.length();
656	m_buffer.append('@');	655	m_buffer.append('@');
657	m_authorityOrHostBuffer.clear();
658	}	656	}
659		657
660	static void serializeIPv4(uint32_t address, StringBuilder& buffer)	658	static void serializeIPv4(uint32_t address, StringBuilder& buffer)
Lines 925-935 static Optional<std::array<uint16_t, 8>> Source/WebCore/platform/URLParser.cpp_sec7
925	return address;	923	return address;
926	}	924	}
927		925
928	void URLParser::hostEndReached()	926	void URLParser::parseHost(StringView::CodePoints::Iterator& iterator, const StringView::CodePoints::Iterator& end)
929	{	927	{
930	auto codePoints = StringView(m_authorityOrHostBuffer.toString()).codePoints();
931	auto iterator = codePoints.begin();
932	auto end = codePoints.end();
933	if (iterator == end)	928	if (iterator == end)
934	return;	929	return;
935	if (*iterator == '[') {	930	if (*iterator == '[') {
Lines 966-972 void URLParser::hostEndReached() Source/WebCore/platform/URLParser.cpp_sec8
966	}	961	}
967	m_url.m_hostEnd = m_buffer.length();	962	m_url.m_hostEnd = m_buffer.length();
968	m_url.m_portEnd = m_url.m_hostEnd;	963	m_url.m_portEnd = m_url.m_hostEnd;
969	m_authorityOrHostBuffer.clear();
970	}	964	}
971		965
972	bool URLParser::allValuesEqual(const URL& a, const URL& b)	966	bool URLParser::allValuesEqual(const URL& a, const URL& b)

Lines 42-50 public: Source/WebCore/platform/URLParser.h_sec1
- Source/WebCore/platform/URLParser.h -3 / +2 lines
42	private:	42	private:
43	URL m_url;	43	URL m_url;
44	StringBuilder m_buffer;	44	StringBuilder m_buffer;
45	StringBuilder m_authorityOrHostBuffer; // FIXME: Save the iterator at the end of the scheme instead of using a second buffer.	45	void parseAuthority(StringView::CodePoints::Iterator&, const StringView::CodePoints::Iterator& end);
46	void authorityEndReached();	46	void parseHost(StringView::CodePoints::Iterator&, const StringView::CodePoints::Iterator& end);
47	void hostEndReached();
48		47
49	enum class URLPart;	48	enum class URLPart;
50	void copyURLPartsUntil(const URL& base, URLPart);	49	void copyURLPartsUntil(const URL& base, URLPart);

Lines 1-3 Source/WebCore/ChangeLog_sec1
- Source/WebCore/ChangeLog +17 lines
		1	2016-09-01 Alex Christensen <achristensen@webkit.org>
		2
		3	Avoid unneeded string copy when parsing URL hosts
		4	https://bugs.webkit.org/show_bug.cgi?id=161511
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	No change in behavior. Covered by existing API tests.
		9
		10	* platform/URLParser.cpp:
		11	(WebCore::URLParser::parse):
		12	(WebCore::URLParser::parseAuthority):
		13	(WebCore::URLParser::parseHost):
		14	(WebCore::URLParser::authorityEndReached): Deleted.
		15	(WebCore::URLParser::hostEndReached): Deleted.
		16	* platform/URLParser.h:
		17
1	2016-09-01 Ryosuke Niwa <rniwa@webkit.org>	18	2016-09-01 Ryosuke Niwa <rniwa@webkit.org>
2		19
3	Add "whenDefined" to CustomElementRegistry	20	Add "whenDefined" to CustomElementRegistry