Attachment #249423 for bug #143056

View Details Raw Unified Return to Bug 143056

| Differences between



2015-03-25  Joonghun Park  <jh718.park@samsung.com>

        Use std::unique_ptr instead of PassOwnPtr|OwnPtr for ResourceRequest 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-03-25  Dan Bernstein  <mitz@apple.com>

        iOS Simulator build fix.



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

namespace WebCore {

{
    ASSERT(m_workerClientWrapper.get());

    CrossThreadResourceRequestData* 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;
    CrossThreadResourceResponseData* 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 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-03-25 Joonghun Park <jh718.park@samsung.com>
		2
		3	Use std::unique_ptr instead of PassOwnPtr\|OwnPtr for ResourceRequest 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-03-25 Dan Bernstein <mitz@apple.com>	28	2015-03-25 Dan Bernstein <mitz@apple.com>
2		29
3	iOS Simulator build fix.	30	iOS Simulator build fix.

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	CrossThreadResourceRequestData* 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	CrossThreadResourceResponseData* 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 91-99 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
91	{	91	{
92	}	92	}
93		93
94	PassOwnPtr<ResourceResponse> ResourceResponseBase::adopt(PassOwnPtr<CrossThreadResourceResponseData> data)	94	std::unique_ptr<ResourceResponse> ResourceResponseBase::adopt(std::unique_ptr<CrossThreadResourceResponseData> data)
95	{	95	{
96	OwnPtr<ResourceResponse> response = adoptPtr(new ResourceResponse);	96	auto response = std::make_unique<ResourceResponse>();
97	response->setURL(data->m_url);	97	response->setURL(data->m_url);
98	response->setMimeType(data->m_mimeType);	98	response->setMimeType(data->m_mimeType);
99	response->setExpectedContentLength(data->m_expectedContentLength);	99	response->setExpectedContentLength(data->m_expectedContentLength);
Lines 105-117 PassOwnPtr<ResourceResponse> ResourceResponseBase::adopt(PassOwnPtr<CrossThreadR a/Source/WebCore/platform/network/ResourceResponseBase.cpp_sec2
105	response->lazyInit(AllFields);	105	response->lazyInit(AllFields);
106	response->m_httpHeaderFields.adopt(WTF::move(data->m_httpHeaders));	106	response->m_httpHeaderFields.adopt(WTF::move(data->m_httpHeaders));
107	response->m_resourceLoadTiming = data->m_resourceLoadTiming;	107	response->m_resourceLoadTiming = data->m_resourceLoadTiming;
108	response->doPlatformAdopt(data);	108	response->doPlatformAdopt(WTF::move(data));
109	return response.release();	109	return response;
110	}	110	}
111		111
112	PassOwnPtr<CrossThreadResourceResponseData> ResourceResponseBase::copyData() const	112	std::unique_ptr<CrossThreadResourceResponseData> ResourceResponseBase::copyData() const
113	{	113	{
114	OwnPtr<CrossThreadResourceResponseData> data = adoptPtr(new CrossThreadResourceResponseData);	114	auto data = std::make_unique<CrossThreadResourceResponseData>();
115	data->m_url = url().copy();	115	data->m_url = url().copy();
116	data->m_mimeType = mimeType().isolatedCopy();	116	data->m_mimeType = mimeType().isolatedCopy();
117	data->m_expectedContentLength = expectedContentLength();	117	data->m_expectedContentLength = expectedContentLength();
Lines 120-126 PassOwnPtr<CrossThreadResourceResponseData> ResourceResponseBase::copyData() con a/Source/WebCore/platform/network/ResourceResponseBase.cpp_sec3
120	data->m_httpStatusText = httpStatusText().isolatedCopy();	120	data->m_httpStatusText = httpStatusText().isolatedCopy();
121	data->m_httpHeaders = httpHeaderFields().copyData();	121	data->m_httpHeaders = httpHeaderFields().copyData();
122	data->m_resourceLoadTiming = m_resourceLoadTiming;	122	data->m_resourceLoadTiming = m_resourceLoadTiming;
123	return asResourceResponse().doPlatformCopyData(data.release());	123	return asResourceResponse().doPlatformCopyData(WTF::move(data));
124	}	124	}
125		125
126	bool ResourceResponseBase::isHTTP() const	126	bool ResourceResponseBase::isHTTP() const

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