OLD | NEW |
| (Empty) |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "config.h" | |
6 #include "modules/serviceworkers/Response.h" | |
7 | |
8 #include "bindings/core/v8/ExceptionState.h" | |
9 #include "bindings/core/v8/ScriptState.h" | |
10 #include "core/dom/Document.h" | |
11 #include "core/frame/Frame.h" | |
12 #include "core/testing/DummyPageHolder.h" | |
13 #include "modules/serviceworkers/BodyStreamBuffer.h" | |
14 #include "modules/serviceworkers/FetchResponseData.h" | |
15 #include "platform/blob/BlobData.h" | |
16 #include "public/platform/WebServiceWorkerResponse.h" | |
17 #include <gtest/gtest.h> | |
18 | |
19 namespace blink { | |
20 namespace { | |
21 | |
22 const char kTestData[] = "Here is sample text for the blob."; | |
23 | |
24 PassOwnPtr<WebServiceWorkerResponse> createTestWebServiceWorkerResponse() | |
25 { | |
26 const KURL url(ParsedURLString, "http://www.webresponse.com/"); | |
27 const unsigned short status = 200; | |
28 const String statusText = "the best status text"; | |
29 struct { | |
30 const char* key; | |
31 const char* value; | |
32 } headers[] = { { "cache-control", "no-cache" }, { "set-cookie", "foop" }, {
"foo", "bar" }, { 0, 0 } }; | |
33 | |
34 OwnPtr<WebServiceWorkerResponse> webResponse = adoptPtr(new WebServiceWorker
Response()); | |
35 webResponse->setURL(url); | |
36 webResponse->setStatus(status); | |
37 webResponse->setStatusText(statusText); | |
38 webResponse->setResponseType(WebServiceWorkerResponseTypeDefault); | |
39 for (int i = 0; headers[i].key; ++i) | |
40 webResponse->setHeader(WebString::fromUTF8(headers[i].key), WebString::f
romUTF8(headers[i].value)); | |
41 return webResponse.release(); | |
42 } | |
43 | |
44 class BlobHandleCreatorClient final : public BodyStreamBuffer::BlobHandleCreator
Client { | |
45 public: | |
46 BlobHandleCreatorClient() | |
47 { | |
48 } | |
49 ~BlobHandleCreatorClient() override { } | |
50 void trace(Visitor* visitor) override | |
51 { | |
52 visitor->trace(m_exception); | |
53 BodyStreamBuffer::BlobHandleCreatorClient::trace(visitor); | |
54 } | |
55 void didCreateBlobHandle(PassRefPtr<BlobDataHandle> blobHandle) override | |
56 { | |
57 m_blobHandle = blobHandle; | |
58 } | |
59 void didFail(PassRefPtrWillBeRawPtr<DOMException> exception) override | |
60 { | |
61 m_exception = exception; | |
62 } | |
63 PassRefPtr<BlobDataHandle> blobHandle() | |
64 { | |
65 return m_blobHandle; | |
66 } | |
67 PassRefPtrWillBeRawPtr<DOMException> exception() | |
68 { | |
69 return m_exception; | |
70 } | |
71 | |
72 private: | |
73 RefPtr<BlobDataHandle> m_blobHandle; | |
74 RefPtrWillBeMember<DOMException> m_exception; | |
75 }; | |
76 | |
77 | |
78 class ServiceWorkerResponseTest : public ::testing::Test { | |
79 public: | |
80 ServiceWorkerResponseTest() | |
81 : m_page(DummyPageHolder::create(IntSize(1, 1))) { } | |
82 | |
83 ScriptState* scriptState() { return ScriptState::forMainWorld(m_page->docume
nt().frame()); } | |
84 ExecutionContext* executionContext() { return scriptState()->executionContex
t(); } | |
85 | |
86 private: | |
87 OwnPtr<DummyPageHolder> m_page; | |
88 }; | |
89 | |
90 | |
91 TEST_F(ServiceWorkerResponseTest, FromFetchResponseData) | |
92 { | |
93 const KURL url(ParsedURLString, "http://www.response.com"); | |
94 | |
95 FetchResponseData* fetchResponseData = FetchResponseData::create(); | |
96 fetchResponseData->setURL(url); | |
97 | |
98 Response* response = Response::create(executionContext(), fetchResponseData)
; | |
99 ASSERT(response); | |
100 EXPECT_EQ(url, response->url()); | |
101 } | |
102 | |
103 TEST_F(ServiceWorkerResponseTest, FromWebServiceWorkerResponse) | |
104 { | |
105 OwnPtr<WebServiceWorkerResponse> webResponse = createTestWebServiceWorkerRes
ponse(); | |
106 Response* response = Response::create(executionContext(), *webResponse); | |
107 ASSERT(response); | |
108 EXPECT_EQ(webResponse->url(), response->url()); | |
109 EXPECT_EQ(webResponse->status(), response->status()); | |
110 EXPECT_STREQ(webResponse->statusText().utf8().c_str(), response->statusText(
).utf8().data()); | |
111 | |
112 Headers* responseHeaders = response->headers(); | |
113 | |
114 WebVector<WebString> keys = webResponse->getHeaderKeys(); | |
115 EXPECT_EQ(keys.size(), responseHeaders->headerList()->size()); | |
116 for (size_t i = 0, max = keys.size(); i < max; ++i) { | |
117 WebString key = keys[i]; | |
118 TrackExceptionState exceptionState; | |
119 EXPECT_STREQ(webResponse->getHeader(key).utf8().c_str(), responseHeaders
->get(key, exceptionState).utf8().data()); | |
120 EXPECT_FALSE(exceptionState.hadException()); | |
121 } | |
122 } | |
123 | |
124 TEST_F(ServiceWorkerResponseTest, FromWebServiceWorkerResponseDefault) | |
125 { | |
126 OwnPtr<WebServiceWorkerResponse> webResponse = createTestWebServiceWorkerRes
ponse(); | |
127 webResponse->setResponseType(WebServiceWorkerResponseTypeDefault); | |
128 Response* response = Response::create(executionContext(), *webResponse); | |
129 | |
130 Headers* responseHeaders = response->headers(); | |
131 TrackExceptionState exceptionState; | |
132 EXPECT_STREQ("foop", responseHeaders->get("set-cookie", exceptionState).utf8
().data()); | |
133 EXPECT_STREQ("bar", responseHeaders->get("foo", exceptionState).utf8().data(
)); | |
134 EXPECT_STREQ("no-cache", responseHeaders->get("cache-control", exceptionStat
e).utf8().data()); | |
135 EXPECT_FALSE(exceptionState.hadException()); | |
136 } | |
137 | |
138 TEST_F(ServiceWorkerResponseTest, FromWebServiceWorkerResponseBasic) | |
139 { | |
140 OwnPtr<WebServiceWorkerResponse> webResponse = createTestWebServiceWorkerRes
ponse(); | |
141 webResponse->setResponseType(WebServiceWorkerResponseTypeBasic); | |
142 Response* response = Response::create(executionContext(), *webResponse); | |
143 | |
144 Headers* responseHeaders = response->headers(); | |
145 TrackExceptionState exceptionState; | |
146 EXPECT_STREQ("", responseHeaders->get("set-cookie", exceptionState).utf8().d
ata()); | |
147 EXPECT_STREQ("bar", responseHeaders->get("foo", exceptionState).utf8().data(
)); | |
148 EXPECT_STREQ("no-cache", responseHeaders->get("cache-control", exceptionStat
e).utf8().data()); | |
149 EXPECT_FALSE(exceptionState.hadException()); | |
150 } | |
151 | |
152 TEST_F(ServiceWorkerResponseTest, FromWebServiceWorkerResponseCORS) | |
153 { | |
154 OwnPtr<WebServiceWorkerResponse> webResponse = createTestWebServiceWorkerRes
ponse(); | |
155 webResponse->setResponseType(WebServiceWorkerResponseTypeCORS); | |
156 Response* response = Response::create(executionContext(), *webResponse); | |
157 | |
158 Headers* responseHeaders = response->headers(); | |
159 TrackExceptionState exceptionState; | |
160 EXPECT_STREQ("", responseHeaders->get("set-cookie", exceptionState).utf8().d
ata()); | |
161 EXPECT_STREQ("", responseHeaders->get("foo", exceptionState).utf8().data()); | |
162 EXPECT_STREQ("no-cache", responseHeaders->get("cache-control", exceptionStat
e).utf8().data()); | |
163 EXPECT_FALSE(exceptionState.hadException()); | |
164 } | |
165 | |
166 TEST_F(ServiceWorkerResponseTest, FromWebServiceWorkerResponseOpaque) | |
167 { | |
168 OwnPtr<WebServiceWorkerResponse> webResponse = createTestWebServiceWorkerRes
ponse(); | |
169 webResponse->setResponseType(WebServiceWorkerResponseTypeOpaque); | |
170 Response* response = Response::create(executionContext(), *webResponse); | |
171 | |
172 Headers* responseHeaders = response->headers(); | |
173 TrackExceptionState exceptionState; | |
174 EXPECT_STREQ("", responseHeaders->get("set-cookie", exceptionState).utf8().d
ata()); | |
175 EXPECT_STREQ("", responseHeaders->get("foo", exceptionState).utf8().data()); | |
176 EXPECT_STREQ("", responseHeaders->get("cache-control", exceptionState).utf8(
).data()); | |
177 EXPECT_FALSE(exceptionState.hadException()); | |
178 } | |
179 | |
180 void checkResponseBlobHandle(Response* response, bool hasNonInternalBlobHandle,
const unsigned long long blobSize) | |
181 { | |
182 EXPECT_TRUE(response->internalBlobDataHandle()); | |
183 EXPECT_EQ(blobSize, response->internalBlobDataHandle()->size()); | |
184 EXPECT_FALSE(response->internalBuffer()); | |
185 if (hasNonInternalBlobHandle) { | |
186 EXPECT_TRUE(response->blobDataHandle()); | |
187 EXPECT_EQ(response->blobDataHandle(), response->internalBlobDataHandle()
); | |
188 EXPECT_EQ(blobSize, response->blobDataHandle()->size()); | |
189 } else { | |
190 EXPECT_FALSE(response->blobDataHandle()); | |
191 } | |
192 EXPECT_FALSE(response->buffer()); | |
193 | |
194 TrackExceptionState exceptionState; | |
195 Response* clonedResponse = response->clone(exceptionState); | |
196 EXPECT_FALSE(exceptionState.hadException()); | |
197 | |
198 EXPECT_TRUE(response->internalBlobDataHandle()); | |
199 EXPECT_EQ(blobSize, clonedResponse->internalBlobDataHandle()->size()); | |
200 EXPECT_EQ(response->internalBlobDataHandle(), clonedResponse->internalBlobDa
taHandle()); | |
201 EXPECT_FALSE(response->internalBuffer()); | |
202 EXPECT_FALSE(clonedResponse->internalBuffer()); | |
203 if (hasNonInternalBlobHandle) { | |
204 EXPECT_EQ(response->internalBlobDataHandle(), response->blobDataHandle()
); | |
205 EXPECT_EQ(clonedResponse->internalBlobDataHandle(), clonedResponse->blob
DataHandle()); | |
206 } else { | |
207 EXPECT_FALSE(response->blobDataHandle()); | |
208 EXPECT_FALSE(clonedResponse->blobDataHandle()); | |
209 } | |
210 EXPECT_FALSE(response->buffer()); | |
211 EXPECT_FALSE(clonedResponse->buffer()); | |
212 } | |
213 | |
214 TEST_F(ServiceWorkerResponseTest, BlobHandleCloneDefault) | |
215 { | |
216 FetchResponseData* fetchResponseData = FetchResponseData::create(); | |
217 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com")); | |
218 OwnPtr<BlobData> blobData(BlobData::create()); | |
219 blobData->appendBytes(kTestData, sizeof(kTestData) - 1); | |
220 const unsigned long long size = blobData->length(); | |
221 fetchResponseData->setBlobDataHandle(BlobDataHandle::create(blobData.release
(), size)); | |
222 checkResponseBlobHandle(Response::create(executionContext(), fetchResponseDa
ta), true, size); | |
223 } | |
224 | |
225 TEST_F(ServiceWorkerResponseTest, BlobHandleCloneBasic) | |
226 { | |
227 FetchResponseData* fetchResponseData = FetchResponseData::create(); | |
228 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com")); | |
229 OwnPtr<BlobData> blobData(BlobData::create()); | |
230 blobData->appendBytes(kTestData, sizeof(kTestData) - 1); | |
231 const unsigned long long size = blobData->length(); | |
232 fetchResponseData->setBlobDataHandle(BlobDataHandle::create(blobData.release
(), size)); | |
233 fetchResponseData = fetchResponseData->createBasicFilteredResponse(); | |
234 checkResponseBlobHandle(Response::create(executionContext(), fetchResponseDa
ta), true, size); | |
235 } | |
236 | |
237 TEST_F(ServiceWorkerResponseTest, BlobHandleCloneCORS) | |
238 { | |
239 FetchResponseData* fetchResponseData = FetchResponseData::create(); | |
240 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com")); | |
241 OwnPtr<BlobData> blobData(BlobData::create()); | |
242 blobData->appendBytes(kTestData, sizeof(kTestData) - 1); | |
243 const unsigned long long size = blobData->length(); | |
244 fetchResponseData->setBlobDataHandle(BlobDataHandle::create(blobData.release
(), size)); | |
245 fetchResponseData = fetchResponseData->createCORSFilteredResponse(); | |
246 checkResponseBlobHandle(Response::create(executionContext(), fetchResponseDa
ta), true, size); | |
247 } | |
248 | |
249 TEST_F(ServiceWorkerResponseTest, BlobHandleCloneOpaque) | |
250 { | |
251 FetchResponseData* fetchResponseData = FetchResponseData::create(); | |
252 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com")); | |
253 OwnPtr<BlobData> blobData(BlobData::create()); | |
254 blobData->appendBytes(kTestData, sizeof(kTestData) - 1); | |
255 const unsigned long long size = blobData->length(); | |
256 fetchResponseData->setBlobDataHandle(BlobDataHandle::create(blobData.release
(), size)); | |
257 fetchResponseData = fetchResponseData->createOpaqueFilteredResponse(); | |
258 checkResponseBlobHandle(Response::create(executionContext(), fetchResponseDa
ta), false, size); | |
259 } | |
260 | |
261 void checkResponseStream(Response* response, bool checkResponseBodyStreamBuffer) | |
262 { | |
263 BodyStreamBuffer* buffer = response->internalBuffer(); | |
264 EXPECT_FALSE(response->internalBlobDataHandle()); | |
265 EXPECT_FALSE(response->blobDataHandle()); | |
266 if (checkResponseBodyStreamBuffer) { | |
267 EXPECT_EQ(response->buffer(), buffer); | |
268 } else { | |
269 EXPECT_FALSE(response->buffer()); | |
270 } | |
271 | |
272 TrackExceptionState exceptionState; | |
273 Response* clonedResponse = response->clone(exceptionState); | |
274 EXPECT_FALSE(exceptionState.hadException()); | |
275 EXPECT_FALSE(response->internalBlobDataHandle()); | |
276 EXPECT_FALSE(response->blobDataHandle()); | |
277 EXPECT_FALSE(clonedResponse->internalBlobDataHandle()); | |
278 EXPECT_FALSE(clonedResponse->blobDataHandle()); | |
279 | |
280 EXPECT_TRUE(response->internalBuffer()); | |
281 EXPECT_TRUE(clonedResponse->internalBuffer()); | |
282 EXPECT_NE(response->internalBuffer(), buffer); | |
283 EXPECT_NE(clonedResponse->internalBuffer(), buffer); | |
284 EXPECT_NE(response->internalBuffer(), clonedResponse->internalBuffer()); | |
285 if (checkResponseBodyStreamBuffer) { | |
286 EXPECT_EQ(response->buffer(), response->internalBuffer()); | |
287 EXPECT_EQ(clonedResponse->buffer(), clonedResponse->internalBuffer()); | |
288 } else { | |
289 EXPECT_FALSE(response->buffer()); | |
290 EXPECT_FALSE(clonedResponse->buffer()); | |
291 } | |
292 BlobHandleCreatorClient* client1 = new BlobHandleCreatorClient(); | |
293 BlobHandleCreatorClient* client2 = new BlobHandleCreatorClient(); | |
294 EXPECT_TRUE(response->internalBuffer()->readAllAndCreateBlobHandle(response-
>internalContentTypeForBuffer(), client1)); | |
295 EXPECT_TRUE(clonedResponse->internalBuffer()->readAllAndCreateBlobHandle(clo
nedResponse->internalContentTypeForBuffer(), client2)); | |
296 buffer->write(DOMArrayBuffer::create("foobar", 6)); | |
297 buffer->write(DOMArrayBuffer::create("piyo", 4)); | |
298 EXPECT_FALSE(client1->blobHandle()); | |
299 EXPECT_FALSE(client2->blobHandle()); | |
300 buffer->close(); | |
301 EXPECT_TRUE(client1->blobHandle()); | |
302 EXPECT_TRUE(client2->blobHandle()); | |
303 EXPECT_EQ(10u, client1->blobHandle()->size()); | |
304 EXPECT_EQ(10u, client2->blobHandle()->size()); | |
305 } | |
306 | |
307 TEST_F(ServiceWorkerResponseTest, BodyStreamBufferCloneDefault) | |
308 { | |
309 BodyStreamBuffer* buffer = new BodyStreamBuffer(); | |
310 FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(b
uffer); | |
311 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com")); | |
312 Response* response = Response::create(executionContext(), fetchResponseData)
; | |
313 EXPECT_EQ(response->internalBuffer(), buffer); | |
314 checkResponseStream(response, true); | |
315 } | |
316 | |
317 TEST_F(ServiceWorkerResponseTest, BodyStreamBufferCloneBasic) | |
318 { | |
319 BodyStreamBuffer* buffer = new BodyStreamBuffer(); | |
320 FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(b
uffer); | |
321 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com")); | |
322 fetchResponseData = fetchResponseData->createBasicFilteredResponse(); | |
323 Response* response = Response::create(executionContext(), fetchResponseData)
; | |
324 EXPECT_EQ(response->internalBuffer(), buffer); | |
325 checkResponseStream(response, true); | |
326 } | |
327 | |
328 TEST_F(ServiceWorkerResponseTest, BodyStreamBufferCloneCORS) | |
329 { | |
330 BodyStreamBuffer* buffer = new BodyStreamBuffer(); | |
331 FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(b
uffer); | |
332 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com")); | |
333 fetchResponseData = fetchResponseData->createCORSFilteredResponse(); | |
334 Response* response = Response::create(executionContext(), fetchResponseData)
; | |
335 EXPECT_EQ(response->internalBuffer(), buffer); | |
336 checkResponseStream(response, true); | |
337 } | |
338 | |
339 TEST_F(ServiceWorkerResponseTest, BodyStreamBufferCloneOpaque) | |
340 { | |
341 BodyStreamBuffer* buffer = new BodyStreamBuffer(); | |
342 FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(b
uffer); | |
343 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com")); | |
344 fetchResponseData = fetchResponseData->createOpaqueFilteredResponse(); | |
345 Response* response = Response::create(executionContext(), fetchResponseData)
; | |
346 EXPECT_EQ(response->internalBuffer(), buffer); | |
347 checkResponseStream(response, false); | |
348 } | |
349 | |
350 TEST_F(ServiceWorkerResponseTest, BodyStreamBufferCloneError) | |
351 { | |
352 BodyStreamBuffer* buffer = new BodyStreamBuffer(); | |
353 FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(b
uffer); | |
354 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com")); | |
355 Response* response = Response::create(executionContext(), fetchResponseData)
; | |
356 TrackExceptionState exceptionState; | |
357 Response* clonedResponse = response->clone(exceptionState); | |
358 EXPECT_FALSE(exceptionState.hadException()); | |
359 BlobHandleCreatorClient* client1 = new BlobHandleCreatorClient(); | |
360 BlobHandleCreatorClient* client2 = new BlobHandleCreatorClient(); | |
361 EXPECT_TRUE(response->internalBuffer()->readAllAndCreateBlobHandle(response-
>internalContentTypeForBuffer(), client1)); | |
362 EXPECT_TRUE(clonedResponse->internalBuffer()->readAllAndCreateBlobHandle(clo
nedResponse->internalContentTypeForBuffer(), client2)); | |
363 buffer->write(DOMArrayBuffer::create("foobar", 6)); | |
364 buffer->write(DOMArrayBuffer::create("piyo", 4)); | |
365 EXPECT_FALSE(client1->blobHandle()); | |
366 EXPECT_FALSE(client2->blobHandle()); | |
367 buffer->error(DOMException::create(NetworkError, "Error Message")); | |
368 EXPECT_EQ("NetworkError", client1->exception()->name()); | |
369 EXPECT_EQ("Error Message", client1->exception()->message()); | |
370 EXPECT_EQ("NetworkError", client2->exception()->name()); | |
371 EXPECT_EQ("Error Message", client2->exception()->message()); | |
372 } | |
373 | |
374 } // namespace | |
375 } // namespace blink | |
OLD | NEW |