Attachment #250630 for bug #143056

View Details Raw Unified Return to Bug 143056

| Differences between



2015-04-13  Joonghun Park  <jh718.park@samsung.com>

        Use std::unique_ptr instead of PassOwnPtr|OwnPtr for ResourceResponse
        https://bugs.webkit.org/show_bug.cgi?id=143056

        Reviewed by NOBODY (OOPS!).

        No new tests, no behavior changes.

        * loader/WorkerThreadableLoader.cpp:
        (WebCore::WorkerThreadableLoader::MainThreadBridge::MainThreadBridge):
        (WebCore::WorkerThreadableLoader::MainThreadBridge::didReceiveResponse):
        * platform/CrossThreadCopier.h:
        * platform/network/ResourceResponseBase.cpp:
        (WebCore::ResourceResponseBase::adopt):
        (WebCore::ResourceResponseBase::copyData):
        * platform/network/ResourceResponseBase.h:
        * platform/network/cf/ResourceResponse.h:
        (WebCore::ResourceResponse::doPlatformCopyData):
        (WebCore::ResourceResponse::doPlatformAdopt):
        * platform/network/curl/ResourceResponse.h:
        (WebCore::ResourceResponse::doPlatformCopyData):
        (WebCore::ResourceResponse::doPlatformAdopt):
        * platform/network/soup/ResourceResponse.h:
        (WebCore::ResourceResponse::doPlatformCopyData):
        (WebCore::ResourceResponse::doPlatformAdopt):

2015-04-12  Benjamin Poulain  <benjamin@webkit.org>

        Legacy scroll behavior on HTMLBodyElement should only apply to the first body element of a document



#include "WorkerLoaderProxy.h"
#include "WorkerThread.h"
#include <wtf/MainThread.h>
#include <wtf/OwnPtr.h>
#include <wtf/Vector.h>

namespace WebCore {

{
    ASSERT(m_workerClientWrapper.get());

    auto* requestData = request.copyData().release();
    StringCapture capturedOutgoingReferrer(outgoingReferrer);
    m_loaderProxy.postTaskToLoader([this, requestData, options, capturedOutgoingReferrer](ScriptExecutionContext& context) {
        ASSERT(isMainThread());

void WorkerThreadableLoader::MainThreadBridge::didReceiveResponse(unsigned long identifier, const ResourceResponse& response)
{
    RefPtr<ThreadableLoaderClientWrapper> workerClientWrapper = m_workerClientWrapper;
    auto* responseData = response.copyData().release();
    if (!m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper, identifier, responseData] (ScriptExecutionContext& context) {
        ASSERT_UNUSED(context, context.isWorkerGlobalScope());
        auto response(ResourceResponse::adopt(std::unique_ptr<CrossThreadResourceResponseData>(responseData)));
        workerClientWrapper->didReceiveResponse(identifier, *response);
    }, m_taskMode))
        delete responseData;

Lines 142-148 namespace WebCore { a/Source/WebCore/platform/CrossThreadCopier.h_sec1
- a/Source/WebCore/platform/CrossThreadCopier.h -1 / +1 lines
142	};	142	};
143		143
144	template<> struct CrossThreadCopierBase<false, false, ResourceResponse> {	144	template<> struct CrossThreadCopierBase<false, false, ResourceResponse> {
145	typedef PassOwnPtr<CrossThreadResourceResponseData> Type;	145	typedef std::unique_ptr<CrossThreadResourceResponseData> Type;
146	static Type copy(const ResourceResponse&);	146	static Type copy(const ResourceResponse&);
147	};	147	};
148		148



{
}

std::unique_ptr<ResourceResponse> ResourceResponseBase::adopt(std::unique_ptr<CrossThreadResourceResponseData> data)
{
    auto response = std::make_unique<ResourceResponse>();
    response->setURL(data->m_url);
    response->setMimeType(data->m_mimeType);
    response->setExpectedContentLength(data->m_expectedContentLength);

    response->lazyInit(AllFields);
    response->m_httpHeaderFields.adopt(WTF::move(data->m_httpHeaders));
    response->m_resourceLoadTiming = data->m_resourceLoadTiming;
    response->doPlatformAdopt(WTF::move(data));
    return response;
}

std::unique_ptr<CrossThreadResourceResponseData> ResourceResponseBase::copyData() const
{
    auto data = std::make_unique<CrossThreadResourceResponseData>();
    data->m_url = url().copy();
    data->m_mimeType = mimeType().isolatedCopy();
    data->m_expectedContentLength = expectedContentLength();

    data->m_httpStatusText = httpStatusText().isolatedCopy();
    data->m_httpHeaders = httpHeaderFields().copyData();
    data->m_resourceLoadTiming = m_resourceLoadTiming;
    return asResourceResponse().doPlatformCopyData(WTF::move(data));
}

bool ResourceResponseBase::isHTTP() const



class ResourceResponseBase {
    WTF_MAKE_FAST_ALLOCATED;
public:
    static std::unique_ptr<ResourceResponse> adopt(std::unique_ptr<CrossThreadResourceResponseData>);

