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

Issues Search
    My Issues | Starred     Open | Closed | All

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

Issue 1217943007: Call Client methods synchronously in FetchDataLoader if the first read is Done or error (Closed) Base URL: https://chromium.googlesource.com/chromium/blink.git@master
Patch Set: Fix unittests. Created 5 years, 5 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 | « Source/modules/fetch/FetchDataLoader.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 "config.h" 5 #include "config.h"
6 #include "modules/fetch/FetchDataLoader.h" 6 #include "modules/fetch/FetchDataLoader.h"
7 7
8 #include "modules/fetch/DataConsumerHandleTestUtil.h" 8 #include "modules/fetch/DataConsumerHandleTestUtil.h"
9 9
10 #include <gmock/gmock.h> 10 #include <gmock/gmock.h>
11 #include <gtest/gtest.h> 11 #include <gtest/gtest.h>
12 12
13 namespace blink { 13 namespace blink {
14 14
15 namespace { 15 namespace {
16 16
17 using ::testing::InSequence; 17 using ::testing::InSequence;
18 using ::testing::Return; 18 using ::testing::Return;
19 using ::testing::DoAll; 19 using ::testing::DoAll;
20 using ::testing::StrictMock; 20 using ::testing::StrictMock;
21 using ::testing::_; 21 using ::testing::_;
22 using ::testing::SaveArg; 22 using ::testing::SaveArg;
23 using ::testing::SetArgPointee; 23 using ::testing::SetArgPointee;
24 using Checkpoint = StrictMock<::testing::MockFunction<void(int)>>; 24 using Checkpoint = StrictMock<::testing::MockFunction<void(int)>>;
25 using MockFetchDataLoaderClient = DataConsumerHandleTestUtil::MockFetchDataLoade rClient; 25 using MockFetchDataLoaderClient = DataConsumerHandleTestUtil::MockFetchDataLoade rClient;
26 26
27 const WebDataConsumerHandle::Result kOk = WebDataConsumerHandle::Ok; 27 const WebDataConsumerHandle::Result kOk = WebDataConsumerHandle::Ok;
28 const WebDataConsumerHandle::Result kUnexpectedError = WebDataConsumerHandle::Un expectedError; 28 const WebDataConsumerHandle::Result kUnexpectedError = WebDataConsumerHandle::Un expectedError;
29 const WebDataConsumerHandle::Result kDone = WebDataConsumerHandle::Done; 29 const WebDataConsumerHandle::Result kDone = WebDataConsumerHandle::Done;
30 const WebDataConsumerHandle::Result kShouldWait = WebDataConsumerHandle::ShouldW ait;
30 const WebDataConsumerHandle::Flags kNone = WebDataConsumerHandle::FlagNone; 31 const WebDataConsumerHandle::Flags kNone = WebDataConsumerHandle::FlagNone;
31 const FetchDataConsumerHandle::Reader::BlobSizePolicy kDisallowBlobWithInvalidSi ze = FetchDataConsumerHandle::Reader::DisallowBlobWithInvalidSize; 32 const FetchDataConsumerHandle::Reader::BlobSizePolicy kDisallowBlobWithInvalidSi ze = FetchDataConsumerHandle::Reader::DisallowBlobWithInvalidSize;
32 33
33 class MockReader : public FetchDataConsumerHandle::Reader { 34 class MockReader : public FetchDataConsumerHandle::Reader {
34 public: 35 public:
35 static PassOwnPtr<StrictMock<MockReader>> create() { return adoptPtr(new Str ictMock<MockReader>); } 36 static PassOwnPtr<StrictMock<MockReader>> create() { return adoptPtr(new Str ictMock<MockReader>); }
36 37
37 using Result = WebDataConsumerHandle::Result; 38 using Result = WebDataConsumerHandle::Result;
38 using Flags = WebDataConsumerHandle::Flags; 39 using Flags = WebDataConsumerHandle::Flags;
39 MOCK_METHOD4(read, Result(void*, size_t, Flags, size_t*)); 40 MOCK_METHOD4(read, Result(void*, size_t, Flags, size_t*));
(...skipping 27 matching lines...) Expand all
67 OwnPtr<MockHandle> handle = MockHandle::create(); 68 OwnPtr<MockHandle> handle = MockHandle::create();
68 OwnPtr<MockReader> reader = MockReader::create(); 69 OwnPtr<MockReader> reader = MockReader::create();
69 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsBlobHandle ("text/test"); 70 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsBlobHandle ("text/test");
70 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create(); 71 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create();
71 RefPtr<BlobDataHandle> blobDataHandle; 72 RefPtr<BlobDataHandle> blobDataHandle;
72 73
73 InSequence s; 74 InSequence s;
74 EXPECT_CALL(checkpoint, Call(1)); 75 EXPECT_CALL(checkpoint, Call(1));
75 EXPECT_CALL(*handle, obtainReaderInternal(_)).WillOnce(DoAll(SaveArg<0>(&cli ent), Return(reader.get()))); 76 EXPECT_CALL(*handle, obtainReaderInternal(_)).WillOnce(DoAll(SaveArg<0>(&cli ent), Return(reader.get())));
76 EXPECT_CALL(*reader, drainAsBlobDataHandle(kDisallowBlobWithInvalidSize)).Wi llOnce(Return(nullptr)); 77 EXPECT_CALL(*reader, drainAsBlobDataHandle(kDisallowBlobWithInvalidSize)).Wi llOnce(Return(nullptr));
78 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kShouldWait));
77 EXPECT_CALL(checkpoint, Call(2)); 79 EXPECT_CALL(checkpoint, Call(2));
78 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengt hWithTerminatingNull), Return(kOk))); 80 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengt hWithTerminatingNull), Return(kOk)));
79 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillO nce(Return(kOk)); 81 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillO nce(Return(kOk));
80 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kDone)); 82 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kDone));
81 EXPECT_CALL(*reader, destruct()); 83 EXPECT_CALL(*reader, destruct());
82 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedBlobHandleMock(_)).Wil lOnce(SaveArg<0>(&blobDataHandle)); 84 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedBlobHandleMock(_)).Wil lOnce(SaveArg<0>(&blobDataHandle));
83 EXPECT_CALL(checkpoint, Call(3)); 85 EXPECT_CALL(checkpoint, Call(3));
84 EXPECT_CALL(checkpoint, Call(4)); 86 EXPECT_CALL(checkpoint, Call(4));
85 87
86 // |reader| is adopted by |obtainReader|. 88 // |reader| is adopted by |obtainReader|.
(...skipping 20 matching lines...) Expand all
107 109
108 OwnPtr<MockHandle> handle = MockHandle::create(); 110 OwnPtr<MockHandle> handle = MockHandle::create();
109 OwnPtr<MockReader> reader = MockReader::create(); 111 OwnPtr<MockReader> reader = MockReader::create();
110 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsBlobHandle ("text/test"); 112 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsBlobHandle ("text/test");
111 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create(); 113 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create();
112 114
113 InSequence s; 115 InSequence s;
114 EXPECT_CALL(checkpoint, Call(1)); 116 EXPECT_CALL(checkpoint, Call(1));
115 EXPECT_CALL(*handle, obtainReaderInternal(_)).WillOnce(DoAll(SaveArg<0>(&cli ent), Return(reader.get()))); 117 EXPECT_CALL(*handle, obtainReaderInternal(_)).WillOnce(DoAll(SaveArg<0>(&cli ent), Return(reader.get())));
116 EXPECT_CALL(*reader, drainAsBlobDataHandle(kDisallowBlobWithInvalidSize)).Wi llOnce(Return(nullptr)); 118 EXPECT_CALL(*reader, drainAsBlobDataHandle(kDisallowBlobWithInvalidSize)).Wi llOnce(Return(nullptr));
119 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kShouldWait));
117 EXPECT_CALL(checkpoint, Call(2)); 120 EXPECT_CALL(checkpoint, Call(2));
118 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengt hWithTerminatingNull), Return(kOk))); 121 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengt hWithTerminatingNull), Return(kOk)));
119 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillO nce(Return(kOk)); 122 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillO nce(Return(kOk));
120 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kUnexpectedErro r)); 123 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kUnexpectedErro r));
121 EXPECT_CALL(*reader, destruct()); 124 EXPECT_CALL(*reader, destruct());
122 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadFailed()); 125 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadFailed());
123 EXPECT_CALL(checkpoint, Call(3)); 126 EXPECT_CALL(checkpoint, Call(3));
124 EXPECT_CALL(checkpoint, Call(4)); 127 EXPECT_CALL(checkpoint, Call(4));
125 128
126 // |reader| is adopted by |obtainReader|. 129 // |reader| is adopted by |obtainReader|.
(...skipping 15 matching lines...) Expand all
142 145
143 OwnPtr<MockHandle> handle = MockHandle::create(); 146 OwnPtr<MockHandle> handle = MockHandle::create();
144 OwnPtr<MockReader> reader = MockReader::create(); 147 OwnPtr<MockReader> reader = MockReader::create();
145 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsBlobHandle ("text/test"); 148 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsBlobHandle ("text/test");
146 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create(); 149 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create();
147 150
148 InSequence s; 151 InSequence s;
149 EXPECT_CALL(checkpoint, Call(1)); 152 EXPECT_CALL(checkpoint, Call(1));
150 EXPECT_CALL(*handle, obtainReaderInternal(_)).WillOnce(Return(reader.get())) ; 153 EXPECT_CALL(*handle, obtainReaderInternal(_)).WillOnce(Return(reader.get())) ;
151 EXPECT_CALL(*reader, drainAsBlobDataHandle(kDisallowBlobWithInvalidSize)).Wi llOnce(Return(nullptr)); 154 EXPECT_CALL(*reader, drainAsBlobDataHandle(kDisallowBlobWithInvalidSize)).Wi llOnce(Return(nullptr));
155 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kShouldWait));
152 EXPECT_CALL(checkpoint, Call(2)); 156 EXPECT_CALL(checkpoint, Call(2));
153 EXPECT_CALL(*reader, destruct()); 157 EXPECT_CALL(*reader, destruct());
154 EXPECT_CALL(checkpoint, Call(3)); 158 EXPECT_CALL(checkpoint, Call(3));
155 159
156 // |reader| is adopted by |obtainReader|. 160 // |reader| is adopted by |obtainReader|.
157 ASSERT_TRUE(reader.leakPtr()); 161 ASSERT_TRUE(reader.leakPtr());
158 162
159 checkpoint.Call(1); 163 checkpoint.Call(1);
160 fetchDataLoader->start(handle.get(), fetchDataLoaderClient); 164 fetchDataLoader->start(handle.get(), fetchDataLoaderClient);
161 checkpoint.Call(2); 165 checkpoint.Call(2);
(...skipping 86 matching lines...) Expand 10 before | Expand all | Expand 10 after
248 252
249 OwnPtr<MockHandle> handle = MockHandle::create(); 253 OwnPtr<MockHandle> handle = MockHandle::create();
250 OwnPtr<MockReader> reader = MockReader::create(); 254 OwnPtr<MockReader> reader = MockReader::create();
251 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsArrayBuffe r(); 255 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsArrayBuffe r();
252 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create(); 256 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create();
253 RefPtr<DOMArrayBuffer> arrayBuffer; 257 RefPtr<DOMArrayBuffer> arrayBuffer;
254 258
255 InSequence s; 259 InSequence s;
256 EXPECT_CALL(checkpoint, Call(1)); 260 EXPECT_CALL(checkpoint, Call(1));
257 EXPECT_CALL(*handle, obtainReaderInternal(_)).WillOnce(DoAll(SaveArg<0>(&cli ent), Return(reader.get()))); 261 EXPECT_CALL(*handle, obtainReaderInternal(_)).WillOnce(DoAll(SaveArg<0>(&cli ent), Return(reader.get())));
262 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kShouldWait));
258 EXPECT_CALL(checkpoint, Call(2)); 263 EXPECT_CALL(checkpoint, Call(2));
259 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengt hWithTerminatingNull), Return(kOk))); 264 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengt hWithTerminatingNull), Return(kOk)));
260 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillO nce(Return(kOk)); 265 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillO nce(Return(kOk));
261 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kDone)); 266 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kDone));
262 EXPECT_CALL(*reader, destruct()); 267 EXPECT_CALL(*reader, destruct());
263 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedArrayBufferMock(_)).Wi llOnce(SaveArg<0>(&arrayBuffer)); 268 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedArrayBufferMock(_)).Wi llOnce(SaveArg<0>(&arrayBuffer));
264 EXPECT_CALL(checkpoint, Call(3)); 269 EXPECT_CALL(checkpoint, Call(3));
265 EXPECT_CALL(checkpoint, Call(4)); 270 EXPECT_CALL(checkpoint, Call(4));
266 271
267 // |reader| is adopted by |obtainReader|. 272 // |reader| is adopted by |obtainReader|.
(...skipping 19 matching lines...) Expand all
287 Checkpoint checkpoint; 292 Checkpoint checkpoint;
288 293
289 OwnPtr<MockHandle> handle = MockHandle::create(); 294 OwnPtr<MockHandle> handle = MockHandle::create();
290 OwnPtr<MockReader> reader = MockReader::create(); 295 OwnPtr<MockReader> reader = MockReader::create();
291 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsArrayBuffe r(); 296 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsArrayBuffe r();
292 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create(); 297 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create();
293 298
294 InSequence s; 299 InSequence s;
295 EXPECT_CALL(checkpoint, Call(1)); 300 EXPECT_CALL(checkpoint, Call(1));
296 EXPECT_CALL(*handle, obtainReaderInternal(_)).WillOnce(DoAll(SaveArg<0>(&cli ent), Return(reader.get()))); 301 EXPECT_CALL(*handle, obtainReaderInternal(_)).WillOnce(DoAll(SaveArg<0>(&cli ent), Return(reader.get())));
302 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kShouldWait));
297 EXPECT_CALL(checkpoint, Call(2)); 303 EXPECT_CALL(checkpoint, Call(2));
298 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengt hWithTerminatingNull), Return(kOk))); 304 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengt hWithTerminatingNull), Return(kOk)));
299 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillO nce(Return(kOk)); 305 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillO nce(Return(kOk));
300 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kUnexpectedErro r)); 306 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kUnexpectedErro r));
301 EXPECT_CALL(*reader, destruct()); 307 EXPECT_CALL(*reader, destruct());
302 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadFailed()); 308 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadFailed());
303 EXPECT_CALL(checkpoint, Call(3)); 309 EXPECT_CALL(checkpoint, Call(3));
304 EXPECT_CALL(checkpoint, Call(4)); 310 EXPECT_CALL(checkpoint, Call(4));
305 311
306 // |reader| is adopted by |obtainReader|. 312 // |reader| is adopted by |obtainReader|.
(...skipping 14 matching lines...) Expand all
321 Checkpoint checkpoint; 327 Checkpoint checkpoint;
322 328
323 OwnPtr<MockHandle> handle = MockHandle::create(); 329 OwnPtr<MockHandle> handle = MockHandle::create();
324 OwnPtr<MockReader> reader = MockReader::create(); 330 OwnPtr<MockReader> reader = MockReader::create();
325 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsArrayBuffe r(); 331 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsArrayBuffe r();
326 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create(); 332 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create();
327 333
328 InSequence s; 334 InSequence s;
329 EXPECT_CALL(checkpoint, Call(1)); 335 EXPECT_CALL(checkpoint, Call(1));
330 EXPECT_CALL(*handle, obtainReaderInternal(_)).WillOnce(Return(reader.get())) ; 336 EXPECT_CALL(*handle, obtainReaderInternal(_)).WillOnce(Return(reader.get())) ;
337 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kShouldWait));
331 EXPECT_CALL(checkpoint, Call(2)); 338 EXPECT_CALL(checkpoint, Call(2));
332 EXPECT_CALL(*reader, destruct()); 339 EXPECT_CALL(*reader, destruct());
333 EXPECT_CALL(checkpoint, Call(3)); 340 EXPECT_CALL(checkpoint, Call(3));
334 341
335 // |reader| is adopted by |obtainReader|. 342 // |reader| is adopted by |obtainReader|.
336 ASSERT_TRUE(reader.leakPtr()); 343 ASSERT_TRUE(reader.leakPtr());
337 344
338 checkpoint.Call(1); 345 checkpoint.Call(1);
339 fetchDataLoader->start(handle.get(), fetchDataLoaderClient); 346 fetchDataLoader->start(handle.get(), fetchDataLoaderClient);
340 checkpoint.Call(2); 347 checkpoint.Call(2);
341 fetchDataLoader->cancel(); 348 fetchDataLoader->cancel();
342 checkpoint.Call(3); 349 checkpoint.Call(3);
343 } 350 }
344 351
345 TEST(FetchDataLoaderTest, LoadAsString) 352 TEST(FetchDataLoaderTest, LoadAsString)
346 { 353 {
347 WebDataConsumerHandle::Client *client = nullptr; 354 WebDataConsumerHandle::Client *client = nullptr;
348 Checkpoint checkpoint; 355 Checkpoint checkpoint;
349 356
350 OwnPtr<MockHandle> handle = MockHandle::create(); 357 OwnPtr<MockHandle> handle = MockHandle::create();
351 OwnPtr<MockReader> reader = MockReader::create(); 358 OwnPtr<MockReader> reader = MockReader::create();
352 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsString(); 359 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsString();
353 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create(); 360 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create();
354 361
355 InSequence s; 362 InSequence s;
356 EXPECT_CALL(checkpoint, Call(1)); 363 EXPECT_CALL(checkpoint, Call(1));
357 EXPECT_CALL(*handle, obtainReaderInternal(_)).WillOnce(DoAll(SaveArg<0>(&cli ent), Return(reader.get()))); 364 EXPECT_CALL(*handle, obtainReaderInternal(_)).WillOnce(DoAll(SaveArg<0>(&cli ent), Return(reader.get())));
365 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kShouldWait));
358 EXPECT_CALL(checkpoint, Call(2)); 366 EXPECT_CALL(checkpoint, Call(2));
359 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengt h), Return(kOk))); 367 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengt h), Return(kOk)));
360 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLength)).WillOnce(Return(kOk)); 368 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLength)).WillOnce(Return(kOk));
361 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kDone)); 369 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kDone));
362 EXPECT_CALL(*reader, destruct()); 370 EXPECT_CALL(*reader, destruct());
363 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedString(String(kQuickBr ownFox))); 371 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedString(String(kQuickBr ownFox)));
364 EXPECT_CALL(checkpoint, Call(3)); 372 EXPECT_CALL(checkpoint, Call(3));
365 EXPECT_CALL(checkpoint, Call(4)); 373 EXPECT_CALL(checkpoint, Call(4));
366 374
367 // |reader| is adopted by |obtainReader|. 375 // |reader| is adopted by |obtainReader|.
(...skipping 15 matching lines...) Expand all
383 Checkpoint checkpoint; 391 Checkpoint checkpoint;
384 392
385 OwnPtr<MockHandle> handle = MockHandle::create(); 393 OwnPtr<MockHandle> handle = MockHandle::create();
386 OwnPtr<MockReader> reader = MockReader::create(); 394 OwnPtr<MockReader> reader = MockReader::create();
387 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsString(); 395 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsString();
388 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create(); 396 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create();
389 397
390 InSequence s; 398 InSequence s;
391 EXPECT_CALL(checkpoint, Call(1)); 399 EXPECT_CALL(checkpoint, Call(1));
392 EXPECT_CALL(*handle, obtainReaderInternal(_)).WillOnce(DoAll(SaveArg<0>(&cli ent), Return(reader.get()))); 400 EXPECT_CALL(*handle, obtainReaderInternal(_)).WillOnce(DoAll(SaveArg<0>(&cli ent), Return(reader.get())));
401 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kShouldWait));
393 EXPECT_CALL(checkpoint, Call(2)); 402 EXPECT_CALL(checkpoint, Call(2));
394 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>("Quick\0brown\0fox")), SetArgPointee<2>(16), Return(kO k))); 403 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>("Quick\0brown\0fox")), SetArgPointee<2>(16), Return(kO k)));
395 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillO nce(Return(kOk)); 404 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLengthWithTerminatingNull)).WillO nce(Return(kOk));
396 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kDone)); 405 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kDone));
397 EXPECT_CALL(*reader, destruct()); 406 EXPECT_CALL(*reader, destruct());
398 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedString(String("Quick\0 brown\0fox", 16))); 407 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadedString(String("Quick\0 brown\0fox", 16)));
399 EXPECT_CALL(checkpoint, Call(3)); 408 EXPECT_CALL(checkpoint, Call(3));
400 EXPECT_CALL(checkpoint, Call(4)); 409 EXPECT_CALL(checkpoint, Call(4));
401 410
402 // |reader| is adopted by |obtainReader|. 411 // |reader| is adopted by |obtainReader|.
(...skipping 15 matching lines...) Expand all
418 Checkpoint checkpoint; 427 Checkpoint checkpoint;
419 428
420 OwnPtr<MockHandle> handle = MockHandle::create(); 429 OwnPtr<MockHandle> handle = MockHandle::create();
421 OwnPtr<MockReader> reader = MockReader::create(); 430 OwnPtr<MockReader> reader = MockReader::create();
422 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsString(); 431 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsString();
423 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create(); 432 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create();
424 433
425 InSequence s; 434 InSequence s;
426 EXPECT_CALL(checkpoint, Call(1)); 435 EXPECT_CALL(checkpoint, Call(1));
427 EXPECT_CALL(*handle, obtainReaderInternal(_)).WillOnce(DoAll(SaveArg<0>(&cli ent), Return(reader.get()))); 436 EXPECT_CALL(*handle, obtainReaderInternal(_)).WillOnce(DoAll(SaveArg<0>(&cli ent), Return(reader.get())));
437 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kShouldWait));
428 EXPECT_CALL(checkpoint, Call(2)); 438 EXPECT_CALL(checkpoint, Call(2));
429 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengt h), Return(kOk))); 439 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(DoAll(SetArgPointee<0> (static_cast<const void*>(kQuickBrownFox)), SetArgPointee<2>(kQuickBrownFoxLengt h), Return(kOk)));
430 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLength)).WillOnce(Return(kOk)); 440 EXPECT_CALL(*reader, endRead(kQuickBrownFoxLength)).WillOnce(Return(kOk));
431 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kUnexpectedErro r)); 441 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kUnexpectedErro r));
432 EXPECT_CALL(*reader, destruct()); 442 EXPECT_CALL(*reader, destruct());
433 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadFailed()); 443 EXPECT_CALL(*fetchDataLoaderClient, didFetchDataLoadFailed());
434 EXPECT_CALL(checkpoint, Call(3)); 444 EXPECT_CALL(checkpoint, Call(3));
435 EXPECT_CALL(checkpoint, Call(4)); 445 EXPECT_CALL(checkpoint, Call(4));
436 446
437 // |reader| is adopted by |obtainReader|. 447 // |reader| is adopted by |obtainReader|.
(...skipping 14 matching lines...) Expand all
452 Checkpoint checkpoint; 462 Checkpoint checkpoint;
453 463
454 OwnPtr<MockHandle> handle = MockHandle::create(); 464 OwnPtr<MockHandle> handle = MockHandle::create();
455 OwnPtr<MockReader> reader = MockReader::create(); 465 OwnPtr<MockReader> reader = MockReader::create();
456 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsString(); 466 FetchDataLoader* fetchDataLoader = FetchDataLoader::createLoaderAsString();
457 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create(); 467 MockFetchDataLoaderClient* fetchDataLoaderClient = MockFetchDataLoaderClient ::create();
458 468
459 InSequence s; 469 InSequence s;
460 EXPECT_CALL(checkpoint, Call(1)); 470 EXPECT_CALL(checkpoint, Call(1));
461 EXPECT_CALL(*handle, obtainReaderInternal(_)).WillOnce(Return(reader.get())) ; 471 EXPECT_CALL(*handle, obtainReaderInternal(_)).WillOnce(Return(reader.get())) ;
472 EXPECT_CALL(*reader, beginRead(_, kNone, _)).WillOnce(Return(kShouldWait));
462 EXPECT_CALL(checkpoint, Call(2)); 473 EXPECT_CALL(checkpoint, Call(2));
463 EXPECT_CALL(*reader, destruct()); 474 EXPECT_CALL(*reader, destruct());
464 EXPECT_CALL(checkpoint, Call(3)); 475 EXPECT_CALL(checkpoint, Call(3));
465 476
466 // |reader| is adopted by |obtainReader|. 477 // |reader| is adopted by |obtainReader|.
467 ASSERT_TRUE(reader.leakPtr()); 478 ASSERT_TRUE(reader.leakPtr());
468 479
469 checkpoint.Call(1); 480 checkpoint.Call(1);
470 fetchDataLoader->start(handle.get(), fetchDataLoaderClient); 481 fetchDataLoader->start(handle.get(), fetchDataLoaderClient);
471 checkpoint.Call(2); 482 checkpoint.Call(2);
472 fetchDataLoader->cancel(); 483 fetchDataLoader->cancel();
473 checkpoint.Call(3); 484 checkpoint.Call(3);
474 } 485 }
475 486
476 } // namespace 487 } // namespace
477 488
478 } // namespace blink 489 } // namespace blink
OLDNEW
« no previous file with comments | « Source/modules/fetch/FetchDataLoader.cpp ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698