OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "config.h" | 5 #include "config.h" |
6 #include "modules/fetch/Response.h" | 6 #include "modules/fetch/Response.h" |
7 | 7 |
8 #include "bindings/core/v8/ExceptionState.h" | 8 #include "bindings/core/v8/ExceptionState.h" |
9 #include "bindings/core/v8/ScriptState.h" | 9 #include "bindings/core/v8/ScriptState.h" |
10 #include "core/dom/Document.h" | 10 #include "core/dom/Document.h" |
11 #include "core/frame/Frame.h" | 11 #include "core/frame/Frame.h" |
12 #include "core/testing/DummyPageHolder.h" | 12 #include "core/testing/DummyPageHolder.h" |
13 #include "modules/fetch/BodyStreamBuffer.h" | 13 #include "modules/fetch/BodyStreamBuffer.h" |
| 14 #include "modules/fetch/DataConsumerHandleTestUtil.h" |
| 15 #include "modules/fetch/DataConsumerHandleUtil.h" |
14 #include "modules/fetch/FetchResponseData.h" | 16 #include "modules/fetch/FetchResponseData.h" |
15 #include "platform/blob/BlobData.h" | 17 #include "platform/blob/BlobData.h" |
| 18 #include "platform/testing/UnitTestHelpers.h" |
16 #include "public/platform/WebServiceWorkerResponse.h" | 19 #include "public/platform/WebServiceWorkerResponse.h" |
17 #include <gtest/gtest.h> | 20 #include <gtest/gtest.h> |
18 | 21 |
19 namespace blink { | 22 namespace blink { |
20 namespace { | 23 namespace { |
21 | 24 |
22 const char kTestData[] = "Here is sample text for the blob."; | |
23 | |
24 class MockCanceller : public BodyStreamBuffer::Canceller { | |
25 public: | |
26 MockCanceller() : m_counter(0) { } | |
27 void cancel() override { ++m_counter; } | |
28 int counter() const { return m_counter; } | |
29 | |
30 private: | |
31 int m_counter; | |
32 }; | |
33 | |
34 PassOwnPtr<WebServiceWorkerResponse> createTestWebServiceWorkerResponse() | 25 PassOwnPtr<WebServiceWorkerResponse> createTestWebServiceWorkerResponse() |
35 { | 26 { |
36 const KURL url(ParsedURLString, "http://www.webresponse.com/"); | 27 const KURL url(ParsedURLString, "http://www.webresponse.com/"); |
37 const unsigned short status = 200; | 28 const unsigned short status = 200; |
38 const String statusText = "the best status text"; | 29 const String statusText = "the best status text"; |
39 struct { | 30 struct { |
40 const char* key; | 31 const char* key; |
41 const char* value; | 32 const char* value; |
42 } headers[] = { { "cache-control", "no-cache" }, { "set-cookie", "foop" }, {
"foo", "bar" }, { 0, 0 } }; | 33 } headers[] = { { "cache-control", "no-cache" }, { "set-cookie", "foop" }, {
"foo", "bar" }, { 0, 0 } }; |
43 | 34 |
44 OwnPtr<WebServiceWorkerResponse> webResponse = adoptPtr(new WebServiceWorker
Response()); | 35 OwnPtr<WebServiceWorkerResponse> webResponse = adoptPtr(new WebServiceWorker
Response()); |
45 webResponse->setURL(url); | 36 webResponse->setURL(url); |
46 webResponse->setStatus(status); | 37 webResponse->setStatus(status); |
47 webResponse->setStatusText(statusText); | 38 webResponse->setStatusText(statusText); |
48 webResponse->setResponseType(WebServiceWorkerResponseTypeDefault); | 39 webResponse->setResponseType(WebServiceWorkerResponseTypeDefault); |
49 for (int i = 0; headers[i].key; ++i) | 40 for (int i = 0; headers[i].key; ++i) |
50 webResponse->setHeader(WebString::fromUTF8(headers[i].key), WebString::f
romUTF8(headers[i].value)); | 41 webResponse->setHeader(WebString::fromUTF8(headers[i].key), WebString::f
romUTF8(headers[i].value)); |
51 return webResponse.release(); | 42 return webResponse.release(); |
52 } | 43 } |
53 | 44 |
54 class BlobHandleCreatorClient final : public BodyStreamBuffer::BlobHandleCreator
Client { | |
55 public: | |
56 BlobHandleCreatorClient() | |
57 { | |
58 } | |
59 ~BlobHandleCreatorClient() override { } | |
60 DEFINE_INLINE_VIRTUAL_TRACE() | |
61 { | |
62 visitor->trace(m_exception); | |
63 BodyStreamBuffer::BlobHandleCreatorClient::trace(visitor); | |
64 } | |
65 void didCreateBlobHandle(PassRefPtr<BlobDataHandle> blobHandle) override | |
66 { | |
67 m_blobHandle = blobHandle; | |
68 } | |
69 void didFail(DOMException* exception) override | |
70 { | |
71 m_exception = exception; | |
72 } | |
73 PassRefPtr<BlobDataHandle> blobHandle() | |
74 { | |
75 return m_blobHandle; | |
76 } | |
77 DOMException* exception() | |
78 { | |
79 return m_exception; | |
80 } | |
81 | |
82 private: | |
83 RefPtr<BlobDataHandle> m_blobHandle; | |
84 Member<DOMException> m_exception; | |
85 }; | |
86 | |
87 | |
88 class ServiceWorkerResponseTest : public ::testing::Test { | 45 class ServiceWorkerResponseTest : public ::testing::Test { |
89 public: | 46 public: |
90 ServiceWorkerResponseTest() | 47 ServiceWorkerResponseTest() |
91 : m_page(DummyPageHolder::create(IntSize(1, 1))) { } | 48 : m_page(DummyPageHolder::create(IntSize(1, 1))) { } |
92 | 49 |
93 ScriptState* scriptState() { return ScriptState::forMainWorld(m_page->docume
nt().frame()); } | 50 ScriptState* scriptState() { return ScriptState::forMainWorld(m_page->docume
nt().frame()); } |
94 ExecutionContext* executionContext() { return scriptState()->executionContex
t(); } | 51 ExecutionContext* executionContext() { return scriptState()->executionContex
t(); } |
95 | 52 |
96 private: | 53 private: |
97 OwnPtr<DummyPageHolder> m_page; | 54 OwnPtr<DummyPageHolder> m_page; |
(...skipping 82 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
180 Response* response = Response::create(executionContext(), *webResponse); | 137 Response* response = Response::create(executionContext(), *webResponse); |
181 | 138 |
182 Headers* responseHeaders = response->headers(); | 139 Headers* responseHeaders = response->headers(); |
183 TrackExceptionState exceptionState; | 140 TrackExceptionState exceptionState; |
184 EXPECT_STREQ("", responseHeaders->get("set-cookie", exceptionState).utf8().d
ata()); | 141 EXPECT_STREQ("", responseHeaders->get("set-cookie", exceptionState).utf8().d
ata()); |
185 EXPECT_STREQ("", responseHeaders->get("foo", exceptionState).utf8().data()); | 142 EXPECT_STREQ("", responseHeaders->get("foo", exceptionState).utf8().data()); |
186 EXPECT_STREQ("", responseHeaders->get("cache-control", exceptionState).utf8(
).data()); | 143 EXPECT_STREQ("", responseHeaders->get("cache-control", exceptionState).utf8(
).data()); |
187 EXPECT_FALSE(exceptionState.hadException()); | 144 EXPECT_FALSE(exceptionState.hadException()); |
188 } | 145 } |
189 | 146 |
190 void checkResponseBlobHandle(Response* response, bool hasNonInternalBlobHandle,
const unsigned long long blobSize) | |
191 { | |
192 EXPECT_TRUE(response->internalBlobDataHandle()); | |
193 EXPECT_EQ(blobSize, response->internalBlobDataHandle()->size()); | |
194 EXPECT_FALSE(response->internalBuffer()); | |
195 if (hasNonInternalBlobHandle) { | |
196 EXPECT_TRUE(response->blobDataHandle()); | |
197 EXPECT_EQ(response->blobDataHandle(), response->internalBlobDataHandle()
); | |
198 EXPECT_EQ(blobSize, response->blobDataHandle()->size()); | |
199 } else { | |
200 EXPECT_FALSE(response->blobDataHandle()); | |
201 } | |
202 EXPECT_FALSE(response->buffer()); | |
203 | |
204 TrackExceptionState exceptionState; | |
205 Response* clonedResponse = response->clone(exceptionState); | |
206 EXPECT_FALSE(exceptionState.hadException()); | |
207 | |
208 EXPECT_TRUE(response->internalBlobDataHandle()); | |
209 EXPECT_EQ(blobSize, clonedResponse->internalBlobDataHandle()->size()); | |
210 EXPECT_EQ(response->internalBlobDataHandle(), clonedResponse->internalBlobDa
taHandle()); | |
211 EXPECT_FALSE(response->internalBuffer()); | |
212 EXPECT_FALSE(clonedResponse->internalBuffer()); | |
213 if (hasNonInternalBlobHandle) { | |
214 EXPECT_EQ(response->internalBlobDataHandle(), response->blobDataHandle()
); | |
215 EXPECT_EQ(clonedResponse->internalBlobDataHandle(), clonedResponse->blob
DataHandle()); | |
216 } else { | |
217 EXPECT_FALSE(response->blobDataHandle()); | |
218 EXPECT_FALSE(clonedResponse->blobDataHandle()); | |
219 } | |
220 EXPECT_FALSE(response->buffer()); | |
221 EXPECT_FALSE(clonedResponse->buffer()); | |
222 } | |
223 | |
224 TEST_F(ServiceWorkerResponseTest, BlobHandleCloneDefault) | |
225 { | |
226 FetchResponseData* fetchResponseData = FetchResponseData::create(); | |
227 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com")); | |
228 OwnPtr<BlobData> blobData(BlobData::create()); | |
229 blobData->appendBytes(kTestData, sizeof(kTestData) - 1); | |
230 const unsigned long long size = blobData->length(); | |
231 fetchResponseData->setBlobDataHandle(BlobDataHandle::create(blobData.release
(), size)); | |
232 checkResponseBlobHandle(Response::create(executionContext(), fetchResponseDa
ta), true, size); | |
233 } | |
234 | |
235 TEST_F(ServiceWorkerResponseTest, BlobHandleCloneBasic) | |
236 { | |
237 FetchResponseData* fetchResponseData = FetchResponseData::create(); | |
238 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com")); | |
239 OwnPtr<BlobData> blobData(BlobData::create()); | |
240 blobData->appendBytes(kTestData, sizeof(kTestData) - 1); | |
241 const unsigned long long size = blobData->length(); | |
242 fetchResponseData->setBlobDataHandle(BlobDataHandle::create(blobData.release
(), size)); | |
243 fetchResponseData = fetchResponseData->createBasicFilteredResponse(); | |
244 checkResponseBlobHandle(Response::create(executionContext(), fetchResponseDa
ta), true, size); | |
245 } | |
246 | |
247 TEST_F(ServiceWorkerResponseTest, BlobHandleCloneCORS) | |
248 { | |
249 FetchResponseData* fetchResponseData = FetchResponseData::create(); | |
250 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com")); | |
251 OwnPtr<BlobData> blobData(BlobData::create()); | |
252 blobData->appendBytes(kTestData, sizeof(kTestData) - 1); | |
253 const unsigned long long size = blobData->length(); | |
254 fetchResponseData->setBlobDataHandle(BlobDataHandle::create(blobData.release
(), size)); | |
255 fetchResponseData = fetchResponseData->createCORSFilteredResponse(); | |
256 checkResponseBlobHandle(Response::create(executionContext(), fetchResponseDa
ta), true, size); | |
257 } | |
258 | |
259 TEST_F(ServiceWorkerResponseTest, BlobHandleCloneOpaque) | |
260 { | |
261 FetchResponseData* fetchResponseData = FetchResponseData::create(); | |
262 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com")); | |
263 OwnPtr<BlobData> blobData(BlobData::create()); | |
264 blobData->appendBytes(kTestData, sizeof(kTestData) - 1); | |
265 const unsigned long long size = blobData->length(); | |
266 fetchResponseData->setBlobDataHandle(BlobDataHandle::create(blobData.release
(), size)); | |
267 fetchResponseData = fetchResponseData->createOpaqueFilteredResponse(); | |
268 checkResponseBlobHandle(Response::create(executionContext(), fetchResponseDa
ta), false, size); | |
269 } | |
270 | |
271 void checkResponseStream(Response* response, bool checkResponseBodyStreamBuffer) | 147 void checkResponseStream(Response* response, bool checkResponseBodyStreamBuffer) |
272 { | 148 { |
273 BodyStreamBuffer* buffer = response->internalBuffer(); | 149 BodyStreamBuffer2* buffer = response->internalBuffer(); |
274 EXPECT_FALSE(response->internalBlobDataHandle()); | |
275 EXPECT_FALSE(response->blobDataHandle()); | |
276 if (checkResponseBodyStreamBuffer) { | 150 if (checkResponseBodyStreamBuffer) { |
277 EXPECT_EQ(response->buffer(), buffer); | 151 EXPECT_EQ(response->buffer(), buffer); |
278 } else { | 152 } else { |
279 EXPECT_FALSE(response->buffer()); | 153 EXPECT_FALSE(response->buffer()); |
280 } | 154 } |
281 | 155 |
282 TrackExceptionState exceptionState; | 156 TrackExceptionState exceptionState; |
283 Response* clonedResponse = response->clone(exceptionState); | 157 Response* clonedResponse = response->clone(exceptionState); |
284 EXPECT_FALSE(exceptionState.hadException()); | 158 EXPECT_FALSE(exceptionState.hadException()); |
285 EXPECT_FALSE(response->internalBlobDataHandle()); | |
286 EXPECT_FALSE(response->blobDataHandle()); | |
287 EXPECT_FALSE(clonedResponse->internalBlobDataHandle()); | |
288 EXPECT_FALSE(clonedResponse->blobDataHandle()); | |
289 | 159 |
290 EXPECT_TRUE(response->internalBuffer()); | 160 EXPECT_TRUE(response->internalBuffer()); |
291 EXPECT_TRUE(clonedResponse->internalBuffer()); | 161 EXPECT_TRUE(clonedResponse->internalBuffer()); |
292 EXPECT_NE(response->internalBuffer(), buffer); | 162 EXPECT_NE(response->internalBuffer(), buffer); |
293 EXPECT_NE(clonedResponse->internalBuffer(), buffer); | 163 EXPECT_NE(clonedResponse->internalBuffer(), buffer); |
294 EXPECT_NE(response->internalBuffer(), clonedResponse->internalBuffer()); | 164 EXPECT_NE(response->internalBuffer(), clonedResponse->internalBuffer()); |
295 if (checkResponseBodyStreamBuffer) { | 165 if (checkResponseBodyStreamBuffer) { |
296 EXPECT_EQ(response->buffer(), response->internalBuffer()); | 166 EXPECT_EQ(response->buffer(), response->internalBuffer()); |
297 EXPECT_EQ(clonedResponse->buffer(), clonedResponse->internalBuffer()); | 167 EXPECT_EQ(clonedResponse->buffer(), clonedResponse->internalBuffer()); |
298 } else { | 168 } else { |
299 EXPECT_FALSE(response->buffer()); | 169 EXPECT_FALSE(response->buffer()); |
300 EXPECT_FALSE(clonedResponse->buffer()); | 170 EXPECT_FALSE(clonedResponse->buffer()); |
301 } | 171 } |
302 BlobHandleCreatorClient* client1 = new BlobHandleCreatorClient(); | 172 DataConsumerHandleTestUtil::MockFetchDataLoaderClient* client1 = new DataCon
sumerHandleTestUtil::MockFetchDataLoaderClient(); |
303 BlobHandleCreatorClient* client2 = new BlobHandleCreatorClient(); | 173 FetchDataLoader* fetchDataLoader1 = FetchDataLoader::createLoaderAsString(); |
304 EXPECT_TRUE(response->internalBuffer()->readAllAndCreateBlobHandle(response-
>internalMIMEType(), client1)); | 174 fetchDataLoader1->start(response->internalBuffer()->handle(), client1); |
305 EXPECT_TRUE(clonedResponse->internalBuffer()->readAllAndCreateBlobHandle(clo
nedResponse->internalMIMEType(), client2)); | 175 |
306 buffer->write(DOMArrayBuffer::create("foobar", 6)); | 176 DataConsumerHandleTestUtil::MockFetchDataLoaderClient* client2 = new DataCon
sumerHandleTestUtil::MockFetchDataLoaderClient(); |
307 buffer->write(DOMArrayBuffer::create("piyo", 4)); | 177 FetchDataLoader* fetchDataLoader2 = FetchDataLoader::createLoaderAsString(); |
308 EXPECT_FALSE(client1->blobHandle()); | 178 fetchDataLoader2->start(clonedResponse->internalBuffer()->handle(), client2)
; |
309 EXPECT_FALSE(client2->blobHandle()); | 179 |
310 buffer->close(); | 180 EXPECT_CALL(*client1, didFetchDataLoadedString(String("Hello, world"))); |
311 EXPECT_TRUE(client1->blobHandle()); | 181 EXPECT_CALL(*client2, didFetchDataLoadedString(String("Hello, world"))); |
312 EXPECT_TRUE(client2->blobHandle()); | 182 |
313 EXPECT_EQ(10u, client1->blobHandle()->size()); | 183 blink::testing::runPendingTasks(); |
314 EXPECT_EQ(10u, client2->blobHandle()->size()); | 184 } |
| 185 |
| 186 BodyStreamBuffer2* createHelloWorldBuffer() |
| 187 { |
| 188 using Command = DataConsumerHandleTestUtil::Command; |
| 189 OwnPtr<DataConsumerHandleTestUtil::ReplayingHandle> src(adoptPtr(new DataCon
sumerHandleTestUtil::ReplayingHandle)); |
| 190 src->add(Command(Command::Data, "Hello, ")); |
| 191 src->add(Command(Command::Data, "world")); |
| 192 src->add(Command(Command::Done)); |
| 193 return BodyStreamBuffer2::create(createFetchDataConsumerHandleFromWebHandle(
src.release())); |
315 } | 194 } |
316 | 195 |
317 TEST_F(ServiceWorkerResponseTest, BodyStreamBufferCloneDefault) | 196 TEST_F(ServiceWorkerResponseTest, BodyStreamBufferCloneDefault) |
318 { | 197 { |
319 BodyStreamBuffer* buffer = new BodyStreamBuffer(new MockCanceller); | 198 BodyStreamBuffer2* buffer = createHelloWorldBuffer(); |
320 FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(b
uffer); | 199 FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(b
uffer); |
321 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com")); | 200 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com")); |
322 Response* response = Response::create(executionContext(), fetchResponseData)
; | 201 Response* response = Response::create(executionContext(), fetchResponseData)
; |
323 EXPECT_EQ(response->internalBuffer(), buffer); | 202 EXPECT_EQ(response->internalBuffer(), buffer); |
324 checkResponseStream(response, true); | 203 checkResponseStream(response, true); |
325 } | 204 } |
326 | 205 |
327 TEST_F(ServiceWorkerResponseTest, BodyStreamBufferCloneBasic) | 206 TEST_F(ServiceWorkerResponseTest, BodyStreamBufferCloneBasic) |
328 { | 207 { |
329 BodyStreamBuffer* buffer = new BodyStreamBuffer(new MockCanceller); | 208 BodyStreamBuffer2* buffer = createHelloWorldBuffer(); |
330 FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(b
uffer); | 209 FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(b
uffer); |
331 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com")); | 210 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com")); |
332 fetchResponseData = fetchResponseData->createBasicFilteredResponse(); | 211 fetchResponseData = fetchResponseData->createBasicFilteredResponse(); |
333 Response* response = Response::create(executionContext(), fetchResponseData)
; | 212 Response* response = Response::create(executionContext(), fetchResponseData)
; |
334 EXPECT_EQ(response->internalBuffer(), buffer); | 213 EXPECT_EQ(response->internalBuffer(), buffer); |
335 checkResponseStream(response, true); | 214 checkResponseStream(response, true); |
336 } | 215 } |
337 | 216 |
338 TEST_F(ServiceWorkerResponseTest, BodyStreamBufferCloneCORS) | 217 TEST_F(ServiceWorkerResponseTest, BodyStreamBufferCloneCORS) |
339 { | 218 { |
340 BodyStreamBuffer* buffer = new BodyStreamBuffer(new MockCanceller); | 219 BodyStreamBuffer2* buffer = createHelloWorldBuffer(); |
341 FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(b
uffer); | 220 FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(b
uffer); |
342 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com")); | 221 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com")); |
343 fetchResponseData = fetchResponseData->createCORSFilteredResponse(); | 222 fetchResponseData = fetchResponseData->createCORSFilteredResponse(); |
344 Response* response = Response::create(executionContext(), fetchResponseData)
; | 223 Response* response = Response::create(executionContext(), fetchResponseData)
; |
345 EXPECT_EQ(response->internalBuffer(), buffer); | 224 EXPECT_EQ(response->internalBuffer(), buffer); |
346 checkResponseStream(response, true); | 225 checkResponseStream(response, true); |
347 } | 226 } |
348 | 227 |
349 TEST_F(ServiceWorkerResponseTest, BodyStreamBufferCloneOpaque) | 228 TEST_F(ServiceWorkerResponseTest, BodyStreamBufferCloneOpaque) |
350 { | 229 { |
351 BodyStreamBuffer* buffer = new BodyStreamBuffer(new MockCanceller); | 230 BodyStreamBuffer2* buffer = createHelloWorldBuffer(); |
352 FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(b
uffer); | 231 FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(b
uffer); |
353 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com")); | 232 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com")); |
354 fetchResponseData = fetchResponseData->createOpaqueFilteredResponse(); | 233 fetchResponseData = fetchResponseData->createOpaqueFilteredResponse(); |
355 Response* response = Response::create(executionContext(), fetchResponseData)
; | 234 Response* response = Response::create(executionContext(), fetchResponseData)
; |
356 EXPECT_EQ(response->internalBuffer(), buffer); | 235 EXPECT_EQ(response->internalBuffer(), buffer); |
357 checkResponseStream(response, false); | 236 checkResponseStream(response, false); |
358 } | 237 } |
359 | 238 |
360 TEST_F(ServiceWorkerResponseTest, BodyStreamBufferCloneError) | 239 TEST_F(ServiceWorkerResponseTest, BodyStreamBufferCloneError) |
361 { | 240 { |
362 BodyStreamBuffer* buffer = new BodyStreamBuffer(new MockCanceller); | 241 BodyStreamBuffer2* buffer = BodyStreamBuffer2::create(createFetchDataConsume
rHandleFromWebHandle(createUnexpectedErrorDataConsumerHandle())); |
363 FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(b
uffer); | 242 FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(b
uffer); |
364 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com")); | 243 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com")); |
365 Response* response = Response::create(executionContext(), fetchResponseData)
; | 244 Response* response = Response::create(executionContext(), fetchResponseData)
; |
366 TrackExceptionState exceptionState; | 245 TrackExceptionState exceptionState; |
367 Response* clonedResponse = response->clone(exceptionState); | 246 Response* clonedResponse = response->clone(exceptionState); |
368 EXPECT_FALSE(exceptionState.hadException()); | 247 EXPECT_FALSE(exceptionState.hadException()); |
369 BlobHandleCreatorClient* client1 = new BlobHandleCreatorClient(); | |
370 BlobHandleCreatorClient* client2 = new BlobHandleCreatorClient(); | |
371 EXPECT_TRUE(response->internalBuffer()->readAllAndCreateBlobHandle(response-
>internalMIMEType(), client1)); | |
372 EXPECT_TRUE(clonedResponse->internalBuffer()->readAllAndCreateBlobHandle(clo
nedResponse->internalMIMEType(), client2)); | |
373 buffer->write(DOMArrayBuffer::create("foobar", 6)); | |
374 buffer->write(DOMArrayBuffer::create("piyo", 4)); | |
375 EXPECT_FALSE(client1->blobHandle()); | |
376 EXPECT_FALSE(client2->blobHandle()); | |
377 buffer->error(DOMException::create(NetworkError, "Error Message")); | |
378 EXPECT_EQ("NetworkError", client1->exception()->name()); | |
379 EXPECT_EQ("Error Message", client1->exception()->message()); | |
380 EXPECT_EQ("NetworkError", client2->exception()->name()); | |
381 EXPECT_EQ("Error Message", client2->exception()->message()); | |
382 } | |
383 | 248 |
384 TEST_F(ServiceWorkerResponseTest, CloneAndCancel) | 249 DataConsumerHandleTestUtil::MockFetchDataLoaderClient* client1 = new DataCon
sumerHandleTestUtil::MockFetchDataLoaderClient(); |
385 { | 250 FetchDataLoader* fetchDataLoader1 = FetchDataLoader::createLoaderAsString(); |
386 auto canceller = new MockCanceller; | 251 fetchDataLoader1->start(response->internalBuffer()->handle(), client1); |
387 BodyStreamBuffer* buffer = new BodyStreamBuffer(canceller); | |
388 FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(b
uffer); | |
389 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com")); | |
390 Response* response = Response::create(executionContext(), fetchResponseData)
; | |
391 TrackExceptionState exceptionState; | |
392 Response* clonedResponse = response->clone(exceptionState); | |
393 | 252 |
394 EXPECT_EQ(0, canceller->counter()); | 253 DataConsumerHandleTestUtil::MockFetchDataLoaderClient* client2 = new DataCon
sumerHandleTestUtil::MockFetchDataLoaderClient(); |
395 response->bufferForTest()->cancel(); | 254 FetchDataLoader* fetchDataLoader2 = FetchDataLoader::createLoaderAsString(); |
396 EXPECT_EQ(0, canceller->counter()); | 255 fetchDataLoader2->start(clonedResponse->internalBuffer()->handle(), client2)
; |
397 clonedResponse->bufferForTest()->cancel(); | 256 |
398 EXPECT_EQ(1, canceller->counter()); | 257 EXPECT_CALL(*client1, didFetchDataLoadFailed()); |
| 258 EXPECT_CALL(*client2, didFetchDataLoadFailed()); |
| 259 |
| 260 blink::testing::runPendingTasks(); |
399 } | 261 } |
400 | 262 |
401 } // namespace | 263 } // namespace |
402 } // namespace blink | 264 } // namespace blink |
OLD | NEW |