    // Gets a copy of the data suitable for passing to another thread.
    std::unique_ptr<CrossThreadResourceResponseData> copyData() const;

    bool isNull() const { return m_isNull; }
    WEBCORE_EXPORT bool isHTTP() const;



    String platformSuggestedFilename() const;
    CertificateInfo platformCertificateInfo() const;

    std::unique_ptr<CrossThreadResourceResponseData> doPlatformCopyData(std::unique_ptr<CrossThreadResourceResponseData> data) const { return data; }
    void doPlatformAdopt(std::unique_ptr<CrossThreadResourceResponseData>) { }
#if PLATFORM(COCOA)
    void initNSURLResponse() const;
#endif



private:
    friend class ResourceResponseBase;

    std::unique_ptr<CrossThreadResourceResponseData> doPlatformCopyData(std::unique_ptr<CrossThreadResourceResponseData> data) const { return data; }
    void doPlatformAdopt(std::unique_ptr<CrossThreadResourceResponseData>) { }
    String platformSuggestedFilename() const
    {
        return filenameFromHTTPContentDisposition(httpHeaderField(HTTPHeaderName::ContentDisposition));



    String platformSuggestedFilename() const;
    CertificateInfo platformCertificateInfo() const;

    std::unique_ptr<CrossThreadResourceResponseData> doPlatformCopyData(std::unique_ptr<CrossThreadResourceResponseData> data) const { return data; }
    void doPlatformAdopt(std::unique_ptr<CrossThreadResourceResponseData>) { }
};

template<class Encoder>

Return to Bug 143056

Lines 49-58 struct CrossThreadResourceResponseData; a/Source/WebCore/platform/network/ResourceResponseBase.h_sec1
- a/Source/WebCore/platform/network/ResourceResponseBase.h -2 / +2 lines
49	class ResourceResponseBase {	49	class ResourceResponseBase {
50	WTF_MAKE_FAST_ALLOCATED;	50	WTF_MAKE_FAST_ALLOCATED;
51	public:	51	public:
52	static PassOwnPtr<ResourceResponse> adopt(PassOwnPtr<CrossThreadResourceResponseData>);	52	static std::unique_ptr<ResourceResponse> adopt(std::unique_ptr<CrossThreadResourceResponseData>);
53		53
54	// Gets a copy of the data suitable for passing to another thread.	54	// Gets a copy of the data suitable for passing to another thread.
55	PassOwnPtr<CrossThreadResourceResponseData> copyData() const;	55	std::unique_ptr<CrossThreadResourceResponseData> copyData() const;
56		56
57	bool isNull() const { return m_isNull; }	57	bool isNull() const { return m_isNull; }
58	WEBCORE_EXPORT bool isHTTP() const;	58	WEBCORE_EXPORT bool isHTTP() const;

Lines 101-108 private: a/Source/WebCore/platform/network/cf/ResourceResponse.h_sec1
- a/Source/WebCore/platform/network/cf/ResourceResponse.h -2 / +2 lines
101	String platformSuggestedFilename() const;	101	String platformSuggestedFilename() const;
102	CertificateInfo platformCertificateInfo() const;	102	CertificateInfo platformCertificateInfo() const;
103		103
104	PassOwnPtr<CrossThreadResourceResponseData> doPlatformCopyData(PassOwnPtr<CrossThreadResourceResponseData> data) const { return data; }	104	std::unique_ptr<CrossThreadResourceResponseData> doPlatformCopyData(std::unique_ptr<CrossThreadResourceResponseData> data) const { return data; }
105	void doPlatformAdopt(PassOwnPtr<CrossThreadResourceResponseData>) { }	105	void doPlatformAdopt(std::unique_ptr<CrossThreadResourceResponseData>) { }
106	#if PLATFORM(COCOA)	106	#if PLATFORM(COCOA)
107	void initNSURLResponse() const;	107	void initNSURLResponse() const;
108	#endif	108	#endif

Lines 59-66 public: a/Source/WebCore/platform/network/curl/ResourceResponse.h_sec1
- a/Source/WebCore/platform/network/curl/ResourceResponse.h -2 / +2 lines
59	private:	59	private:
60	friend class ResourceResponseBase;	60	friend class ResourceResponseBase;
61		61
62	PassOwnPtr<CrossThreadResourceResponseData> doPlatformCopyData(PassOwnPtr<CrossThreadResourceResponseData> data) const { return data; }	62	std::unique_ptr<CrossThreadResourceResponseData> doPlatformCopyData(std::unique_ptr<CrossThreadResourceResponseData> data) const { return data; }
63	void doPlatformAdopt(PassOwnPtr<CrossThreadResourceResponseData>) { }	63	void doPlatformAdopt(std::unique_ptr<CrossThreadResourceResponseData>) { }
64	String platformSuggestedFilename() const	64	String platformSuggestedFilename() const
65	{	65	{
66	return filenameFromHTTPContentDisposition(httpHeaderField(HTTPHeaderName::ContentDisposition));	66	return filenameFromHTTPContentDisposition(httpHeaderField(HTTPHeaderName::ContentDisposition));

Lines 91-98 private: a/Source/WebCore/platform/network/soup/ResourceResponse.h_sec1
- a/Source/WebCore/platform/network/soup/ResourceResponse.h -2 / +2 lines
91	String platformSuggestedFilename() const;	91	String platformSuggestedFilename() const;
92	CertificateInfo platformCertificateInfo() const;	92	CertificateInfo platformCertificateInfo() const;
93		93
94	PassOwnPtr<CrossThreadResourceResponseData> doPlatformCopyData(PassOwnPtr<CrossThreadResourceResponseData> data) const { return data; }	94	std::unique_ptr<CrossThreadResourceResponseData> doPlatformCopyData(std::unique_ptr<CrossThreadResourceResponseData> data) const { return data; }
95	void doPlatformAdopt(PassOwnPtr<CrossThreadResourceResponseData>) { }	95	void doPlatformAdopt(std::unique_ptr<CrossThreadResourceResponseData>) { }
96	};	96	};
97		97
98	template<class Encoder>	98	template<class Encoder>

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +27 lines
		1	2015-04-13 Joonghun Park <jh718.park@samsung.com>
		2
		3	Use std::unique_ptr instead of PassOwnPtr\|OwnPtr for ResourceResponse
		4	https://bugs.webkit.org/show_bug.cgi?id=143056
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	No new tests, no behavior changes.
		9
		10	* loader/WorkerThreadableLoader.cpp:
		11	(WebCore::WorkerThreadableLoader::MainThreadBridge::MainThreadBridge):
		12	(WebCore::WorkerThreadableLoader::MainThreadBridge::didReceiveResponse):
		13	* platform/CrossThreadCopier.h:
		14	* platform/network/ResourceResponseBase.cpp:
		15	(WebCore::ResourceResponseBase::adopt):
		16	(WebCore::ResourceResponseBase::copyData):
		17	* platform/network/ResourceResponseBase.h:
		18	* platform/network/cf/ResourceResponse.h:
		19	(WebCore::ResourceResponse::doPlatformCopyData):
		20	(WebCore::ResourceResponse::doPlatformAdopt):
		21	* platform/network/curl/ResourceResponse.h:
		22	(WebCore::ResourceResponse::doPlatformCopyData):
		23	(WebCore::ResourceResponse::doPlatformAdopt):
		24	* platform/network/soup/ResourceResponse.h:
		25	(WebCore::ResourceResponse::doPlatformCopyData):
		26	(WebCore::ResourceResponse::doPlatformAdopt):
		27
1	2015-04-12 Benjamin Poulain <benjamin@webkit.org>	28	2015-04-12 Benjamin Poulain <benjamin@webkit.org>
2		29
3	Legacy scroll behavior on HTMLBodyElement should only apply to the first body element of a document	30	Legacy scroll behavior on HTMLBodyElement should only apply to the first body element of a document

Lines 42-48 a/Source/WebCore/loader/WorkerThreadableLoader.cpp_sec1
- a/Source/WebCore/loader/WorkerThreadableLoader.cpp -4 / +3 lines
42	#include "WorkerLoaderProxy.h"	42	#include "WorkerLoaderProxy.h"
43	#include "WorkerThread.h"	43	#include "WorkerThread.h"
44	#include <wtf/MainThread.h>	44	#include <wtf/MainThread.h>
45	#include <wtf/OwnPtr.h>
46	#include <wtf/Vector.h>	45	#include <wtf/Vector.h>
47		46
48	namespace WebCore {	47	namespace WebCore {
Lines 91-97 WorkerThreadableLoader::MainThreadBridge::MainThreadBridge(PassRefPtr<Threadable a/Source/WebCore/loader/WorkerThreadableLoader.cpp_sec2
91	{	90	{
92	ASSERT(m_workerClientWrapper.get());	91	ASSERT(m_workerClientWrapper.get());
93		92
94	auto requestData = request.copyData().release();	93	auto* requestData = request.copyData().release();
95	StringCapture capturedOutgoingReferrer(outgoingReferrer);	94	StringCapture capturedOutgoingReferrer(outgoingReferrer);
96	m_loaderProxy.postTaskToLoader([this, requestData, options, capturedOutgoingReferrer](ScriptExecutionContext& context) {	95	m_loaderProxy.postTaskToLoader([this, requestData, options, capturedOutgoingReferrer](ScriptExecutionContext& context) {
97	ASSERT(isMainThread());	96	ASSERT(isMainThread());
Lines 161-170 void WorkerThreadableLoader::MainThreadBridge::didSendData(unsigned long long by a/Source/WebCore/loader/WorkerThreadableLoader.cpp_sec3
161	void WorkerThreadableLoader::MainThreadBridge::didReceiveResponse(unsigned long identifier, const ResourceResponse& response)	160	void WorkerThreadableLoader::MainThreadBridge::didReceiveResponse(unsigned long identifier, const ResourceResponse& response)
162	{	161	{
163	RefPtr<ThreadableLoaderClientWrapper> workerClientWrapper = m_workerClientWrapper;	162	RefPtr<ThreadableLoaderClientWrapper> workerClientWrapper = m_workerClientWrapper;
164	CrossThreadResourceResponseData* responseData = response.copyData().leakPtr();	163	auto* responseData = response.copyData().release();
165	if (!m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper, identifier, responseData] (ScriptExecutionContext& context) {	164	if (!m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper, identifier, responseData] (ScriptExecutionContext& context) {
166	ASSERT_UNUSED(context, context.isWorkerGlobalScope());	165	ASSERT_UNUSED(context, context.isWorkerGlobalScope());
167	OwnPtr<ResourceResponse> response(ResourceResponse::adopt(adoptPtr(responseData)));	166	auto response(ResourceResponse::adopt(std::unique_ptr<CrossThreadResourceResponseData>(responseData)));
168	workerClientWrapper->didReceiveResponse(identifier, *response);	167	workerClientWrapper->didReceiveResponse(identifier, *response);
169	}, m_taskMode))	168	}, m_taskMode))
170	delete responseData;	169	delete responseData;

Lines 62-70 ResourceResponseBase::ResourceResponseBase(const URL& url, const String& mimeTyp a/Source/WebCore/platform/network/ResourceResponseBase.cpp_sec1
- a/Source/WebCore/platform/network/ResourceResponseBase.cpp -7 / +7 lines
62	{	62	{
63	}	63	}
64		64
65	PassOwnPtr<ResourceResponse> ResourceResponseBase::adopt(PassOwnPtr<CrossThreadResourceResponseData> data)	65	std::unique_ptr<ResourceResponse> ResourceResponseBase::adopt(std::unique_ptr<CrossThreadResourceResponseData> data)
66	{	66	{
67	OwnPtr<ResourceResponse> response = adoptPtr(new ResourceResponse);	67	auto response = std::make_unique<ResourceResponse>();
68	response->setURL(data->m_url);	68	response->setURL(data->m_url);
69	response->setMimeType(data->m_mimeType);	69	response->setMimeType(data->m_mimeType);
70	response->setExpectedContentLength(data->m_expectedContentLength);	70	response->setExpectedContentLength(data->m_expectedContentLength);
Lines 76-88 PassOwnPtr<ResourceResponse> ResourceResponseBase::adopt(PassOwnPtr<CrossThreadR a/Source/WebCore/platform/network/ResourceResponseBase.cpp_sec2
76	response->lazyInit(AllFields);	76	response->lazyInit(AllFields);
77	response->m_httpHeaderFields.adopt(WTF::move(data->m_httpHeaders));	77	response->m_httpHeaderFields.adopt(WTF::move(data->m_httpHeaders));
78	response->m_resourceLoadTiming = data->m_resourceLoadTiming;	78	response->m_resourceLoadTiming = data->m_resourceLoadTiming;
79	response->doPlatformAdopt(data);	79	response->doPlatformAdopt(WTF::move(data));
80	return response.release();	80	return response;
81	}	81	}
82		82
83	PassOwnPtr<CrossThreadResourceResponseData> ResourceResponseBase::copyData() const	83	std::unique_ptr<CrossThreadResourceResponseData> ResourceResponseBase::copyData() const
84	{	84	{
85	OwnPtr<CrossThreadResourceResponseData> data = adoptPtr(new CrossThreadResourceResponseData);	85	auto data = std::make_unique<CrossThreadResourceResponseData>();
86	data->m_url = url().copy();	86	data->m_url = url().copy();
87	data->m_mimeType = mimeType().isolatedCopy();	87	data->m_mimeType = mimeType().isolatedCopy();
88	data->m_expectedContentLength = expectedContentLength();	88	data->m_expectedContentLength = expectedContentLength();
Lines 91-97 PassOwnPtr<CrossThreadResourceResponseData> ResourceResponseBase::copyData() con a/Source/WebCore/platform/network/ResourceResponseBase.cpp_sec3
91	data->m_httpStatusText = httpStatusText().isolatedCopy();	91	data->m_httpStatusText = httpStatusText().isolatedCopy();
92	data->m_httpHeaders = httpHeaderFields().copyData();	92	data->m_httpHeaders = httpHeaderFields().copyData();
93	data->m_resourceLoadTiming = m_resourceLoadTiming;	93	data->m_resourceLoadTiming = m_resourceLoadTiming;
94	return asResourceResponse().doPlatformCopyData(data.release());	94	return asResourceResponse().doPlatformCopyData(WTF::move(data));
95	}	95	}
96		96
97	bool ResourceResponseBase::isHTTP() const	97	bool ResourceResponseBase::isHTTP() const