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

Issues Search
    My Issues | Starred     Open | Closed | All

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

Issue 2269953004: Implment BytesConsumer::tee (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: fix Created 4 years, 3 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/BytesConsumerTestUtil.cpp ('k') | no next file » | no next file with comments »
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/BytesConsumerForDataConsumerHandle.h" 7 #include "modules/fetch/BytesConsumerForDataConsumerHandle.h"
8 #include "modules/fetch/DataConsumerHandleTestUtil.h" 8 #include "modules/fetch/DataConsumerHandleTestUtil.h"
9 #include "testing/gmock/include/gmock/gmock.h" 9 #include "testing/gmock/include/gmock/gmock.h"
10 #include "testing/gtest/include/gtest/gtest.h" 10 #include "testing/gtest/include/gtest/gtest.h"
(...skipping 50 matching lines...) Expand 10 before | Expand all | Expand 10 after
61 EXPECT_CALL(*reader, read(nullptr, kNone, 0, _)).WillOnce(DoAll(SetArgPointe e<3>(0), Return(kShouldWait))); 61 EXPECT_CALL(*reader, read(nullptr, kNone, 0, _)).WillOnce(DoAll(SetArgPointe e<3>(0), Return(kShouldWait)));
62 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengt hWithTerminatingNull), Return(kOk))); 62 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengt hWithTerminatingNull), Return(kOk)));
63 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillO nce(Return(kOk)); 63 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillO nce(Return(kOk));
64 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kDone)); 64 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kDone));
65 EXPECT_CALL(*reader, destruct()); 65 EXPECT_CALL(*reader, destruct());
66 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedBlobHandleMock(_)).Wil lOnce(SaveArg<0>(&blobDataHandle)); 66 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedBlobHandleMock(_)).Wil lOnce(SaveArg<0>(&blobDataHandle));
67 EXPECT_CALL(checkpoint, Call(3)); 67 EXPECT_CALL(checkpoint, Call(3));
68 EXPECT_CALL(checkpoint, Call(4)); 68 EXPECT_CALL(checkpoint, Call(4));
69 69
70 checkpoint.Call(1); 70 checkpoint.Call(1);
71 fetchDataLoader->start(new BytesConsumerForDataConsumerHandle(std::move(hand le)), fetchDataLoaderClient); 71 fetchDataLoader->start(new BytesConsumerForDataConsumerHandle(nullptr, std:: move(handle)), fetchDataLoaderClient);
72 checkpoint.Call(2); 72 checkpoint.Call(2);
73 ASSERT_TRUE(client); 73 ASSERT_TRUE(client);
74 client->didGetReadable(); 74 client->didGetReadable();
75 checkpoint.Call(3); 75 checkpoint.Call(3);
76 fetchDataLoader->cancel(); 76 fetchDataLoader->cancel();
77 checkpoint.Call(4); 77 checkpoint.Call(4);
78 78
79 ASSERT_TRUE(blobDataHandle); 79 ASSERT_TRUE(blobDataHandle);
80 EXPECT_EQ(kQuickBrownFoxLengthWithTerminatingNull, blobDataHandle->size()); 80 EXPECT_EQ(kQuickBrownFoxLengthWithTerminatingNull, blobDataHandle->size());
81 EXPECT_EQ(String("text/test"), blobDataHandle->type()); 81 EXPECT_EQ(String("text/test"), blobDataHandle->type());
(...skipping 21 matching lines...) Expand all
103 EXPECT_CALL(*reader, read(nullptr, kNone, 0, _)).WillOnce(DoAll(SetArgPointe e<3>(0), Return(kShouldWait))); 103 EXPECT_CALL(*reader, read(nullptr, kNone, 0, _)).WillOnce(DoAll(SetArgPointe e<3>(0), Return(kShouldWait)));
104 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengt hWithTerminatingNull), Return(kOk))); 104 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengt hWithTerminatingNull), Return(kOk)));
105 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillO nce(Return(kOk)); 105 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillO nce(Return(kOk));
106 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kUnexpectedErro r)); 106 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kUnexpectedErro r));
107 EXPECT_CALL(*reader, destruct()); 107 EXPECT_CALL(*reader, destruct());
108 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadFailed()); 108 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadFailed());
109 EXPECT_CALL(checkpoint, Call(3)); 109 EXPECT_CALL(checkpoint, Call(3));
110 EXPECT_CALL(checkpoint, Call(4)); 110 EXPECT_CALL(checkpoint, Call(4));
111 111
112 checkpoint.Call(1); 112 checkpoint.Call(1);
113 fetchDataLoader->start(new BytesConsumerForDataConsumerHandle(std::move(hand le)), fetchDataLoaderClient); 113 fetchDataLoader->start(new BytesConsumerForDataConsumerHandle(nullptr, std:: move(handle)), fetchDataLoaderClient);
114 checkpoint.Call(2); 114 checkpoint.Call(2);
115 ASSERT_TRUE(client); 115 ASSERT_TRUE(client);
116 client->didGetReadable(); 116 client->didGetReadable();
117 checkpoint.Call(3); 117 checkpoint.Call(3);
118 fetchDataLoader->cancel(); 118 fetchDataLoader->cancel();
119 checkpoint.Call(4); 119 checkpoint.Call(4);
120 } 120 }
121 121
122 TEST(FetchDataLoaderTest, LoadAsBlobCancel) 122 TEST(FetchDataLoaderTest, LoadAsBlobCancel)
123 { 123 {
(...skipping 10 matching lines...) Expand all
134 InSequence s; 134 InSequence s;
135 EXPECT_CALL(checkpoint, Call(1)); 135 EXPECT_CALL(checkpoint, Call(1));
136 EXPECT_CALL(*handle, obtainFetchDataReader(_)).WillOnce(Return(ByMove(WTF::w rapUnique(reader)))); 136 EXPECT_CALL(*handle, obtainFetchDataReader(_)).WillOnce(Return(ByMove(WTF::w rapUnique(reader))));
137 EXPECT_CALL(*reader, drainAsBlobDataHandle(kDisallowBlobWithInvalidSize)).Wi llOnce(Return(nullptr)); 137 EXPECT_CALL(*reader, drainAsBlobDataHandle(kDisallowBlobWithInvalidSize)).Wi llOnce(Return(nullptr));
138 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (nullptr), SetArgPointee<2>(0), Return(kShouldWait))); 138 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (nullptr), SetArgPointee<2>(0), Return(kShouldWait)));
139 EXPECT_CALL(checkpoint, Call(2)); 139 EXPECT_CALL(checkpoint, Call(2));
140 EXPECT_CALL(*reader, destruct()); 140 EXPECT_CALL(*reader, destruct());
141 EXPECT_CALL(checkpoint, Call(3)); 141 EXPECT_CALL(checkpoint, Call(3));
142 142
143 checkpoint.Call(1); 143 checkpoint.Call(1);
144 fetchDataLoader->start(new BytesConsumerForDataConsumerHandle(std::move(hand le)), fetchDataLoaderClient); 144 fetchDataLoader->start(new BytesConsumerForDataConsumerHandle(nullptr, std:: move(handle)), fetchDataLoaderClient);
145 checkpoint.Call(2); 145 checkpoint.Call(2);
146 fetchDataLoader->cancel(); 146 fetchDataLoader->cancel();
147 checkpoint.Call(3); 147 checkpoint.Call(3);
148 } 148 }
149 149
150 TEST(FetchDataLoaderTest, LoadAsBlobViaDrainAsBlobDataHandleWithSameContentType) 150 TEST(FetchDataLoaderTest, LoadAsBlobViaDrainAsBlobDataHandleWithSameContentType)
151 { 151 {
152 std::unique_ptr<BlobData> blobData = BlobData::create(); 152 std::unique_ptr<BlobData> blobData = BlobData::create();
153 blobData->appendBytes(kQuickBrownFox, kQuickBrownFoxLengthWithTerminatingNul l); 153 blobData->appendBytes(kQuickBrownFox, kQuickBrownFoxLengthWithTerminatingNul l);
154 blobData->setContentType("text/test"); 154 blobData->setContentType("text/test");
(...skipping 13 matching lines...) Expand all
168 InSequence s; 168 InSequence s;
169 EXPECT_CALL(checkpoint, Call(1)); 169 EXPECT_CALL(checkpoint, Call(1));
170 EXPECT_CALL(*handle, obtainFetchDataReader(_)).WillOnce(Return(ByMove(WTF::w rapUnique(reader)))); 170 EXPECT_CALL(*handle, obtainFetchDataReader(_)).WillOnce(Return(ByMove(WTF::w rapUnique(reader))));
171 EXPECT_CALL(*reader, drainAsBlobDataHandle(kDisallowBlobWithInvalidSize)).Wi llOnce(Return(inputBlobDataHandle)); 171 EXPECT_CALL(*reader, drainAsBlobDataHandle(kDisallowBlobWithInvalidSize)).Wi llOnce(Return(inputBlobDataHandle));
172 EXPECT_CALL(*reader, destruct()); 172 EXPECT_CALL(*reader, destruct());
173 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedBlobHandleMock(_)).Wil lOnce(SaveArg<0>(&blobDataHandle)); 173 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedBlobHandleMock(_)).Wil lOnce(SaveArg<0>(&blobDataHandle));
174 EXPECT_CALL(checkpoint, Call(2)); 174 EXPECT_CALL(checkpoint, Call(2));
175 EXPECT_CALL(checkpoint, Call(3)); 175 EXPECT_CALL(checkpoint, Call(3));
176 176
177 checkpoint.Call(1); 177 checkpoint.Call(1);
178 fetchDataLoader->start(new BytesConsumerForDataConsumerHandle(std::move(hand le)), fetchDataLoaderClient); 178 fetchDataLoader->start(new BytesConsumerForDataConsumerHandle(nullptr, std:: move(handle)), fetchDataLoaderClient);
179 checkpoint.Call(2); 179 checkpoint.Call(2);
180 fetchDataLoader->cancel(); 180 fetchDataLoader->cancel();
181 checkpoint.Call(3); 181 checkpoint.Call(3);
182 182
183 ASSERT_TRUE(blobDataHandle); 183 ASSERT_TRUE(blobDataHandle);
184 EXPECT_EQ(inputBlobDataHandle, blobDataHandle); 184 EXPECT_EQ(inputBlobDataHandle, blobDataHandle);
185 EXPECT_EQ(kQuickBrownFoxLengthWithTerminatingNull, blobDataHandle->size()); 185 EXPECT_EQ(kQuickBrownFoxLengthWithTerminatingNull, blobDataHandle->size());
186 EXPECT_EQ(String("text/test"), blobDataHandle->type()); 186 EXPECT_EQ(String("text/test"), blobDataHandle->type());
187 } 187 }
188 188
(...skipping 18 matching lines...) Expand all
207 InSequence s; 207 InSequence s;
208 EXPECT_CALL(checkpoint, Call(1)); 208 EXPECT_CALL(checkpoint, Call(1));
209 EXPECT_CALL(*handle, obtainFetchDataReader(_)).WillOnce(Return(ByMove(WTF::w rapUnique(reader)))); 209 EXPECT_CALL(*handle, obtainFetchDataReader(_)).WillOnce(Return(ByMove(WTF::w rapUnique(reader))));
210 EXPECT_CALL(*reader, drainAsBlobDataHandle(kDisallowBlobWithInvalidSize)).Wi llOnce(Return(inputBlobDataHandle)); 210 EXPECT_CALL(*reader, drainAsBlobDataHandle(kDisallowBlobWithInvalidSize)).Wi llOnce(Return(inputBlobDataHandle));
211 EXPECT_CALL(*reader, destruct()); 211 EXPECT_CALL(*reader, destruct());
212 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedBlobHandleMock(_)).Wil lOnce(SaveArg<0>(&blobDataHandle)); 212 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedBlobHandleMock(_)).Wil lOnce(SaveArg<0>(&blobDataHandle));
213 EXPECT_CALL(checkpoint, Call(2)); 213 EXPECT_CALL(checkpoint, Call(2));
214 EXPECT_CALL(checkpoint, Call(3)); 214 EXPECT_CALL(checkpoint, Call(3));
215 215
216 checkpoint.Call(1); 216 checkpoint.Call(1);
217 fetchDataLoader->start(new BytesConsumerForDataConsumerHandle(std::move(hand le)), fetchDataLoaderClient); 217 fetchDataLoader->start(new BytesConsumerForDataConsumerHandle(nullptr, std:: move(handle)), fetchDataLoaderClient);
218 checkpoint.Call(2); 218 checkpoint.Call(2);
219 fetchDataLoader->cancel(); 219 fetchDataLoader->cancel();
220 checkpoint.Call(3); 220 checkpoint.Call(3);
221 221
222 ASSERT_TRUE(blobDataHandle); 222 ASSERT_TRUE(blobDataHandle);
223 EXPECT_NE(inputBlobDataHandle, blobDataHandle); 223 EXPECT_NE(inputBlobDataHandle, blobDataHandle);
224 EXPECT_EQ(kQuickBrownFoxLengthWithTerminatingNull, blobDataHandle->size()); 224 EXPECT_EQ(kQuickBrownFoxLengthWithTerminatingNull, blobDataHandle->size());
225 EXPECT_EQ(String("text/test"), blobDataHandle->type()); 225 EXPECT_EQ(String("text/test"), blobDataHandle->type());
226 } 226 }
227 227
(...skipping 19 matching lines...) Expand all
247 EXPECT_CALL(*reader, read(nullptr, kNone, 0, _)).WillOnce(DoAll(SetArgPointe e<3>(0), Return(kShouldWait))); 247 EXPECT_CALL(*reader, read(nullptr, kNone, 0, _)).WillOnce(DoAll(SetArgPointe e<3>(0), Return(kShouldWait)));
248 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengt hWithTerminatingNull), Return(kOk))); 248 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengt hWithTerminatingNull), Return(kOk)));
249 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillO nce(Return(kOk)); 249 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillO nce(Return(kOk));
250 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kDone)); 250 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kDone));
251 EXPECT_CALL(*reader, destruct()); 251 EXPECT_CALL(*reader, destruct());
252 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedArrayBufferMock(_)).Wi llOnce(SaveArg<0>(&arrayBuffer)); 252 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedArrayBufferMock(_)).Wi llOnce(SaveArg<0>(&arrayBuffer));
253 EXPECT_CALL(checkpoint, Call(3)); 253 EXPECT_CALL(checkpoint, Call(3));
254 EXPECT_CALL(checkpoint, Call(4)); 254 EXPECT_CALL(checkpoint, Call(4));
255 255
256 checkpoint.Call(1); 256 checkpoint.Call(1);
257 fetchDataLoader->start(new BytesConsumerForDataConsumerHandle(std::move(hand le)), fetchDataLoaderClient); 257 fetchDataLoader->start(new BytesConsumerForDataConsumerHandle(nullptr, std:: move(handle)), fetchDataLoaderClient);
258 checkpoint.Call(2); 258 checkpoint.Call(2);
259 ASSERT_TRUE(client); 259 ASSERT_TRUE(client);
260 client->didGetReadable(); 260 client->didGetReadable();
261 checkpoint.Call(3); 261 checkpoint.Call(3);
262 fetchDataLoader->cancel(); 262 fetchDataLoader->cancel();
263 checkpoint.Call(4); 263 checkpoint.Call(4);
264 264
265 ASSERT_TRUE(arrayBuffer); 265 ASSERT_TRUE(arrayBuffer);
266 ASSERT_EQ(kQuickBrownFoxLengthWithTerminatingNull, arrayBuffer->byteLength() ); 266 ASSERT_EQ(kQuickBrownFoxLengthWithTerminatingNull, arrayBuffer->byteLength() );
267 EXPECT_STREQ(kQuickBrownFox, static_cast<const char*>(arrayBuffer->data())); 267 EXPECT_STREQ(kQuickBrownFox, static_cast<const char*>(arrayBuffer->data()));
(...skipping 20 matching lines...) Expand all
288 EXPECT_CALL(*reader, read(nullptr, kNone, 0, _)).WillOnce(DoAll(SetArgPointe e<3>(0), Return(kShouldWait))); 288 EXPECT_CALL(*reader, read(nullptr, kNone, 0, _)).WillOnce(DoAll(SetArgPointe e<3>(0), Return(kShouldWait)));
289 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengt hWithTerminatingNull), Return(kOk))); 289 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengt hWithTerminatingNull), Return(kOk)));
290 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillO nce(Return(kOk)); 290 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillO nce(Return(kOk));
291 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kUnexpectedErro r)); 291 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kUnexpectedErro r));
292 EXPECT_CALL(*reader, destruct()); 292 EXPECT_CALL(*reader, destruct());
293 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadFailed()); 293 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadFailed());
294 EXPECT_CALL(checkpoint, Call(3)); 294 EXPECT_CALL(checkpoint, Call(3));
295 EXPECT_CALL(checkpoint, Call(4)); 295 EXPECT_CALL(checkpoint, Call(4));
296 296
297 checkpoint.Call(1); 297 checkpoint.Call(1);
298 fetchDataLoader->start(new BytesConsumerForDataConsumerHandle(std::move(hand le)), fetchDataLoaderClient); 298 fetchDataLoader->start(new BytesConsumerForDataConsumerHandle(nullptr, std:: move(handle)), fetchDataLoaderClient);
299 checkpoint.Call(2); 299 checkpoint.Call(2);
300 ASSERT_TRUE(client); 300 ASSERT_TRUE(client);
301 client->didGetReadable(); 301 client->didGetReadable();
302 checkpoint.Call(3); 302 checkpoint.Call(3);
303 fetchDataLoader->cancel(); 303 fetchDataLoader->cancel();
304 checkpoint.Call(4); 304 checkpoint.Call(4);
305 } 305 }
306 306
307 TEST(FetchDataLoaderTest, LoadAsArrayBufferCancel) 307 TEST(FetchDataLoaderTest, LoadAsArrayBufferCancel)
308 { 308 {
309 Checkpoint checkpoint; 309 Checkpoint checkpoint;
310 310
311 std::unique_ptr<MockHandle> handle = MockHandle::create(); 311 std::unique_ptr<MockHandle> handle = MockHandle::create();
312 312
313 // |reader| will be adopted by |obtainFetchDataReader|. 313 // |reader| will be adopted by |obtainFetchDataReader|.
314 MockReader* reader = MockReader::create().release(); 314 MockReader* reader = MockReader::create().release();
315 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsArrayBuffe r(); 315 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsArrayBuffe r();
316 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create(); 316 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create();
317 317
318 InSequence s; 318 InSequence s;
319 EXPECT_CALL(checkpoint, Call(1)); 319 EXPECT_CALL(checkpoint, Call(1));
320 EXPECT_CALL(*handle, obtainFetchDataReader(_)).WillOnce(Return(ByMove(WTF::w rapUnique(reader)))); 320 EXPECT_CALL(*handle, obtainFetchDataReader(_)).WillOnce(Return(ByMove(WTF::w rapUnique(reader))));
321 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (nullptr), SetArgPointee<2>(0), Return(kShouldWait))); 321 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (nullptr), SetArgPointee<2>(0), Return(kShouldWait)));
322 EXPECT_CALL(checkpoint, Call(2)); 322 EXPECT_CALL(checkpoint, Call(2));
323 EXPECT_CALL(*reader, destruct()); 323 EXPECT_CALL(*reader, destruct());
324 EXPECT_CALL(checkpoint, Call(3)); 324 EXPECT_CALL(checkpoint, Call(3));
325 325
326 checkpoint.Call(1); 326 checkpoint.Call(1);
327 fetchDataLoader->start(new BytesConsumerForDataConsumerHandle(std::move(hand le)), fetchDataLoaderClient); 327 fetchDataLoader->start(new BytesConsumerForDataConsumerHandle(nullptr, std:: move(handle)), fetchDataLoaderClient);
328 checkpoint.Call(2); 328 checkpoint.Call(2);
329 fetchDataLoader->cancel(); 329 fetchDataLoader->cancel();
330 checkpoint.Call(3); 330 checkpoint.Call(3);
331 } 331 }
332 332
333 TEST(FetchDataLoaderTest, LoadAsString) 333 TEST(FetchDataLoaderTest, LoadAsString)
334 { 334 {
335 WebDataConsumerHandle::Client *client = nullptr; 335 WebDataConsumerHandle::Client *client = nullptr;
336 Checkpoint checkpoint; 336 Checkpoint checkpoint;
337 337
(...skipping 13 matching lines...) Expand all
351 EXPECT_CALL(*reader, read(nullptr, kNone, 0, _)).WillOnce(DoAll(SetArgPointe e<3>(0), Return(kShouldWait))); 351 EXPECT_CALL(*reader, read(nullptr, kNone, 0, _)).WillOnce(DoAll(SetArgPointe e<3>(0), Return(kShouldWait)));
352 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengt h), Return(kOk))); 352 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengt h), Return(kOk)));
353 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLength)).WillOnce(Return(kOk)); 353 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLength)).WillOnce(Return(kOk));
354 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kDone)); 354 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kDone));
355 EXPECT_CALL(*reader, destruct()); 355 EXPECT_CALL(*reader, destruct());
356 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedString(String(kQuickBr ownFox))); 356 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedString(String(kQuickBr ownFox)));
357 EXPECT_CALL(checkpoint, Call(3)); 357 EXPECT_CALL(checkpoint, Call(3));
358 EXPECT_CALL(checkpoint, Call(4)); 358 EXPECT_CALL(checkpoint, Call(4));
359 359
360 checkpoint.Call(1); 360 checkpoint.Call(1);
361 fetchDataLoader->start(new BytesConsumerForDataConsumerHandle(std::move(hand le)), fetchDataLoaderClient); 361 fetchDataLoader->start(new BytesConsumerForDataConsumerHandle(nullptr, std:: move(handle)), fetchDataLoaderClient);
362 checkpoint.Call(2); 362 checkpoint.Call(2);
363 ASSERT_TRUE(client); 363 ASSERT_TRUE(client);
364 client->didGetReadable(); 364 client->didGetReadable();
365 checkpoint.Call(3); 365 checkpoint.Call(3);
366 fetchDataLoader->cancel(); 366 fetchDataLoader->cancel();
367 checkpoint.Call(4); 367 checkpoint.Call(4);
368 } 368 }
369 369
370 TEST(FetchDataLoaderTest, LoadAsStringWithNullBytes) 370 TEST(FetchDataLoaderTest, LoadAsStringWithNullBytes)
371 { 371 {
(...skipping 16 matching lines...) Expand all
388 EXPECT_CALL(*reader, read(nullptr, kNone, 0, _)).WillOnce(DoAll(SetArgPointe e<3>(0), Return(kShouldWait))); 388 EXPECT_CALL(*reader, read(nullptr, kNone, 0, _)).WillOnce(DoAll(SetArgPointe e<3>(0), Return(kShouldWait)));
389 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>("Quick\0brown\0fox")), SetArgPointee<2>(16), Return(kO k))); 389 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>("Quick\0brown\0fox")), SetArgPointee<2>(16), Return(kO k)));
390 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillO nce(Return(kOk)); 390 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillO nce(Return(kOk));
391 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kDone)); 391 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kDone));
392 EXPECT_CALL(*reader, destruct()); 392 EXPECT_CALL(*reader, destruct());
393 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedString(String("Quick\0 brown\0fox", 16))); 393 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedString(String("Quick\0 brown\0fox", 16)));
394 EXPECT_CALL(checkpoint, Call(3)); 394 EXPECT_CALL(checkpoint, Call(3));
395 EXPECT_CALL(checkpoint, Call(4)); 395 EXPECT_CALL(checkpoint, Call(4));
396 396
397 checkpoint.Call(1); 397 checkpoint.Call(1);
398 fetchDataLoader->start(new BytesConsumerForDataConsumerHandle(std::move(hand le)), fetchDataLoaderClient); 398 fetchDataLoader->start(new BytesConsumerForDataConsumerHandle(nullptr, std:: move(handle)), fetchDataLoaderClient);
399 checkpoint.Call(2); 399 checkpoint.Call(2);
400 ASSERT_TRUE(client); 400 ASSERT_TRUE(client);
401 client->didGetReadable(); 401 client->didGetReadable();
402 checkpoint.Call(3); 402 checkpoint.Call(3);
403 fetchDataLoader->cancel(); 403 fetchDataLoader->cancel();
404 checkpoint.Call(4); 404 checkpoint.Call(4);
405 } 405 }
406 406
407 TEST(FetchDataLoaderTest, LoadAsStringError) 407 TEST(FetchDataLoaderTest, LoadAsStringError)
408 { 408 {
(...skipping 16 matching lines...) Expand all
425 EXPECT_CALL(*reader, read(nullptr, kNone, 0, _)).WillOnce(DoAll(SetArgPointe e<3>(0), Return(kShouldWait))); 425 EXPECT_CALL(*reader, read(nullptr, kNone, 0, _)).WillOnce(DoAll(SetArgPointe e<3>(0), Return(kShouldWait)));
426 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengt h), Return(kOk))); 426 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengt h), Return(kOk)));
427 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLength)).WillOnce(Return(kOk)); 427 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLength)).WillOnce(Return(kOk));
428 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kUnexpectedErro r)); 428 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kUnexpectedErro r));
429 EXPECT_CALL(*reader, destruct()); 429 EXPECT_CALL(*reader, destruct());
430 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadFailed()); 430 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadFailed());
431 EXPECT_CALL(checkpoint, Call(3)); 431 EXPECT_CALL(checkpoint, Call(3));
432 EXPECT_CALL(checkpoint, Call(4)); 432 EXPECT_CALL(checkpoint, Call(4));
433 433
434 checkpoint.Call(1); 434 checkpoint.Call(1);
435 fetchDataLoader->start(new BytesConsumerForDataConsumerHandle(std::move(hand le)), fetchDataLoaderClient); 435 fetchDataLoader->start(new BytesConsumerForDataConsumerHandle(nullptr, std:: move(handle)), fetchDataLoaderClient);
436 checkpoint.Call(2); 436 checkpoint.Call(2);
437 ASSERT_TRUE(client); 437 ASSERT_TRUE(client);
438 client->didGetReadable(); 438 client->didGetReadable();
439 checkpoint.Call(3); 439 checkpoint.Call(3);
440 fetchDataLoader->cancel(); 440 fetchDataLoader->cancel();
441 checkpoint.Call(4); 441 checkpoint.Call(4);
442 } 442 }
443 443
444 TEST(FetchDataLoaderTest, LoadAsStringCancel) 444 TEST(FetchDataLoaderTest, LoadAsStringCancel)
445 { 445 {
446 Checkpoint checkpoint; 446 Checkpoint checkpoint;
447 447
448 std::unique_ptr<MockHandle> handle = MockHandle::create(); 448 std::unique_ptr<MockHandle> handle = MockHandle::create();
449 449
450 // |reader| will be adopted by |obtainFetchDataReader|. 450 // |reader| will be adopted by |obtainFetchDataReader|.
451 MockReader* reader = MockReader::create().release(); 451 MockReader* reader = MockReader::create().release();
452 452
453 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsString(); 453 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsString();
454 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create(); 454 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create();
455 455
456 InSequence s; 456 InSequence s;
457 EXPECT_CALL(checkpoint, Call(1)); 457 EXPECT_CALL(checkpoint, Call(1));
458 EXPECT_CALL(*handle, obtainFetchDataReader(_)).WillOnce(Return(ByMove(WTF::w rapUnique(reader)))); 458 EXPECT_CALL(*handle, obtainFetchDataReader(_)).WillOnce(Return(ByMove(WTF::w rapUnique(reader))));
459 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (nullptr), SetArgPointee<2>(0), Return(kShouldWait))); 459 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (nullptr), SetArgPointee<2>(0), Return(kShouldWait)));
460 EXPECT_CALL(checkpoint, Call(2)); 460 EXPECT_CALL(checkpoint, Call(2));
461 EXPECT_CALL(*reader, destruct()); 461 EXPECT_CALL(*reader, destruct());
462 EXPECT_CALL(checkpoint, Call(3)); 462 EXPECT_CALL(checkpoint, Call(3));
463 463
464 checkpoint.Call(1); 464 checkpoint.Call(1);
465 fetchDataLoader->start(new BytesConsumerForDataConsumerHandle(std::move(hand le)), fetchDataLoaderClient); 465 fetchDataLoader->start(new BytesConsumerForDataConsumerHandle(nullptr, std:: move(handle)), fetchDataLoaderClient);
466 checkpoint.Call(2); 466 checkpoint.Call(2);
467 fetchDataLoader->cancel(); 467 fetchDataLoader->cancel();
468 checkpoint.Call(3); 468 checkpoint.Call(3);
469 } 469 }
470 470
471 } // namespace 471 } // namespace
472 472
473 } // namespace blink 473 } // namespace blink
OLDNEW
« no previous file with comments | « third_party/WebKit/Source/modules/fetch/BytesConsumerTestUtil.cpp ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698