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 "modules/fetch/Response.h" | 5 #include "modules/fetch/Response.h" |
6 | 6 |
7 #include "bindings/core/v8/ExceptionState.h" | 7 #include "bindings/core/v8/ExceptionState.h" |
8 #include "bindings/core/v8/ScriptState.h" | 8 #include "bindings/core/v8/ScriptState.h" |
| 9 #include "bindings/core/v8/V8BindingForTesting.h" |
9 #include "core/dom/Document.h" | 10 #include "core/dom/Document.h" |
10 #include "core/frame/Frame.h" | 11 #include "core/frame/Frame.h" |
11 #include "core/testing/DummyPageHolder.h" | 12 #include "core/testing/DummyPageHolder.h" |
12 #include "modules/fetch/BodyStreamBuffer.h" | 13 #include "modules/fetch/BodyStreamBuffer.h" |
13 #include "modules/fetch/DataConsumerHandleTestUtil.h" | 14 #include "modules/fetch/DataConsumerHandleTestUtil.h" |
14 #include "modules/fetch/DataConsumerHandleUtil.h" | 15 #include "modules/fetch/DataConsumerHandleUtil.h" |
15 #include "modules/fetch/FetchResponseData.h" | 16 #include "modules/fetch/FetchResponseData.h" |
16 #include "platform/blob/BlobData.h" | 17 #include "platform/blob/BlobData.h" |
17 #include "platform/testing/UnitTestHelpers.h" | 18 #include "platform/testing/UnitTestHelpers.h" |
18 #include "public/platform/modules/serviceworker/WebServiceWorkerResponse.h" | 19 #include "public/platform/modules/serviceworker/WebServiceWorkerResponse.h" |
(...skipping 17 matching lines...) Expand all Loading... |
36 std::unique_ptr<WebServiceWorkerResponse> webResponse = wrapUnique(new WebSe
rviceWorkerResponse()); | 37 std::unique_ptr<WebServiceWorkerResponse> webResponse = wrapUnique(new WebSe
rviceWorkerResponse()); |
37 webResponse->setURL(url); | 38 webResponse->setURL(url); |
38 webResponse->setStatus(status); | 39 webResponse->setStatus(status); |
39 webResponse->setStatusText(statusText); | 40 webResponse->setStatusText(statusText); |
40 webResponse->setResponseType(WebServiceWorkerResponseTypeDefault); | 41 webResponse->setResponseType(WebServiceWorkerResponseTypeDefault); |
41 for (int i = 0; headers[i].key; ++i) | 42 for (int i = 0; headers[i].key; ++i) |
42 webResponse->setHeader(WebString::fromUTF8(headers[i].key), WebString::f
romUTF8(headers[i].value)); | 43 webResponse->setHeader(WebString::fromUTF8(headers[i].key), WebString::f
romUTF8(headers[i].value)); |
43 return webResponse; | 44 return webResponse; |
44 } | 45 } |
45 | 46 |
46 class ServiceWorkerResponseTest : public ::testing::Test { | 47 TEST(ServiceWorkerResponseTest, FromFetchResponseData) |
47 public: | |
48 ServiceWorkerResponseTest() | |
49 : m_page(DummyPageHolder::create(IntSize(1, 1))) { } | |
50 | |
51 ScriptState* getScriptState() { return ScriptState::forMainWorld(m_page->doc
ument().frame()); } | |
52 ExecutionContext* getExecutionContext() { return getScriptState()->getExecut
ionContext(); } | |
53 | |
54 private: | |
55 std::unique_ptr<DummyPageHolder> m_page; | |
56 }; | |
57 | |
58 | |
59 TEST_F(ServiceWorkerResponseTest, FromFetchResponseData) | |
60 { | 48 { |
| 49 std::unique_ptr<DummyPageHolder> page = DummyPageHolder::create(IntSize(1, 1
)); |
61 const KURL url(ParsedURLString, "http://www.response.com"); | 50 const KURL url(ParsedURLString, "http://www.response.com"); |
62 | 51 |
63 FetchResponseData* fetchResponseData = FetchResponseData::create(); | 52 FetchResponseData* fetchResponseData = FetchResponseData::create(); |
64 fetchResponseData->setURL(url); | 53 fetchResponseData->setURL(url); |
65 | 54 |
66 Response* response = Response::create(getExecutionContext(), fetchResponseDa
ta); | 55 Response* response = Response::create(&page->document(), fetchResponseData); |
67 ASSERT(response); | 56 ASSERT(response); |
68 EXPECT_EQ(url, response->url()); | 57 EXPECT_EQ(url, response->url()); |
69 } | 58 } |
70 | 59 |
71 TEST_F(ServiceWorkerResponseTest, FromWebServiceWorkerResponse) | 60 TEST(ServiceWorkerResponseTest, FromWebServiceWorkerResponse) |
72 { | 61 { |
| 62 V8TestingScope scope; |
73 std::unique_ptr<WebServiceWorkerResponse> webResponse = createTestWebService
WorkerResponse(); | 63 std::unique_ptr<WebServiceWorkerResponse> webResponse = createTestWebService
WorkerResponse(); |
74 Response* response = Response::create(getScriptState(), *webResponse); | 64 Response* response = Response::create(scope.getScriptState(), *webResponse); |
75 ASSERT(response); | 65 ASSERT(response); |
76 EXPECT_EQ(webResponse->url(), response->url()); | 66 EXPECT_EQ(webResponse->url(), response->url()); |
77 EXPECT_EQ(webResponse->status(), response->status()); | 67 EXPECT_EQ(webResponse->status(), response->status()); |
78 EXPECT_STREQ(webResponse->statusText().utf8().c_str(), response->statusText(
).utf8().data()); | 68 EXPECT_STREQ(webResponse->statusText().utf8().c_str(), response->statusText(
).utf8().data()); |
79 | 69 |
80 Headers* responseHeaders = response->headers(); | 70 Headers* responseHeaders = response->headers(); |
81 | 71 |
82 WebVector<WebString> keys = webResponse->getHeaderKeys(); | 72 WebVector<WebString> keys = webResponse->getHeaderKeys(); |
83 EXPECT_EQ(keys.size(), responseHeaders->headerList()->size()); | 73 EXPECT_EQ(keys.size(), responseHeaders->headerList()->size()); |
84 for (size_t i = 0, max = keys.size(); i < max; ++i) { | 74 for (size_t i = 0, max = keys.size(); i < max; ++i) { |
85 WebString key = keys[i]; | 75 WebString key = keys[i]; |
86 TrackExceptionState exceptionState; | 76 TrackExceptionState exceptionState; |
87 EXPECT_STREQ(webResponse->getHeader(key).utf8().c_str(), responseHeaders
->get(key, exceptionState).utf8().data()); | 77 EXPECT_STREQ(webResponse->getHeader(key).utf8().c_str(), responseHeaders
->get(key, exceptionState).utf8().data()); |
88 EXPECT_FALSE(exceptionState.hadException()); | 78 EXPECT_FALSE(exceptionState.hadException()); |
89 } | 79 } |
90 } | 80 } |
91 | 81 |
92 TEST_F(ServiceWorkerResponseTest, FromWebServiceWorkerResponseDefault) | 82 TEST(ServiceWorkerResponseTest, FromWebServiceWorkerResponseDefault) |
93 { | 83 { |
| 84 V8TestingScope scope; |
94 std::unique_ptr<WebServiceWorkerResponse> webResponse = createTestWebService
WorkerResponse(); | 85 std::unique_ptr<WebServiceWorkerResponse> webResponse = createTestWebService
WorkerResponse(); |
95 webResponse->setResponseType(WebServiceWorkerResponseTypeDefault); | 86 webResponse->setResponseType(WebServiceWorkerResponseTypeDefault); |
96 Response* response = Response::create(getScriptState(), *webResponse); | 87 Response* response = Response::create(scope.getScriptState(), *webResponse); |
97 | 88 |
98 Headers* responseHeaders = response->headers(); | 89 Headers* responseHeaders = response->headers(); |
99 TrackExceptionState exceptionState; | 90 TrackExceptionState exceptionState; |
100 EXPECT_STREQ("foop", responseHeaders->get("set-cookie", exceptionState).utf8
().data()); | 91 EXPECT_STREQ("foop", responseHeaders->get("set-cookie", exceptionState).utf8
().data()); |
101 EXPECT_STREQ("bar", responseHeaders->get("foo", exceptionState).utf8().data(
)); | 92 EXPECT_STREQ("bar", responseHeaders->get("foo", exceptionState).utf8().data(
)); |
102 EXPECT_STREQ("no-cache", responseHeaders->get("cache-control", exceptionStat
e).utf8().data()); | 93 EXPECT_STREQ("no-cache", responseHeaders->get("cache-control", exceptionStat
e).utf8().data()); |
103 EXPECT_FALSE(exceptionState.hadException()); | 94 EXPECT_FALSE(exceptionState.hadException()); |
104 } | 95 } |
105 | 96 |
106 TEST_F(ServiceWorkerResponseTest, FromWebServiceWorkerResponseBasic) | 97 TEST(ServiceWorkerResponseTest, FromWebServiceWorkerResponseBasic) |
107 { | 98 { |
| 99 V8TestingScope scope; |
108 std::unique_ptr<WebServiceWorkerResponse> webResponse = createTestWebService
WorkerResponse(); | 100 std::unique_ptr<WebServiceWorkerResponse> webResponse = createTestWebService
WorkerResponse(); |
109 webResponse->setResponseType(WebServiceWorkerResponseTypeBasic); | 101 webResponse->setResponseType(WebServiceWorkerResponseTypeBasic); |
110 Response* response = Response::create(getScriptState(), *webResponse); | 102 Response* response = Response::create(scope.getScriptState(), *webResponse); |
111 | 103 |
112 Headers* responseHeaders = response->headers(); | 104 Headers* responseHeaders = response->headers(); |
113 TrackExceptionState exceptionState; | 105 TrackExceptionState exceptionState; |
114 EXPECT_STREQ("", responseHeaders->get("set-cookie", exceptionState).utf8().d
ata()); | 106 EXPECT_STREQ("", responseHeaders->get("set-cookie", exceptionState).utf8().d
ata()); |
115 EXPECT_STREQ("bar", responseHeaders->get("foo", exceptionState).utf8().data(
)); | 107 EXPECT_STREQ("bar", responseHeaders->get("foo", exceptionState).utf8().data(
)); |
116 EXPECT_STREQ("no-cache", responseHeaders->get("cache-control", exceptionStat
e).utf8().data()); | 108 EXPECT_STREQ("no-cache", responseHeaders->get("cache-control", exceptionStat
e).utf8().data()); |
117 EXPECT_FALSE(exceptionState.hadException()); | 109 EXPECT_FALSE(exceptionState.hadException()); |
118 } | 110 } |
119 | 111 |
120 TEST_F(ServiceWorkerResponseTest, FromWebServiceWorkerResponseCORS) | 112 TEST(ServiceWorkerResponseTest, FromWebServiceWorkerResponseCORS) |
121 { | 113 { |
| 114 V8TestingScope scope; |
122 std::unique_ptr<WebServiceWorkerResponse> webResponse = createTestWebService
WorkerResponse(); | 115 std::unique_ptr<WebServiceWorkerResponse> webResponse = createTestWebService
WorkerResponse(); |
123 webResponse->setResponseType(WebServiceWorkerResponseTypeCORS); | 116 webResponse->setResponseType(WebServiceWorkerResponseTypeCORS); |
124 Response* response = Response::create(getScriptState(), *webResponse); | 117 Response* response = Response::create(scope.getScriptState(), *webResponse); |
125 | 118 |
126 Headers* responseHeaders = response->headers(); | 119 Headers* responseHeaders = response->headers(); |
127 TrackExceptionState exceptionState; | 120 TrackExceptionState exceptionState; |
128 EXPECT_STREQ("", responseHeaders->get("set-cookie", exceptionState).utf8().d
ata()); | 121 EXPECT_STREQ("", responseHeaders->get("set-cookie", exceptionState).utf8().d
ata()); |
129 EXPECT_STREQ("", responseHeaders->get("foo", exceptionState).utf8().data()); | 122 EXPECT_STREQ("", responseHeaders->get("foo", exceptionState).utf8().data()); |
130 EXPECT_STREQ("no-cache", responseHeaders->get("cache-control", exceptionStat
e).utf8().data()); | 123 EXPECT_STREQ("no-cache", responseHeaders->get("cache-control", exceptionStat
e).utf8().data()); |
131 EXPECT_FALSE(exceptionState.hadException()); | 124 EXPECT_FALSE(exceptionState.hadException()); |
132 } | 125 } |
133 | 126 |
134 TEST_F(ServiceWorkerResponseTest, FromWebServiceWorkerResponseOpaque) | 127 TEST(ServiceWorkerResponseTest, FromWebServiceWorkerResponseOpaque) |
135 { | 128 { |
| 129 V8TestingScope scope; |
136 std::unique_ptr<WebServiceWorkerResponse> webResponse = createTestWebService
WorkerResponse(); | 130 std::unique_ptr<WebServiceWorkerResponse> webResponse = createTestWebService
WorkerResponse(); |
137 webResponse->setResponseType(WebServiceWorkerResponseTypeOpaque); | 131 webResponse->setResponseType(WebServiceWorkerResponseTypeOpaque); |
138 Response* response = Response::create(getScriptState(), *webResponse); | 132 Response* response = Response::create(scope.getScriptState(), *webResponse); |
139 | 133 |
140 Headers* responseHeaders = response->headers(); | 134 Headers* responseHeaders = response->headers(); |
141 TrackExceptionState exceptionState; | 135 TrackExceptionState exceptionState; |
142 EXPECT_STREQ("", responseHeaders->get("set-cookie", exceptionState).utf8().d
ata()); | 136 EXPECT_STREQ("", responseHeaders->get("set-cookie", exceptionState).utf8().d
ata()); |
143 EXPECT_STREQ("", responseHeaders->get("foo", exceptionState).utf8().data()); | 137 EXPECT_STREQ("", responseHeaders->get("foo", exceptionState).utf8().data()); |
144 EXPECT_STREQ("", responseHeaders->get("cache-control", exceptionState).utf8(
).data()); | 138 EXPECT_STREQ("", responseHeaders->get("cache-control", exceptionState).utf8(
).data()); |
145 EXPECT_FALSE(exceptionState.hadException()); | 139 EXPECT_FALSE(exceptionState.hadException()); |
146 } | 140 } |
147 | 141 |
148 void checkResponseStream(ScriptState* scriptState, Response* response, bool chec
kResponseBodyStreamBuffer) | 142 void checkResponseStream(ScriptState* scriptState, Response* response, bool chec
kResponseBodyStreamBuffer) |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
189 BodyStreamBuffer* createHelloWorldBuffer(ScriptState* scriptState) | 183 BodyStreamBuffer* createHelloWorldBuffer(ScriptState* scriptState) |
190 { | 184 { |
191 using Command = DataConsumerHandleTestUtil::Command; | 185 using Command = DataConsumerHandleTestUtil::Command; |
192 std::unique_ptr<DataConsumerHandleTestUtil::ReplayingHandle> src(DataConsume
rHandleTestUtil::ReplayingHandle::create()); | 186 std::unique_ptr<DataConsumerHandleTestUtil::ReplayingHandle> src(DataConsume
rHandleTestUtil::ReplayingHandle::create()); |
193 src->add(Command(Command::Data, "Hello, ")); | 187 src->add(Command(Command::Data, "Hello, ")); |
194 src->add(Command(Command::Data, "world")); | 188 src->add(Command(Command::Data, "world")); |
195 src->add(Command(Command::Done)); | 189 src->add(Command(Command::Done)); |
196 return new BodyStreamBuffer(scriptState, createFetchDataConsumerHandleFromWe
bHandle(std::move(src))); | 190 return new BodyStreamBuffer(scriptState, createFetchDataConsumerHandleFromWe
bHandle(std::move(src))); |
197 } | 191 } |
198 | 192 |
199 TEST_F(ServiceWorkerResponseTest, BodyStreamBufferCloneDefault) | 193 TEST(ServiceWorkerResponseTest, BodyStreamBufferCloneDefault) |
200 { | 194 { |
201 BodyStreamBuffer* buffer = createHelloWorldBuffer(getScriptState()); | 195 V8TestingScope scope; |
| 196 BodyStreamBuffer* buffer = createHelloWorldBuffer(scope.getScriptState()); |
202 FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(b
uffer); | 197 FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(b
uffer); |
203 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com")); | 198 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com")); |
204 Response* response = Response::create(getExecutionContext(), fetchResponseDa
ta); | 199 Response* response = Response::create(scope.getExecutionContext(), fetchResp
onseData); |
205 EXPECT_EQ(response->internalBodyBuffer(), buffer); | 200 EXPECT_EQ(response->internalBodyBuffer(), buffer); |
206 checkResponseStream(getScriptState(), response, true); | 201 checkResponseStream(scope.getScriptState(), response, true); |
207 } | 202 } |
208 | 203 |
209 TEST_F(ServiceWorkerResponseTest, BodyStreamBufferCloneBasic) | 204 TEST(ServiceWorkerResponseTest, BodyStreamBufferCloneBasic) |
210 { | 205 { |
211 BodyStreamBuffer* buffer = createHelloWorldBuffer(getScriptState()); | 206 V8TestingScope scope; |
| 207 BodyStreamBuffer* buffer = createHelloWorldBuffer(scope.getScriptState()); |
212 FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(b
uffer); | 208 FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(b
uffer); |
213 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com")); | 209 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com")); |
214 fetchResponseData = fetchResponseData->createBasicFilteredResponse(); | 210 fetchResponseData = fetchResponseData->createBasicFilteredResponse(); |
215 Response* response = Response::create(getExecutionContext(), fetchResponseDa
ta); | 211 Response* response = Response::create(scope.getExecutionContext(), fetchResp
onseData); |
216 EXPECT_EQ(response->internalBodyBuffer(), buffer); | 212 EXPECT_EQ(response->internalBodyBuffer(), buffer); |
217 checkResponseStream(getScriptState(), response, true); | 213 checkResponseStream(scope.getScriptState(), response, true); |
218 } | 214 } |
219 | 215 |
220 TEST_F(ServiceWorkerResponseTest, BodyStreamBufferCloneCORS) | 216 TEST(ServiceWorkerResponseTest, BodyStreamBufferCloneCORS) |
221 { | 217 { |
222 BodyStreamBuffer* buffer = createHelloWorldBuffer(getScriptState()); | 218 V8TestingScope scope; |
| 219 BodyStreamBuffer* buffer = createHelloWorldBuffer(scope.getScriptState()); |
223 FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(b
uffer); | 220 FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(b
uffer); |
224 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com")); | 221 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com")); |
225 fetchResponseData = fetchResponseData->createCORSFilteredResponse(); | 222 fetchResponseData = fetchResponseData->createCORSFilteredResponse(); |
226 Response* response = Response::create(getExecutionContext(), fetchResponseDa
ta); | 223 Response* response = Response::create(scope.getExecutionContext(), fetchResp
onseData); |
227 EXPECT_EQ(response->internalBodyBuffer(), buffer); | 224 EXPECT_EQ(response->internalBodyBuffer(), buffer); |
228 checkResponseStream(getScriptState(), response, true); | 225 checkResponseStream(scope.getScriptState(), response, true); |
229 } | 226 } |
230 | 227 |
231 TEST_F(ServiceWorkerResponseTest, BodyStreamBufferCloneOpaque) | 228 TEST(ServiceWorkerResponseTest, BodyStreamBufferCloneOpaque) |
232 { | 229 { |
233 BodyStreamBuffer* buffer = createHelloWorldBuffer(getScriptState()); | 230 V8TestingScope scope; |
| 231 BodyStreamBuffer* buffer = createHelloWorldBuffer(scope.getScriptState()); |
234 FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(b
uffer); | 232 FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(b
uffer); |
235 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com")); | 233 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com")); |
236 fetchResponseData = fetchResponseData->createOpaqueFilteredResponse(); | 234 fetchResponseData = fetchResponseData->createOpaqueFilteredResponse(); |
237 Response* response = Response::create(getExecutionContext(), fetchResponseDa
ta); | 235 Response* response = Response::create(scope.getExecutionContext(), fetchResp
onseData); |
238 EXPECT_EQ(response->internalBodyBuffer(), buffer); | 236 EXPECT_EQ(response->internalBodyBuffer(), buffer); |
239 checkResponseStream(getScriptState(), response, false); | 237 checkResponseStream(scope.getScriptState(), response, false); |
240 } | 238 } |
241 | 239 |
242 TEST_F(ServiceWorkerResponseTest, BodyStreamBufferCloneError) | 240 TEST(ServiceWorkerResponseTest, BodyStreamBufferCloneError) |
243 { | 241 { |
244 BodyStreamBuffer* buffer = new BodyStreamBuffer(getScriptState(), createFetc
hDataConsumerHandleFromWebHandle(createUnexpectedErrorDataConsumerHandle())); | 242 V8TestingScope scope; |
| 243 BodyStreamBuffer* buffer = new BodyStreamBuffer(scope.getScriptState(), crea
teFetchDataConsumerHandleFromWebHandle(createUnexpectedErrorDataConsumerHandle()
)); |
245 FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(b
uffer); | 244 FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(b
uffer); |
246 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com")); | 245 fetchResponseData->setURL(KURL(ParsedURLString, "http://www.response.com")); |
247 Response* response = Response::create(getExecutionContext(), fetchResponseDa
ta); | 246 Response* response = Response::create(scope.getExecutionContext(), fetchResp
onseData); |
248 TrackExceptionState exceptionState; | 247 TrackExceptionState exceptionState; |
249 Response* clonedResponse = response->clone(getScriptState(), exceptionState)
; | 248 Response* clonedResponse = response->clone(scope.getScriptState(), exception
State); |
250 EXPECT_FALSE(exceptionState.hadException()); | 249 EXPECT_FALSE(exceptionState.hadException()); |
251 | 250 |
252 DataConsumerHandleTestUtil::MockFetchDataLoaderClient* client1 = new DataCon
sumerHandleTestUtil::MockFetchDataLoaderClient(); | 251 DataConsumerHandleTestUtil::MockFetchDataLoaderClient* client1 = new DataCon
sumerHandleTestUtil::MockFetchDataLoaderClient(); |
253 DataConsumerHandleTestUtil::MockFetchDataLoaderClient* client2 = new DataCon
sumerHandleTestUtil::MockFetchDataLoaderClient(); | 252 DataConsumerHandleTestUtil::MockFetchDataLoaderClient* client2 = new DataCon
sumerHandleTestUtil::MockFetchDataLoaderClient(); |
254 EXPECT_CALL(*client1, didFetchDataLoadFailed()); | 253 EXPECT_CALL(*client1, didFetchDataLoadFailed()); |
255 EXPECT_CALL(*client2, didFetchDataLoadFailed()); | 254 EXPECT_CALL(*client2, didFetchDataLoadFailed()); |
256 | 255 |
257 response->internalBodyBuffer()->startLoading(FetchDataLoader::createLoaderAs
String(), client1); | 256 response->internalBodyBuffer()->startLoading(FetchDataLoader::createLoaderAs
String(), client1); |
258 clonedResponse->internalBodyBuffer()->startLoading(FetchDataLoader::createLo
aderAsString(), client2); | 257 clonedResponse->internalBodyBuffer()->startLoading(FetchDataLoader::createLo
aderAsString(), client2); |
259 blink::testing::runPendingTasks(); | 258 blink::testing::runPendingTasks(); |
260 } | 259 } |
261 | 260 |
262 } // namespace | 261 } // namespace |
263 } // namespace blink | 262 } // namespace blink |
OLD | NEW |