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