Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(92)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: third_party/WebKit/Source/modules/fetch/FetchDataLoaderTest.cpp

Issue 2177243002: Use per-frame TaskRunner instead of thread's default in DataConsumerHandle (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@data_consumer_handle_unique_ptr
Patch Set: update Created 4 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « third_party/WebKit/Source/modules/fetch/FetchDataLoader.cpp ('k') | third_party/WebKit/Source/modules/fetch/FetchFormDataConsumerHandle.h » ('j') | third_party/WebKit/Source/modules/fetch/ReadableStreamDataConsumerHandle.cpp » ('J')
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright 2015 The Chromium Authors. All rights reserved. 1 // Copyright 2015 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/FetchDataLoader.h" 5 #include "modules/fetch/FetchDataLoader.h"
6 6
7 #include "modules/fetch/DataConsumerHandleTestUtil.h" 7 #include "modules/fetch/DataConsumerHandleTestUtil.h"
8 #include "testing/gmock/include/gmock/gmock.h" 8 #include "testing/gmock/include/gmock/gmock.h"
9 #include "testing/gtest/include/gtest/gtest.h" 9 #include "testing/gtest/include/gtest/gtest.h"
10 #include <memory> 10 #include <memory>
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after
45 45
46 // |reader| will be adopted by |obtainFetchDataReader|. 46 // |reader| will be adopted by |obtainFetchDataReader|.
47 MockReader* reader = MockReader::create().release(); 47 MockReader* reader = MockReader::create().release();
48 48
49 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsBlobHandle ("text/test"); 49 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsBlobHandle ("text/test");
50 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create(); 50 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create();
51 RefPtr<BlobDataHandle> blobDataHandle; 51 RefPtr<BlobDataHandle> blobDataHandle;
52 52
53 InSequence s; 53 InSequence s;
54 EXPECT_CALL(checkpoint, Call(1)); 54 EXPECT_CALL(checkpoint, Call(1));
55 EXPECT_CALL(*handle, obtainFetchDataReader(_)).WillOnce(DoAll(SaveArg<0>(&cl ient), Return(ByMove(WTF::wrapUnique(reader))))); 55 EXPECT_CALL(*handle, obtainFetchDataReaderMock(_)).WillOnce(DoAll(SaveArg<0> (&client), Return(ByMove(WTF::wrapUnique(reader)))));
56 EXPECT_CALL(*reader, drainAsBlobDataHandle(kDisallowBlobWithInvalidSize)).Wi llOnce(Return(nullptr)); 56 EXPECT_CALL(*reader, drainAsBlobDataHandle(kDisallowBlobWithInvalidSize)).Wi llOnce(Return(nullptr));
57 EXPECT_CALL(checkpoint, Call(2)); 57 EXPECT_CALL(checkpoint, Call(2));
58 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengt hWithTerminatingNull), Return(kOk))); 58 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengt hWithTerminatingNull), Return(kOk)));
59 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillO nce(Return(kOk)); 59 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillO nce(Return(kOk));
60 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kDone)); 60 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kDone));
61 EXPECT_CALL(*reader, destruct()); 61 EXPECT_CALL(*reader, destruct());
62 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedBlobHandleMock(_)).Wil lOnce(SaveArg<0>(&blobDataHandle)); 62 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedBlobHandleMock(_)).Wil lOnce(SaveArg<0>(&blobDataHandle));
63 EXPECT_CALL(checkpoint, Call(3)); 63 EXPECT_CALL(checkpoint, Call(3));
64 EXPECT_CALL(checkpoint, Call(4)); 64 EXPECT_CALL(checkpoint, Call(4));
65 65
66 checkpoint.Call(1); 66 checkpoint.Call(1);
67 fetchDataLoader->start(handle.get(), fetchDataLoaderClient); 67 fetchDataLoader->start(handle.get(), fetchDataLoaderClient, getCurrentTaskRu nner());
68 checkpoint.Call(2); 68 checkpoint.Call(2);
69 ASSERT_TRUE(client); 69 ASSERT_TRUE(client);
70 client->didGetReadable(); 70 client->didGetReadable();
71 checkpoint.Call(3); 71 checkpoint.Call(3);
72 fetchDataLoader->cancel(); 72 fetchDataLoader->cancel();
73 checkpoint.Call(4); 73 checkpoint.Call(4);
74 74
75 ASSERT_TRUE(blobDataHandle); 75 ASSERT_TRUE(blobDataHandle);
76 EXPECT_EQ(kQuickBrownFoxLengthWithTerminatingNull, blobDataHandle->size()); 76 EXPECT_EQ(kQuickBrownFoxLengthWithTerminatingNull, blobDataHandle->size());
77 EXPECT_EQ(String("text/test"), blobDataHandle->type()); 77 EXPECT_EQ(String("text/test"), blobDataHandle->type());
78 } 78 }
79 79
80 TEST(FetchDataLoaderTest, LoadAsBlobFailed) 80 TEST(FetchDataLoaderTest, LoadAsBlobFailed)
81 { 81 {
82 WebDataConsumerHandle::Client *client = nullptr; 82 WebDataConsumerHandle::Client *client = nullptr;
83 Checkpoint checkpoint; 83 Checkpoint checkpoint;
84 84
85 std::unique_ptr<MockHandle> handle = MockHandle::create(); 85 std::unique_ptr<MockHandle> handle = MockHandle::create();
86 86
87 // |reader| is adopted by |obtainFetchDataReader|. 87 // |reader| is adopted by |obtainFetchDataReader|.
88 MockReader* reader = MockReader::create().release(); 88 MockReader* reader = MockReader::create().release();
89 89
90 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsBlobHandle ("text/test"); 90 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsBlobHandle ("text/test");
91 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create(); 91 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create();
92 92
93 InSequence s; 93 InSequence s;
94 EXPECT_CALL(checkpoint, Call(1)); 94 EXPECT_CALL(checkpoint, Call(1));
95 EXPECT_CALL(*handle, obtainFetchDataReader(_)).WillOnce(DoAll(SaveArg<0>(&cl ient), Return(ByMove(WTF::wrapUnique(reader))))); 95 EXPECT_CALL(*handle, obtainFetchDataReaderMock(_)).WillOnce(DoAll(SaveArg<0> (&client), Return(ByMove(WTF::wrapUnique(reader)))));
96 EXPECT_CALL(*reader, drainAsBlobDataHandle(kDisallowBlobWithInvalidSize)).Wi llOnce(Return(nullptr)); 96 EXPECT_CALL(*reader, drainAsBlobDataHandle(kDisallowBlobWithInvalidSize)).Wi llOnce(Return(nullptr));
97 EXPECT_CALL(checkpoint, Call(2)); 97 EXPECT_CALL(checkpoint, Call(2));
98 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengt hWithTerminatingNull), Return(kOk))); 98 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengt hWithTerminatingNull), Return(kOk)));
99 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillO nce(Return(kOk)); 99 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillO nce(Return(kOk));
100 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kUnexpectedErro r)); 100 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kUnexpectedErro r));
101 EXPECT_CALL(*reader, destruct()); 101 EXPECT_CALL(*reader, destruct());
102 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadFailed()); 102 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadFailed());
103 EXPECT_CALL(checkpoint, Call(3)); 103 EXPECT_CALL(checkpoint, Call(3));
104 EXPECT_CALL(checkpoint, Call(4)); 104 EXPECT_CALL(checkpoint, Call(4));
105 105
106 checkpoint.Call(1); 106 checkpoint.Call(1);
107 fetchDataLoader->start(handle.get(), fetchDataLoaderClient); 107 fetchDataLoader->start(handle.get(), fetchDataLoaderClient, getCurrentTaskRu nner());
108 checkpoint.Call(2); 108 checkpoint.Call(2);
109 ASSERT_TRUE(client); 109 ASSERT_TRUE(client);
110 client->didGetReadable(); 110 client->didGetReadable();
111 checkpoint.Call(3); 111 checkpoint.Call(3);
112 fetchDataLoader->cancel(); 112 fetchDataLoader->cancel();
113 checkpoint.Call(4); 113 checkpoint.Call(4);
114 } 114 }
115 115
116 TEST(FetchDataLoaderTest, LoadAsBlobCancel) 116 TEST(FetchDataLoaderTest, LoadAsBlobCancel)
117 { 117 {
118 Checkpoint checkpoint; 118 Checkpoint checkpoint;
119 119
120 std::unique_ptr<MockHandle> handle = MockHandle::create(); 120 std::unique_ptr<MockHandle> handle = MockHandle::create();
121 121
122 // |reader| will be adopted by |obtainFetchDataReader|. 122 // |reader| will be adopted by |obtainFetchDataReader|.
123 MockReader* reader = MockReader::create().release(); 123 MockReader* reader = MockReader::create().release();
124 124
125 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsBlobHandle ("text/test"); 125 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsBlobHandle ("text/test");
126 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create(); 126 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create();
127 127
128 InSequence s; 128 InSequence s;
129 EXPECT_CALL(checkpoint, Call(1)); 129 EXPECT_CALL(checkpoint, Call(1));
130 EXPECT_CALL(*handle, obtainFetchDataReader(_)).WillOnce(Return(ByMove(WTF::w rapUnique(reader)))); 130 EXPECT_CALL(*handle, obtainFetchDataReaderMock(_)).WillOnce(Return(ByMove(WT F::wrapUnique(reader))));
131 EXPECT_CALL(*reader, drainAsBlobDataHandle(kDisallowBlobWithInvalidSize)).Wi llOnce(Return(nullptr)); 131 EXPECT_CALL(*reader, drainAsBlobDataHandle(kDisallowBlobWithInvalidSize)).Wi llOnce(Return(nullptr));
132 EXPECT_CALL(checkpoint, Call(2)); 132 EXPECT_CALL(checkpoint, Call(2));
133 EXPECT_CALL(*reader, destruct()); 133 EXPECT_CALL(*reader, destruct());
134 EXPECT_CALL(checkpoint, Call(3)); 134 EXPECT_CALL(checkpoint, Call(3));
135 135
136 checkpoint.Call(1); 136 checkpoint.Call(1);
137 fetchDataLoader->start(handle.get(), fetchDataLoaderClient); 137 fetchDataLoader->start(handle.get(), fetchDataLoaderClient, getCurrentTaskRu nner());
138 checkpoint.Call(2); 138 checkpoint.Call(2);
139 fetchDataLoader->cancel(); 139 fetchDataLoader->cancel();
140 checkpoint.Call(3); 140 checkpoint.Call(3);
141 } 141 }
142 142
143 TEST(FetchDataLoaderTest, LoadAsBlobViaDrainAsBlobDataHandleWithSameContentType) 143 TEST(FetchDataLoaderTest, LoadAsBlobViaDrainAsBlobDataHandleWithSameContentType)
144 { 144 {
145 std::unique_ptr<BlobData> blobData = BlobData::create(); 145 std::unique_ptr<BlobData> blobData = BlobData::create();
146 blobData->appendBytes(kQuickBrownFox, kQuickBrownFoxLengthWithTerminatingNul l); 146 blobData->appendBytes(kQuickBrownFox, kQuickBrownFoxLengthWithTerminatingNul l);
147 blobData->setContentType("text/test"); 147 blobData->setContentType("text/test");
148 RefPtr<BlobDataHandle> inputBlobDataHandle = BlobDataHandle::create(std::mov e(blobData), kQuickBrownFoxLengthWithTerminatingNull); 148 RefPtr<BlobDataHandle> inputBlobDataHandle = BlobDataHandle::create(std::mov e(blobData), kQuickBrownFoxLengthWithTerminatingNull);
149 149
150 Checkpoint checkpoint; 150 Checkpoint checkpoint;
151 151
152 std::unique_ptr<MockHandle> handle = MockHandle::create(); 152 std::unique_ptr<MockHandle> handle = MockHandle::create();
153 153
154 // |reader| will be adopted by |obtainFetchDataReader|. 154 // |reader| will be adopted by |obtainFetchDataReader|.
155 MockReader* reader = MockReader::create().release(); 155 MockReader* reader = MockReader::create().release();
156 156
157 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsBlobHandle ("text/test"); 157 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsBlobHandle ("text/test");
158 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create(); 158 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create();
159 RefPtr<BlobDataHandle> blobDataHandle; 159 RefPtr<BlobDataHandle> blobDataHandle;
160 160
161 InSequence s; 161 InSequence s;
162 EXPECT_CALL(checkpoint, Call(1)); 162 EXPECT_CALL(checkpoint, Call(1));
163 EXPECT_CALL(*handle, obtainFetchDataReader(_)).WillOnce(Return(ByMove(WTF::w rapUnique(reader)))); 163 EXPECT_CALL(*handle, obtainFetchDataReaderMock(_)).WillOnce(Return(ByMove(WT F::wrapUnique(reader))));
164 EXPECT_CALL(*reader, drainAsBlobDataHandle(kDisallowBlobWithInvalidSize)).Wi llOnce(Return(inputBlobDataHandle)); 164 EXPECT_CALL(*reader, drainAsBlobDataHandle(kDisallowBlobWithInvalidSize)).Wi llOnce(Return(inputBlobDataHandle));
165 EXPECT_CALL(*reader, destruct()); 165 EXPECT_CALL(*reader, destruct());
166 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedBlobHandleMock(_)).Wil lOnce(SaveArg<0>(&blobDataHandle)); 166 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedBlobHandleMock(_)).Wil lOnce(SaveArg<0>(&blobDataHandle));
167 EXPECT_CALL(checkpoint, Call(2)); 167 EXPECT_CALL(checkpoint, Call(2));
168 EXPECT_CALL(checkpoint, Call(3)); 168 EXPECT_CALL(checkpoint, Call(3));
169 169
170 checkpoint.Call(1); 170 checkpoint.Call(1);
171 fetchDataLoader->start(handle.get(), fetchDataLoaderClient); 171 fetchDataLoader->start(handle.get(), fetchDataLoaderClient, getCurrentTaskRu nner());
172 checkpoint.Call(2); 172 checkpoint.Call(2);
173 fetchDataLoader->cancel(); 173 fetchDataLoader->cancel();
174 checkpoint.Call(3); 174 checkpoint.Call(3);
175 175
176 ASSERT_TRUE(blobDataHandle); 176 ASSERT_TRUE(blobDataHandle);
177 EXPECT_EQ(inputBlobDataHandle, blobDataHandle); 177 EXPECT_EQ(inputBlobDataHandle, blobDataHandle);
178 EXPECT_EQ(kQuickBrownFoxLengthWithTerminatingNull, blobDataHandle->size()); 178 EXPECT_EQ(kQuickBrownFoxLengthWithTerminatingNull, blobDataHandle->size());
179 EXPECT_EQ(String("text/test"), blobDataHandle->type()); 179 EXPECT_EQ(String("text/test"), blobDataHandle->type());
180 } 180 }
181 181
(...skipping 10 matching lines...) Expand all
192 192
193 // |reader| will be adopted by |obtainFetchDataReader|. 193 // |reader| will be adopted by |obtainFetchDataReader|.
194 MockReader* reader = MockReader::create().release(); 194 MockReader* reader = MockReader::create().release();
195 195
196 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsBlobHandle ("text/test"); 196 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsBlobHandle ("text/test");
197 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create(); 197 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create();
198 RefPtr<BlobDataHandle> blobDataHandle; 198 RefPtr<BlobDataHandle> blobDataHandle;
199 199
200 InSequence s; 200 InSequence s;
201 EXPECT_CALL(checkpoint, Call(1)); 201 EXPECT_CALL(checkpoint, Call(1));
202 EXPECT_CALL(*handle, obtainFetchDataReader(_)).WillOnce(Return(ByMove(WTF::w rapUnique(reader)))); 202 EXPECT_CALL(*handle, obtainFetchDataReaderMock(_)).WillOnce(Return(ByMove(WT F::wrapUnique(reader))));
203 EXPECT_CALL(*reader, drainAsBlobDataHandle(kDisallowBlobWithInvalidSize)).Wi llOnce(Return(inputBlobDataHandle)); 203 EXPECT_CALL(*reader, drainAsBlobDataHandle(kDisallowBlobWithInvalidSize)).Wi llOnce(Return(inputBlobDataHandle));
204 EXPECT_CALL(*reader, destruct()); 204 EXPECT_CALL(*reader, destruct());
205 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedBlobHandleMock(_)).Wil lOnce(SaveArg<0>(&blobDataHandle)); 205 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedBlobHandleMock(_)).Wil lOnce(SaveArg<0>(&blobDataHandle));
206 EXPECT_CALL(checkpoint, Call(2)); 206 EXPECT_CALL(checkpoint, Call(2));
207 EXPECT_CALL(checkpoint, Call(3)); 207 EXPECT_CALL(checkpoint, Call(3));
208 208
209 checkpoint.Call(1); 209 checkpoint.Call(1);
210 fetchDataLoader->start(handle.get(), fetchDataLoaderClient); 210 fetchDataLoader->start(handle.get(), fetchDataLoaderClient, getCurrentTaskRu nner());
211 checkpoint.Call(2); 211 checkpoint.Call(2);
212 fetchDataLoader->cancel(); 212 fetchDataLoader->cancel();
213 checkpoint.Call(3); 213 checkpoint.Call(3);
214 214
215 ASSERT_TRUE(blobDataHandle); 215 ASSERT_TRUE(blobDataHandle);
216 EXPECT_NE(inputBlobDataHandle, blobDataHandle); 216 EXPECT_NE(inputBlobDataHandle, blobDataHandle);
217 EXPECT_EQ(kQuickBrownFoxLengthWithTerminatingNull, blobDataHandle->size()); 217 EXPECT_EQ(kQuickBrownFoxLengthWithTerminatingNull, blobDataHandle->size());
218 EXPECT_EQ(String("text/test"), blobDataHandle->type()); 218 EXPECT_EQ(String("text/test"), blobDataHandle->type());
219 } 219 }
220 220
221 TEST(FetchDataLoaderTest, LoadAsArrayBuffer) 221 TEST(FetchDataLoaderTest, LoadAsArrayBuffer)
222 { 222 {
223 WebDataConsumerHandle::Client *client = nullptr; 223 WebDataConsumerHandle::Client *client = nullptr;
224 Checkpoint checkpoint; 224 Checkpoint checkpoint;
225 225
226 std::unique_ptr<MockHandle> handle = MockHandle::create(); 226 std::unique_ptr<MockHandle> handle = MockHandle::create();
227 227
228 // |reader| will be adopted by |obtainFetchDataReader|. 228 // |reader| will be adopted by |obtainFetchDataReader|.
229 MockReader* reader = MockReader::create().release(); 229 MockReader* reader = MockReader::create().release();
230 230
231 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsArrayBuffe r(); 231 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsArrayBuffe r();
232 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create(); 232 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create();
233 DOMArrayBuffer* arrayBuffer = nullptr; 233 DOMArrayBuffer* arrayBuffer = nullptr;
234 234
235 InSequence s; 235 InSequence s;
236 EXPECT_CALL(checkpoint, Call(1)); 236 EXPECT_CALL(checkpoint, Call(1));
237 EXPECT_CALL(*handle, obtainFetchDataReader(_)).WillOnce(DoAll(SaveArg<0>(&cl ient), Return(ByMove(WTF::wrapUnique(reader))))); 237 EXPECT_CALL(*handle, obtainFetchDataReaderMock(_)).WillOnce(DoAll(SaveArg<0> (&client), Return(ByMove(WTF::wrapUnique(reader)))));
238 EXPECT_CALL(checkpoint, Call(2)); 238 EXPECT_CALL(checkpoint, Call(2));
239 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengt hWithTerminatingNull), Return(kOk))); 239 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengt hWithTerminatingNull), Return(kOk)));
240 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillO nce(Return(kOk)); 240 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillO nce(Return(kOk));
241 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kDone)); 241 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kDone));
242 EXPECT_CALL(*reader, destruct()); 242 EXPECT_CALL(*reader, destruct());
243 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedArrayBufferMock(_)).Wi llOnce(SaveArg<0>(&arrayBuffer)); 243 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedArrayBufferMock(_)).Wi llOnce(SaveArg<0>(&arrayBuffer));
244 EXPECT_CALL(checkpoint, Call(3)); 244 EXPECT_CALL(checkpoint, Call(3));
245 EXPECT_CALL(checkpoint, Call(4)); 245 EXPECT_CALL(checkpoint, Call(4));
246 246
247 checkpoint.Call(1); 247 checkpoint.Call(1);
248 fetchDataLoader->start(handle.get(), fetchDataLoaderClient); 248 fetchDataLoader->start(handle.get(), fetchDataLoaderClient, getCurrentTaskRu nner());
249 checkpoint.Call(2); 249 checkpoint.Call(2);
250 ASSERT_TRUE(client); 250 ASSERT_TRUE(client);
251 client->didGetReadable(); 251 client->didGetReadable();
252 checkpoint.Call(3); 252 checkpoint.Call(3);
253 fetchDataLoader->cancel(); 253 fetchDataLoader->cancel();
254 checkpoint.Call(4); 254 checkpoint.Call(4);
255 255
256 ASSERT_TRUE(arrayBuffer); 256 ASSERT_TRUE(arrayBuffer);
257 ASSERT_EQ(kQuickBrownFoxLengthWithTerminatingNull, arrayBuffer->byteLength() ); 257 ASSERT_EQ(kQuickBrownFoxLengthWithTerminatingNull, arrayBuffer->byteLength() );
258 EXPECT_STREQ(kQuickBrownFox, static_cast<const char*>(arrayBuffer->data())); 258 EXPECT_STREQ(kQuickBrownFox, static_cast<const char*>(arrayBuffer->data()));
259 } 259 }
260 260
261 TEST(FetchDataLoaderTest, LoadAsArrayBufferFailed) 261 TEST(FetchDataLoaderTest, LoadAsArrayBufferFailed)
262 { 262 {
263 WebDataConsumerHandle::Client *client = nullptr; 263 WebDataConsumerHandle::Client *client = nullptr;
264 Checkpoint checkpoint; 264 Checkpoint checkpoint;
265 265
266 std::unique_ptr<MockHandle> handle = MockHandle::create(); 266 std::unique_ptr<MockHandle> handle = MockHandle::create();
267 267
268 // |reader| will be adopted by |obtainFetchDataReader|. 268 // |reader| will be adopted by |obtainFetchDataReader|.
269 MockReader* reader = MockReader::create().release(); 269 MockReader* reader = MockReader::create().release();
270 270
271 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsArrayBuffe r(); 271 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsArrayBuffe r();
272 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create(); 272 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create();
273 273
274 InSequence s; 274 InSequence s;
275 EXPECT_CALL(checkpoint, Call(1)); 275 EXPECT_CALL(checkpoint, Call(1));
276 EXPECT_CALL(*handle, obtainFetchDataReader(_)).WillOnce(DoAll(SaveArg<0>(&cl ient), Return(ByMove(WTF::wrapUnique(reader))))); 276 EXPECT_CALL(*handle, obtainFetchDataReaderMock(_)).WillOnce(DoAll(SaveArg<0> (&client), Return(ByMove(WTF::wrapUnique(reader)))));
277 EXPECT_CALL(checkpoint, Call(2)); 277 EXPECT_CALL(checkpoint, Call(2));
278 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengt hWithTerminatingNull), Return(kOk))); 278 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengt hWithTerminatingNull), Return(kOk)));
279 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillO nce(Return(kOk)); 279 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillO nce(Return(kOk));
280 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kUnexpectedErro r)); 280 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kUnexpectedErro r));
281 EXPECT_CALL(*reader, destruct()); 281 EXPECT_CALL(*reader, destruct());
282 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadFailed()); 282 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadFailed());
283 EXPECT_CALL(checkpoint, Call(3)); 283 EXPECT_CALL(checkpoint, Call(3));
284 EXPECT_CALL(checkpoint, Call(4)); 284 EXPECT_CALL(checkpoint, Call(4));
285 285
286 checkpoint.Call(1); 286 checkpoint.Call(1);
287 fetchDataLoader->start(handle.get(), fetchDataLoaderClient); 287 fetchDataLoader->start(handle.get(), fetchDataLoaderClient, getCurrentTaskRu nner());
288 checkpoint.Call(2); 288 checkpoint.Call(2);
289 ASSERT_TRUE(client); 289 ASSERT_TRUE(client);
290 client->didGetReadable(); 290 client->didGetReadable();
291 checkpoint.Call(3); 291 checkpoint.Call(3);
292 fetchDataLoader->cancel(); 292 fetchDataLoader->cancel();
293 checkpoint.Call(4); 293 checkpoint.Call(4);
294 } 294 }
295 295
296 TEST(FetchDataLoaderTest, LoadAsArrayBufferCancel) 296 TEST(FetchDataLoaderTest, LoadAsArrayBufferCancel)
297 { 297 {
298 Checkpoint checkpoint; 298 Checkpoint checkpoint;
299 299
300 std::unique_ptr<MockHandle> handle = MockHandle::create(); 300 std::unique_ptr<MockHandle> handle = MockHandle::create();
301 301
302 // |reader| will be adopted by |obtainFetchDataReader|. 302 // |reader| will be adopted by |obtainFetchDataReader|.
303 MockReader* reader = MockReader::create().release(); 303 MockReader* reader = MockReader::create().release();
304 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsArrayBuffe r(); 304 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsArrayBuffe r();
305 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create(); 305 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create();
306 306
307 InSequence s; 307 InSequence s;
308 EXPECT_CALL(checkpoint, Call(1)); 308 EXPECT_CALL(checkpoint, Call(1));
309 EXPECT_CALL(*handle, obtainFetchDataReader(_)).WillOnce(Return(ByMove(WTF::w rapUnique(reader)))); 309 EXPECT_CALL(*handle, obtainFetchDataReaderMock(_)).WillOnce(Return(ByMove(WT F::wrapUnique(reader))));
310 EXPECT_CALL(checkpoint, Call(2)); 310 EXPECT_CALL(checkpoint, Call(2));
311 EXPECT_CALL(*reader, destruct()); 311 EXPECT_CALL(*reader, destruct());
312 EXPECT_CALL(checkpoint, Call(3)); 312 EXPECT_CALL(checkpoint, Call(3));
313 313
314 checkpoint.Call(1); 314 checkpoint.Call(1);
315 fetchDataLoader->start(handle.get(), fetchDataLoaderClient); 315 fetchDataLoader->start(handle.get(), fetchDataLoaderClient, getCurrentTaskRu nner());
316 checkpoint.Call(2); 316 checkpoint.Call(2);
317 fetchDataLoader->cancel(); 317 fetchDataLoader->cancel();
318 checkpoint.Call(3); 318 checkpoint.Call(3);
319 } 319 }
320 320
321 TEST(FetchDataLoaderTest, LoadAsString) 321 TEST(FetchDataLoaderTest, LoadAsString)
322 { 322 {
323 WebDataConsumerHandle::Client *client = nullptr; 323 WebDataConsumerHandle::Client *client = nullptr;
324 Checkpoint checkpoint; 324 Checkpoint checkpoint;
325 325
326 std::unique_ptr<MockHandle> handle = MockHandle::create(); 326 std::unique_ptr<MockHandle> handle = MockHandle::create();
327 327
328 // |reader| will be adopted by |obtainFetchDataReader|. 328 // |reader| will be adopted by |obtainFetchDataReader|.
329 MockReader* reader = MockReader::create().release(); 329 MockReader* reader = MockReader::create().release();
330 330
331 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsString(); 331 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsString();
332 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create(); 332 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create();
333 333
334 InSequence s; 334 InSequence s;
335 EXPECT_CALL(checkpoint, Call(1)); 335 EXPECT_CALL(checkpoint, Call(1));
336 EXPECT_CALL(*handle, obtainFetchDataReader(_)).WillOnce(DoAll(SaveArg<0>(&cl ient), Return(ByMove(WTF::wrapUnique(reader))))); 336 EXPECT_CALL(*handle, obtainFetchDataReaderMock(_)).WillOnce(DoAll(SaveArg<0> (&client), Return(ByMove(WTF::wrapUnique(reader)))));
337 EXPECT_CALL(checkpoint, Call(2)); 337 EXPECT_CALL(checkpoint, Call(2));
338 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengt h), Return(kOk))); 338 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengt h), Return(kOk)));
339 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLength)).WillOnce(Return(kOk)); 339 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLength)).WillOnce(Return(kOk));
340 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kDone)); 340 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kDone));
341 EXPECT_CALL(*reader, destruct()); 341 EXPECT_CALL(*reader, destruct());
342 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedString(String(kQuickBr ownFox))); 342 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedString(String(kQuickBr ownFox)));
343 EXPECT_CALL(checkpoint, Call(3)); 343 EXPECT_CALL(checkpoint, Call(3));
344 EXPECT_CALL(checkpoint, Call(4)); 344 EXPECT_CALL(checkpoint, Call(4));
345 345
346 checkpoint.Call(1); 346 checkpoint.Call(1);
347 fetchDataLoader->start(handle.get(), fetchDataLoaderClient); 347 fetchDataLoader->start(handle.get(), fetchDataLoaderClient, getCurrentTaskRu nner());
348 checkpoint.Call(2); 348 checkpoint.Call(2);
349 ASSERT_TRUE(client); 349 ASSERT_TRUE(client);
350 client->didGetReadable(); 350 client->didGetReadable();
351 checkpoint.Call(3); 351 checkpoint.Call(3);
352 fetchDataLoader->cancel(); 352 fetchDataLoader->cancel();
353 checkpoint.Call(4); 353 checkpoint.Call(4);
354 } 354 }
355 355
356 TEST(FetchDataLoaderTest, LoadAsStringWithNullBytes) 356 TEST(FetchDataLoaderTest, LoadAsStringWithNullBytes)
357 { 357 {
358 WebDataConsumerHandle::Client *client = nullptr; 358 WebDataConsumerHandle::Client *client = nullptr;
359 Checkpoint checkpoint; 359 Checkpoint checkpoint;
360 360
361 std::unique_ptr<MockHandle> handle = MockHandle::create(); 361 std::unique_ptr<MockHandle> handle = MockHandle::create();
362 362
363 // |reader| will be adopted by |obtainFetchDataReader|. 363 // |reader| will be adopted by |obtainFetchDataReader|.
364 MockReader* reader = MockReader::create().release(); 364 MockReader* reader = MockReader::create().release();
365 365
366 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsString(); 366 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsString();
367 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create(); 367 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create();
368 368
369 InSequence s; 369 InSequence s;
370 EXPECT_CALL(checkpoint, Call(1)); 370 EXPECT_CALL(checkpoint, Call(1));
371 EXPECT_CALL(*handle, obtainFetchDataReader(_)).WillOnce(DoAll(SaveArg<0>(&cl ient), Return(ByMove(WTF::wrapUnique(reader))))); 371 EXPECT_CALL(*handle, obtainFetchDataReaderMock(_)).WillOnce(DoAll(SaveArg<0> (&client), Return(ByMove(WTF::wrapUnique(reader)))));
372 EXPECT_CALL(checkpoint, Call(2)); 372 EXPECT_CALL(checkpoint, Call(2));
373 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>("Quick\0brown\0fox")), SetArgPointee<2>(16), Return(kO k))); 373 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>("Quick\0brown\0fox")), SetArgPointee<2>(16), Return(kO k)));
374 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillO nce(Return(kOk)); 374 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillO nce(Return(kOk));
375 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kDone)); 375 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kDone));
376 EXPECT_CALL(*reader, destruct()); 376 EXPECT_CALL(*reader, destruct());
377 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedString(String("Quick\0 brown\0fox", 16))); 377 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedString(String("Quick\0 brown\0fox", 16)));
378 EXPECT_CALL(checkpoint, Call(3)); 378 EXPECT_CALL(checkpoint, Call(3));
379 EXPECT_CALL(checkpoint, Call(4)); 379 EXPECT_CALL(checkpoint, Call(4));
380 380
381 checkpoint.Call(1); 381 checkpoint.Call(1);
382 fetchDataLoader->start(handle.get(), fetchDataLoaderClient); 382 fetchDataLoader->start(handle.get(), fetchDataLoaderClient, getCurrentTaskRu nner());
383 checkpoint.Call(2); 383 checkpoint.Call(2);
384 ASSERT_TRUE(client); 384 ASSERT_TRUE(client);
385 client->didGetReadable(); 385 client->didGetReadable();
386 checkpoint.Call(3); 386 checkpoint.Call(3);
387 fetchDataLoader->cancel(); 387 fetchDataLoader->cancel();
388 checkpoint.Call(4); 388 checkpoint.Call(4);
389 } 389 }
390 390
391 TEST(FetchDataLoaderTest, LoadAsStringError) 391 TEST(FetchDataLoaderTest, LoadAsStringError)
392 { 392 {
393 WebDataConsumerHandle::Client *client = nullptr; 393 WebDataConsumerHandle::Client *client = nullptr;
394 Checkpoint checkpoint; 394 Checkpoint checkpoint;
395 395
396 std::unique_ptr<MockHandle> handle = MockHandle::create(); 396 std::unique_ptr<MockHandle> handle = MockHandle::create();
397 397
398 // |reader| will be adopted by |obtainFetchDataReader|. 398 // |reader| will be adopted by |obtainFetchDataReader|.
399 MockReader* reader = MockReader::create().release(); 399 MockReader* reader = MockReader::create().release();
400 400
401 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsString(); 401 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsString();
402 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create(); 402 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create();
403 403
404 InSequence s; 404 InSequence s;
405 EXPECT_CALL(checkpoint, Call(1)); 405 EXPECT_CALL(checkpoint, Call(1));
406 EXPECT_CALL(*handle, obtainFetchDataReader(_)).WillOnce(DoAll(SaveArg<0>(&cl ient), Return(ByMove(WTF::wrapUnique(reader))))); 406 EXPECT_CALL(*handle, obtainFetchDataReaderMock(_)).WillOnce(DoAll(SaveArg<0> (&client), Return(ByMove(WTF::wrapUnique(reader)))));
407 EXPECT_CALL(checkpoint, Call(2)); 407 EXPECT_CALL(checkpoint, Call(2));
408 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengt h), Return(kOk))); 408 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengt h), Return(kOk)));
409 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLength)).WillOnce(Return(kOk)); 409 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLength)).WillOnce(Return(kOk));
410 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kUnexpectedErro r)); 410 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kUnexpectedErro r));
411 EXPECT_CALL(*reader, destruct()); 411 EXPECT_CALL(*reader, destruct());
412 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadFailed()); 412 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadFailed());
413 EXPECT_CALL(checkpoint, Call(3)); 413 EXPECT_CALL(checkpoint, Call(3));
414 EXPECT_CALL(checkpoint, Call(4)); 414 EXPECT_CALL(checkpoint, Call(4));
415 415
416 checkpoint.Call(1); 416 checkpoint.Call(1);
417 fetchDataLoader->start(handle.get(), fetchDataLoaderClient); 417 fetchDataLoader->start(handle.get(), fetchDataLoaderClient, getCurrentTaskRu nner());
418 checkpoint.Call(2); 418 checkpoint.Call(2);
419 ASSERT_TRUE(client); 419 ASSERT_TRUE(client);
420 client->didGetReadable(); 420 client->didGetReadable();
421 checkpoint.Call(3); 421 checkpoint.Call(3);
422 fetchDataLoader->cancel(); 422 fetchDataLoader->cancel();
423 checkpoint.Call(4); 423 checkpoint.Call(4);
424 } 424 }
425 425
426 TEST(FetchDataLoaderTest, LoadAsStringCancel) 426 TEST(FetchDataLoaderTest, LoadAsStringCancel)
427 { 427 {
428 Checkpoint checkpoint; 428 Checkpoint checkpoint;
429 429
430 std::unique_ptr<MockHandle> handle = MockHandle::create(); 430 std::unique_ptr<MockHandle> handle = MockHandle::create();
431 431
432 // |reader| will be adopted by |obtainFetchDataReader|. 432 // |reader| will be adopted by |obtainFetchDataReader|.
433 MockReader* reader = MockReader::create().release(); 433 MockReader* reader = MockReader::create().release();
434 434
435 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsString(); 435 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsString();
436 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create(); 436 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create();
437 437
438 InSequence s; 438 InSequence s;
439 EXPECT_CALL(checkpoint, Call(1)); 439 EXPECT_CALL(checkpoint, Call(1));
440 EXPECT_CALL(*handle, obtainFetchDataReader(_)).WillOnce(Return(ByMove(WTF::w rapUnique(reader)))); 440 EXPECT_CALL(*handle, obtainFetchDataReaderMock(_)).WillOnce(Return(ByMove(WT F::wrapUnique(reader))));
441 EXPECT_CALL(checkpoint, Call(2)); 441 EXPECT_CALL(checkpoint, Call(2));
442 EXPECT_CALL(*reader, destruct()); 442 EXPECT_CALL(*reader, destruct());
443 EXPECT_CALL(checkpoint, Call(3)); 443 EXPECT_CALL(checkpoint, Call(3));
444 444
445 checkpoint.Call(1); 445 checkpoint.Call(1);
446 fetchDataLoader->start(handle.get(), fetchDataLoaderClient); 446 fetchDataLoader->start(handle.get(), fetchDataLoaderClient, getCurrentTaskRu nner());
447 checkpoint.Call(2); 447 checkpoint.Call(2);
448 fetchDataLoader->cancel(); 448 fetchDataLoader->cancel();
449 checkpoint.Call(3); 449 checkpoint.Call(3);
450 } 450 }
451 451
452 } // namespace 452 } // namespace
453 453
454 } // namespace blink 454 } // namespace blink
OLDNEW
« no previous file with comments | « third_party/WebKit/Source/modules/fetch/FetchDataLoader.cpp ('k') | third_party/WebKit/Source/modules/fetch/FetchFormDataConsumerHandle.h » ('j') | third_party/WebKit/Source/modules/fetch/ReadableStreamDataConsumerHandle.cpp » ('J')

Powered by Google App Engine
This is Rietveld 408576698