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

Side by Side Diff: net/base/file_stream_unittest.cc

Issue 10701050: net: Implement canceling of all async operations in FileStream. (Closed) Base URL: https://src.chromium.org/chrome/trunk/src/
Patch Set: Created 8 years, 1 month 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
OLDNEW
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 1 // Copyright (c) 2012 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 "net/base/file_stream.h" 5 #include "net/base/file_stream.h"
6 6
7 #include "base/bind.h" 7 #include "base/bind.h"
8 #include "base/callback.h" 8 #include "base/callback.h"
9 #include "base/file_util.h" 9 #include "base/file_util.h"
10 #include "base/message_loop.h" 10 #include "base/message_loop.h"
(...skipping 15 matching lines...) Expand all
26 const char kTestData[] = "0123456789"; 26 const char kTestData[] = "0123456789";
27 const int kTestDataSize = arraysize(kTestData) - 1; 27 const int kTestDataSize = arraysize(kTestData) - 1;
28 28
29 // Creates an IOBufferWithSize that contains the kTestDataSize. 29 // Creates an IOBufferWithSize that contains the kTestDataSize.
30 IOBufferWithSize* CreateTestDataBuffer() { 30 IOBufferWithSize* CreateTestDataBuffer() {
31 IOBufferWithSize* buf = new IOBufferWithSize(kTestDataSize); 31 IOBufferWithSize* buf = new IOBufferWithSize(kTestDataSize);
32 memcpy(buf->data(), kTestData, kTestDataSize); 32 memcpy(buf->data(), kTestData, kTestDataSize);
33 return buf; 33 return buf;
34 } 34 }
35 35
36 // This NetLog is used for notifying when a file stream is closed
37 // (i.e. TYPE_FILE_STREAM_CLOSE event is recorded).
38 class NetLogForNotifyingFileClosure : public NetLog {
39 public:
40 NetLogForNotifyingFileClosure()
41 : last_id_(0),
42 on_closure_(false /* manual_reset */, false /* initially_signaled */) {
43 }
44
45 // Wait until a file closure event is recorded.
46 bool WaitForClosure() {
47 const base::TimeDelta timeout(TestTimeouts::action_max_timeout());
48 return on_closure_.TimedWait(timeout);
49 }
50
51 // NetLog overrides:
52 virtual void OnAddEntry(const net::NetLog::Entry& entry) OVERRIDE {
53 if (entry.type() == TYPE_FILE_STREAM_CLOSE)
54 on_closure_.Signal();
55 }
56
57 virtual uint32 NextID() OVERRIDE { return ++last_id_; }
58 virtual LogLevel GetLogLevel() const OVERRIDE { return LOG_ALL; }
59 virtual void AddThreadSafeObserver(ThreadSafeObserver* observer,
60 LogLevel log_level) OVERRIDE {
61 NOTIMPLEMENTED();
62 }
63 virtual void SetObserverLogLevel(ThreadSafeObserver* observer,
64 LogLevel log_level) OVERRIDE {
65 NOTIMPLEMENTED();
66 }
67 virtual void RemoveThreadSafeObserver(ThreadSafeObserver* observer) OVERRIDE {
68 NOTIMPLEMENTED();
69 }
70
71 private:
72 uint32 last_id_;
73 base::WaitableEvent on_closure_;
74 };
75
76 } // namespace 36 } // namespace
77 37
78 class FileStreamTest : public PlatformTest { 38 class FileStreamTest : public PlatformTest {
79 public: 39 public:
80 virtual void SetUp() { 40 virtual void SetUp() {
81 PlatformTest::SetUp(); 41 PlatformTest::SetUp();
82 42
83 file_util::CreateTemporaryFile(&temp_file_path_); 43 file_util::CreateTemporaryFile(&temp_file_path_);
84 file_util::WriteFile(temp_file_path_, kTestData, kTestDataSize); 44 file_util::WriteFile(temp_file_path_, kTestData, kTestDataSize);
85 } 45 }
(...skipping 20 matching lines...) Expand all
106 EXPECT_EQ(OK, rv); 66 EXPECT_EQ(OK, rv);
107 EXPECT_TRUE(stream.IsOpen()); 67 EXPECT_TRUE(stream.IsOpen());
108 file = stream.GetPlatformFileForTesting(); 68 file = stream.GetPlatformFileForTesting();
109 } 69 }
110 EXPECT_NE(base::kInvalidPlatformFileValue, file); 70 EXPECT_NE(base::kInvalidPlatformFileValue, file);
111 base::PlatformFileInfo info; 71 base::PlatformFileInfo info;
112 // The file should be closed. 72 // The file should be closed.
113 EXPECT_FALSE(base::GetPlatformFileInfo(file, &info)); 73 EXPECT_FALSE(base::GetPlatformFileInfo(file, &info));
114 } 74 }
115 75
116 TEST_F(FileStreamTest, FileHandleLeftOpen) { 76 TEST_F(FileStreamTest, FileHandleNotLeftOpen) {
117 bool created = false; 77 bool created = false;
118 ASSERT_EQ(kTestDataSize, 78 ASSERT_EQ(kTestDataSize,
119 file_util::WriteFile(temp_file_path(), kTestData, kTestDataSize)); 79 file_util::WriteFile(temp_file_path(), kTestData, kTestDataSize));
120 int flags = base::PLATFORM_FILE_OPEN_ALWAYS | base::PLATFORM_FILE_READ; 80 int flags = base::PLATFORM_FILE_OPEN_ALWAYS | base::PLATFORM_FILE_READ;
121 base::PlatformFile file = base::CreatePlatformFile( 81 base::PlatformFile file = base::CreatePlatformFile(
122 temp_file_path(), flags, &created, NULL); 82 temp_file_path(), flags, &created, NULL);
123 83
124 { 84 {
125 // Seek to the beginning of the file and read. 85 // Seek to the beginning of the file and read.
126 FileStream read_stream(file, flags, NULL); 86 FileStream read_stream(file, flags, NULL);
127 EXPECT_TRUE(read_stream.IsOpen()); 87 EXPECT_TRUE(read_stream.IsOpen());
128 } 88 }
129 89
130 EXPECT_NE(base::kInvalidPlatformFileValue, file); 90 EXPECT_NE(base::kInvalidPlatformFileValue, file);
131 base::PlatformFileInfo info; 91 base::PlatformFileInfo info;
132 // The file should still be open. 92 // The file should be closed.
133 EXPECT_TRUE(base::GetPlatformFileInfo(file, &info)); 93 EXPECT_FALSE(base::GetPlatformFileInfo(file, &info));
134 // Clean up. 94 EXPECT_FALSE(base::ClosePlatformFile(file));
135 EXPECT_TRUE(base::ClosePlatformFile(file));
136 } 95 }
137 96
138 // Test the use of FileStream with a file handle provided at construction. 97 // Test the use of FileStream with a file handle provided at construction.
139 TEST_F(FileStreamTest, UseFileHandle) { 98 TEST_F(FileStreamTest, UseFileHandle) {
140 bool created = false; 99 bool created = false;
141 100
142 // 1. Test reading with a file handle. 101 // 1. Test reading with a file handle.
143 ASSERT_EQ(kTestDataSize, 102 ASSERT_EQ(kTestDataSize,
144 file_util::WriteFile(temp_file_path(), kTestData, kTestDataSize)); 103 file_util::WriteFile(temp_file_path(), kTestData, kTestDataSize));
145 int flags = base::PLATFORM_FILE_OPEN_ALWAYS | base::PLATFORM_FILE_READ; 104 int flags = base::PLATFORM_FILE_OPEN_ALWAYS | base::PLATFORM_FILE_READ;
146 base::PlatformFile file = base::CreatePlatformFile( 105 base::PlatformFile file = base::CreatePlatformFile(
147 temp_file_path(), flags, &created, NULL); 106 temp_file_path(), flags, &created, NULL);
148 107
149 // Seek to the beginning of the file and read. 108 // Seek to the beginning of the file and read.
150 FileStream read_stream(file, flags, NULL); 109 scoped_ptr<FileStream> read_stream(new FileStream(file, flags, NULL));
151 ASSERT_EQ(0, read_stream.SeekSync(FROM_BEGIN, 0)); 110 ASSERT_EQ(0, read_stream->SeekSync(FROM_BEGIN, 0));
152 ASSERT_EQ(kTestDataSize, read_stream.Available()); 111 ASSERT_EQ(kTestDataSize, read_stream->Available());
153 // Read into buffer and compare. 112 // Read into buffer and compare.
154 char buffer[kTestDataSize]; 113 char buffer[kTestDataSize];
155 ASSERT_EQ(kTestDataSize, 114 ASSERT_EQ(kTestDataSize,
156 read_stream.ReadSync(buffer, kTestDataSize)); 115 read_stream->ReadSync(buffer, kTestDataSize));
157 ASSERT_EQ(0, memcmp(kTestData, buffer, kTestDataSize)); 116 ASSERT_EQ(0, memcmp(kTestData, buffer, kTestDataSize));
158 read_stream.CloseSync(); 117 read_stream.reset();
159 118
160 // 2. Test writing with a file handle. 119 // 2. Test writing with a file handle.
161 file_util::Delete(temp_file_path(), false); 120 file_util::Delete(temp_file_path(), false);
162 flags = base::PLATFORM_FILE_OPEN_ALWAYS | base::PLATFORM_FILE_WRITE; 121 flags = base::PLATFORM_FILE_OPEN_ALWAYS | base::PLATFORM_FILE_WRITE;
163 file = base::CreatePlatformFile(temp_file_path(), flags, &created, NULL); 122 file = base::CreatePlatformFile(temp_file_path(), flags, &created, NULL);
164 123
165 FileStream write_stream(file, flags, NULL); 124 scoped_ptr<FileStream> write_stream(new FileStream(file, flags, NULL));
166 ASSERT_EQ(0, write_stream.SeekSync(FROM_BEGIN, 0)); 125 ASSERT_EQ(0, write_stream->SeekSync(FROM_BEGIN, 0));
167 ASSERT_EQ(kTestDataSize, 126 ASSERT_EQ(kTestDataSize,
168 write_stream.WriteSync(kTestData, kTestDataSize)); 127 write_stream->WriteSync(kTestData, kTestDataSize));
169 write_stream.CloseSync(); 128 write_stream.reset();
170 129
171 // Read into buffer and compare to make sure the handle worked fine. 130 // Read into buffer and compare to make sure the handle worked fine.
172 ASSERT_EQ(kTestDataSize, 131 ASSERT_EQ(kTestDataSize,
173 file_util::ReadFile(temp_file_path(), buffer, kTestDataSize)); 132 file_util::ReadFile(temp_file_path(), buffer, kTestDataSize));
174 ASSERT_EQ(0, memcmp(kTestData, buffer, kTestDataSize)); 133 ASSERT_EQ(0, memcmp(kTestData, buffer, kTestDataSize));
175 } 134 }
176 135
177 TEST_F(FileStreamTest, UseClosedStream) { 136 TEST_F(FileStreamTest, UseClosedStream) {
178 FileStream stream(NULL); 137 FileStream stream(NULL);
179 138
(...skipping 71 matching lines...) Expand 10 before | Expand all | Expand 10 after
251 EXPECT_LE(0, rv); 210 EXPECT_LE(0, rv);
252 if (rv <= 0) 211 if (rv <= 0)
253 break; 212 break;
254 total_bytes_read += rv; 213 total_bytes_read += rv;
255 data_read.append(buf->data(), rv); 214 data_read.append(buf->data(), rv);
256 } 215 }
257 EXPECT_EQ(file_size, total_bytes_read); 216 EXPECT_EQ(file_size, total_bytes_read);
258 EXPECT_EQ(kTestData, data_read); 217 EXPECT_EQ(kTestData, data_read);
259 } 218 }
260 219
261 TEST_F(FileStreamTest, AsyncRead_EarlyClose) {
262 int64 file_size;
263 bool ok = file_util::GetFileSize(temp_file_path(), &file_size);
264 EXPECT_TRUE(ok);
265
266 FileStream stream(NULL);
267 int flags = base::PLATFORM_FILE_OPEN |
268 base::PLATFORM_FILE_READ |
269 base::PLATFORM_FILE_ASYNC;
270 int rv = stream.OpenSync(temp_file_path(), flags);
271 EXPECT_EQ(OK, rv);
272
273 int64 total_bytes_avail = stream.Available();
274 EXPECT_EQ(file_size, total_bytes_avail);
275
276 TestCompletionCallback callback;
277
278 scoped_refptr<IOBufferWithSize> buf = new IOBufferWithSize(4);
279 rv = stream.Read(buf, buf->size(), callback.callback());
280 stream.CloseSync();
281 if (rv < 0) {
282 EXPECT_EQ(ERR_IO_PENDING, rv);
283 // The callback should not be called if the request is cancelled.
284 MessageLoop::current()->RunAllPending();
285 EXPECT_FALSE(callback.have_result());
286 } else {
287 EXPECT_EQ(std::string(kTestData, rv), std::string(buf->data(), rv));
288 }
289 }
290
291 // Similar to AsyncRead_EarlyClose but deletes a stream instead, to ensure
292 // that deleting a stream is safe while an async read is in flight.
293 TEST_F(FileStreamTest, AsyncRead_EarlyDelete) { 220 TEST_F(FileStreamTest, AsyncRead_EarlyDelete) {
294 int64 file_size; 221 int64 file_size;
295 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); 222 bool ok = file_util::GetFileSize(temp_file_path(), &file_size);
296 EXPECT_TRUE(ok); 223 EXPECT_TRUE(ok);
297 224
298 scoped_ptr<FileStream> stream(new FileStream(NULL)); 225 scoped_ptr<FileStream> stream(new FileStream(NULL));
299 int flags = base::PLATFORM_FILE_OPEN | 226 int flags = base::PLATFORM_FILE_OPEN |
300 base::PLATFORM_FILE_READ | 227 base::PLATFORM_FILE_READ |
301 base::PLATFORM_FILE_ASYNC; 228 base::PLATFORM_FILE_ASYNC;
302 TestCompletionCallback callback; 229 TestCompletionCallback callback;
(...skipping 10 matching lines...) Expand all
313 if (rv < 0) { 240 if (rv < 0) {
314 EXPECT_EQ(ERR_IO_PENDING, rv); 241 EXPECT_EQ(ERR_IO_PENDING, rv);
315 // The callback should not be called if the request is cancelled. 242 // The callback should not be called if the request is cancelled.
316 MessageLoop::current()->RunAllPending(); 243 MessageLoop::current()->RunAllPending();
317 EXPECT_FALSE(callback.have_result()); 244 EXPECT_FALSE(callback.have_result());
318 } else { 245 } else {
319 EXPECT_EQ(std::string(kTestData, rv), std::string(buf->data(), rv)); 246 EXPECT_EQ(std::string(kTestData, rv), std::string(buf->data(), rv));
320 } 247 }
321 } 248 }
322 249
323 // Similar to AsyncRead_EarlyDelete but using a given file handler rather than
324 // calling FileStream::Open, to ensure that deleting a stream with in-flight
325 // operation without auto-closing feature is also ok.
326 TEST_F(FileStreamTest, AsyncRead_EarlyDelete_NoAutoClose) {
327 int64 file_size;
328 bool ok = file_util::GetFileSize(temp_file_path(), &file_size);
329 EXPECT_TRUE(ok);
330
331 bool created = false;
332 int flags = base::PLATFORM_FILE_OPEN |
333 base::PLATFORM_FILE_READ |
334 base::PLATFORM_FILE_ASYNC;
335 base::PlatformFileError error_code = base::PLATFORM_FILE_ERROR_FAILED;
336 base::PlatformFile file = base::CreatePlatformFile(
337 temp_file_path(), flags, &created, &error_code);
338 EXPECT_EQ(base::PLATFORM_FILE_OK, error_code);
339
340 scoped_ptr<FileStream> stream(new FileStream(file, flags, NULL));
341 int64 total_bytes_avail = stream->Available();
342 EXPECT_EQ(file_size, total_bytes_avail);
343
344 TestCompletionCallback callback;
345 scoped_refptr<IOBufferWithSize> buf = new IOBufferWithSize(4);
346 int rv = stream->Read(buf, buf->size(), callback.callback());
347 stream.reset(); // Delete instead of closing it.
348 if (rv < 0) {
349 EXPECT_EQ(ERR_IO_PENDING, rv);
350 // The callback should not be called if the request is cancelled.
351 MessageLoop::current()->RunAllPending();
352 EXPECT_FALSE(callback.have_result());
353 } else {
354 EXPECT_EQ(std::string(kTestData, rv), std::string(buf->data(), rv));
355 }
356
357 base::PlatformFileInfo info;
358 // The file should still be open.
359 EXPECT_TRUE(base::GetPlatformFileInfo(file, &info));
360 // Clean up.
361 EXPECT_TRUE(base::ClosePlatformFile(file));
362 }
363
364 TEST_F(FileStreamTest, BasicRead_FromOffset) { 250 TEST_F(FileStreamTest, BasicRead_FromOffset) {
365 int64 file_size; 251 int64 file_size;
366 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); 252 bool ok = file_util::GetFileSize(temp_file_path(), &file_size);
367 EXPECT_TRUE(ok); 253 EXPECT_TRUE(ok);
368 254
369 FileStream stream(NULL); 255 FileStream stream(NULL);
370 int flags = base::PLATFORM_FILE_OPEN | 256 int flags = base::PLATFORM_FILE_OPEN |
371 base::PLATFORM_FILE_READ; 257 base::PLATFORM_FILE_READ;
372 int rv = stream.OpenSync(temp_file_path(), flags); 258 int rv = stream.OpenSync(temp_file_path(), flags);
373 EXPECT_EQ(OK, rv); 259 EXPECT_EQ(OK, rv);
(...skipping 115 matching lines...) Expand 10 before | Expand all | Expand 10 after
489 375
490 const int kTestDataLen = arraysize(kTestData) - 1; 376 const int kTestDataLen = arraysize(kTestData) - 1;
491 377
492 rv = stream.Seek(FROM_END, -kTestDataLen, callback.callback()); 378 rv = stream.Seek(FROM_END, -kTestDataLen, callback.callback());
493 ASSERT_EQ(ERR_IO_PENDING, rv); 379 ASSERT_EQ(ERR_IO_PENDING, rv);
494 new_offset = callback.WaitForResult(); 380 new_offset = callback.WaitForResult();
495 EXPECT_EQ(0, new_offset); 381 EXPECT_EQ(0, new_offset);
496 } 382 }
497 383
498 TEST_F(FileStreamTest, BasicWrite) { 384 TEST_F(FileStreamTest, BasicWrite) {
499 FileStream stream(NULL); 385 scoped_ptr<FileStream> stream(new FileStream(NULL));
500 int flags = base::PLATFORM_FILE_CREATE_ALWAYS | 386 int flags = base::PLATFORM_FILE_CREATE_ALWAYS |
501 base::PLATFORM_FILE_WRITE; 387 base::PLATFORM_FILE_WRITE;
502 int rv = stream.OpenSync(temp_file_path(), flags); 388 int rv = stream->OpenSync(temp_file_path(), flags);
503 EXPECT_EQ(OK, rv); 389 EXPECT_EQ(OK, rv);
504 390
505 int64 file_size; 391 int64 file_size;
506 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); 392 bool ok = file_util::GetFileSize(temp_file_path(), &file_size);
507 EXPECT_TRUE(ok); 393 EXPECT_TRUE(ok);
508 EXPECT_EQ(0, file_size); 394 EXPECT_EQ(0, file_size);
509 395
510 rv = stream.WriteSync(kTestData, kTestDataSize); 396 rv = stream->WriteSync(kTestData, kTestDataSize);
511 EXPECT_EQ(kTestDataSize, rv); 397 EXPECT_EQ(kTestDataSize, rv);
512 stream.CloseSync(); 398 stream.reset();
513 399
514 ok = file_util::GetFileSize(temp_file_path(), &file_size); 400 ok = file_util::GetFileSize(temp_file_path(), &file_size);
515 EXPECT_TRUE(ok); 401 EXPECT_TRUE(ok);
516 EXPECT_EQ(kTestDataSize, file_size); 402 EXPECT_EQ(kTestDataSize, file_size);
517 } 403 }
518 404
519 TEST_F(FileStreamTest, AsyncWrite) { 405 TEST_F(FileStreamTest, AsyncWrite) {
520 FileStream stream(NULL); 406 FileStream stream(NULL);
521 int flags = base::PLATFORM_FILE_CREATE_ALWAYS | 407 int flags = base::PLATFORM_FILE_CREATE_ALWAYS |
522 base::PLATFORM_FILE_WRITE | 408 base::PLATFORM_FILE_WRITE |
(...skipping 21 matching lines...) Expand all
544 if (rv <= 0) 430 if (rv <= 0)
545 break; 431 break;
546 drainable->DidConsume(rv); 432 drainable->DidConsume(rv);
547 total_bytes_written += rv; 433 total_bytes_written += rv;
548 } 434 }
549 ok = file_util::GetFileSize(temp_file_path(), &file_size); 435 ok = file_util::GetFileSize(temp_file_path(), &file_size);
550 EXPECT_TRUE(ok); 436 EXPECT_TRUE(ok);
551 EXPECT_EQ(file_size, total_bytes_written); 437 EXPECT_EQ(file_size, total_bytes_written);
552 } 438 }
553 439
554 TEST_F(FileStreamTest, AsyncWrite_EarlyClose) { 440 TEST_F(FileStreamTest, AsyncWrite_EarlyDelete) {
555 FileStream stream(NULL); 441 scoped_ptr<FileStream> stream(new FileStream(NULL));
556 int flags = base::PLATFORM_FILE_CREATE_ALWAYS | 442 int flags = base::PLATFORM_FILE_CREATE_ALWAYS |
557 base::PLATFORM_FILE_WRITE | 443 base::PLATFORM_FILE_WRITE |
558 base::PLATFORM_FILE_ASYNC; 444 base::PLATFORM_FILE_ASYNC;
559 int rv = stream.OpenSync(temp_file_path(), flags); 445 int rv = stream->OpenSync(temp_file_path(), flags);
560 EXPECT_EQ(OK, rv); 446 EXPECT_EQ(OK, rv);
561 447
562 int64 file_size; 448 int64 file_size;
563 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); 449 bool ok = file_util::GetFileSize(temp_file_path(), &file_size);
564 EXPECT_TRUE(ok); 450 EXPECT_TRUE(ok);
565 EXPECT_EQ(0, file_size); 451 EXPECT_EQ(0, file_size);
566 452
567 TestCompletionCallback callback; 453 TestCompletionCallback callback;
568 454
569 scoped_refptr<IOBufferWithSize> buf = CreateTestDataBuffer(); 455 scoped_refptr<IOBufferWithSize> buf = CreateTestDataBuffer();
570 rv = stream.Write(buf, buf->size(), callback.callback()); 456 rv = stream->Write(buf, buf->size(), callback.callback());
571 stream.CloseSync(); 457 stream.reset();
572 if (rv < 0) { 458 if (rv < 0) {
573 EXPECT_EQ(ERR_IO_PENDING, rv); 459 EXPECT_EQ(ERR_IO_PENDING, rv);
574 // The callback should not be called if the request is cancelled. 460 // The callback should not be called if the request is cancelled.
575 MessageLoop::current()->RunAllPending(); 461 MessageLoop::current()->RunAllPending();
576 EXPECT_FALSE(callback.have_result()); 462 EXPECT_FALSE(callback.have_result());
577 } else { 463 } else {
578 ok = file_util::GetFileSize(temp_file_path(), &file_size); 464 ok = file_util::GetFileSize(temp_file_path(), &file_size);
579 EXPECT_TRUE(ok); 465 EXPECT_TRUE(ok);
580 EXPECT_EQ(file_size, rv); 466 EXPECT_EQ(file_size, rv);
581 } 467 }
582 } 468 }
583 469
584 TEST_F(FileStreamTest, BasicWrite_FromOffset) { 470 TEST_F(FileStreamTest, BasicWrite_FromOffset) {
585 FileStream stream(NULL); 471 scoped_ptr<FileStream> stream(new FileStream(NULL));
586 int flags = base::PLATFORM_FILE_OPEN | 472 int flags = base::PLATFORM_FILE_OPEN |
587 base::PLATFORM_FILE_WRITE; 473 base::PLATFORM_FILE_WRITE;
588 int rv = stream.OpenSync(temp_file_path(), flags); 474 int rv = stream->OpenSync(temp_file_path(), flags);
589 EXPECT_EQ(OK, rv); 475 EXPECT_EQ(OK, rv);
590 476
591 int64 file_size; 477 int64 file_size;
592 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); 478 bool ok = file_util::GetFileSize(temp_file_path(), &file_size);
593 EXPECT_TRUE(ok); 479 EXPECT_TRUE(ok);
594 EXPECT_EQ(kTestDataSize, file_size); 480 EXPECT_EQ(kTestDataSize, file_size);
595 481
596 const int64 kOffset = 0; 482 const int64 kOffset = 0;
597 int64 new_offset = stream.SeekSync(FROM_END, kOffset); 483 int64 new_offset = stream->SeekSync(FROM_END, kOffset);
598 EXPECT_EQ(kTestDataSize, new_offset); 484 EXPECT_EQ(kTestDataSize, new_offset);
599 485
600 rv = stream.WriteSync(kTestData, kTestDataSize); 486 rv = stream->WriteSync(kTestData, kTestDataSize);
601 EXPECT_EQ(kTestDataSize, rv); 487 EXPECT_EQ(kTestDataSize, rv);
602 stream.CloseSync(); 488 stream.reset();
603 489
604 ok = file_util::GetFileSize(temp_file_path(), &file_size); 490 ok = file_util::GetFileSize(temp_file_path(), &file_size);
605 EXPECT_TRUE(ok); 491 EXPECT_TRUE(ok);
606 EXPECT_EQ(kTestDataSize * 2, file_size); 492 EXPECT_EQ(kTestDataSize * 2, file_size);
607 } 493 }
608 494
609 TEST_F(FileStreamTest, AsyncWrite_FromOffset) { 495 TEST_F(FileStreamTest, AsyncWrite_FromOffset) {
610 int64 file_size; 496 int64 file_size;
611 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); 497 bool ok = file_util::GetFileSize(temp_file_path(), &file_size);
612 EXPECT_TRUE(ok); 498 EXPECT_TRUE(ok);
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after
645 ok = file_util::GetFileSize(temp_file_path(), &file_size); 531 ok = file_util::GetFileSize(temp_file_path(), &file_size);
646 EXPECT_TRUE(ok); 532 EXPECT_TRUE(ok);
647 EXPECT_EQ(file_size, kTestDataSize * 2); 533 EXPECT_EQ(file_size, kTestDataSize * 2);
648 } 534 }
649 535
650 TEST_F(FileStreamTest, BasicReadWrite) { 536 TEST_F(FileStreamTest, BasicReadWrite) {
651 int64 file_size; 537 int64 file_size;
652 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); 538 bool ok = file_util::GetFileSize(temp_file_path(), &file_size);
653 EXPECT_TRUE(ok); 539 EXPECT_TRUE(ok);
654 540
655 FileStream stream(NULL); 541 scoped_ptr<FileStream> stream(new FileStream(NULL));
656 int flags = base::PLATFORM_FILE_OPEN | 542 int flags = base::PLATFORM_FILE_OPEN |
657 base::PLATFORM_FILE_READ | 543 base::PLATFORM_FILE_READ |
658 base::PLATFORM_FILE_WRITE; 544 base::PLATFORM_FILE_WRITE;
659 int rv = stream.OpenSync(temp_file_path(), flags); 545 int rv = stream->OpenSync(temp_file_path(), flags);
660 EXPECT_EQ(OK, rv); 546 EXPECT_EQ(OK, rv);
661 547
662 int64 total_bytes_avail = stream.Available(); 548 int64 total_bytes_avail = stream->Available();
663 EXPECT_EQ(file_size, total_bytes_avail); 549 EXPECT_EQ(file_size, total_bytes_avail);
664 550
665 int total_bytes_read = 0; 551 int total_bytes_read = 0;
666 552
667 std::string data_read; 553 std::string data_read;
668 for (;;) { 554 for (;;) {
669 char buf[4]; 555 char buf[4];
670 rv = stream.ReadSync(buf, arraysize(buf)); 556 rv = stream->ReadSync(buf, arraysize(buf));
671 EXPECT_LE(0, rv); 557 EXPECT_LE(0, rv);
672 if (rv <= 0) 558 if (rv <= 0)
673 break; 559 break;
674 total_bytes_read += rv; 560 total_bytes_read += rv;
675 data_read.append(buf, rv); 561 data_read.append(buf, rv);
676 } 562 }
677 EXPECT_EQ(file_size, total_bytes_read); 563 EXPECT_EQ(file_size, total_bytes_read);
678 EXPECT_TRUE(data_read == kTestData); 564 EXPECT_TRUE(data_read == kTestData);
679 565
680 rv = stream.WriteSync(kTestData, kTestDataSize); 566 rv = stream->WriteSync(kTestData, kTestDataSize);
681 EXPECT_EQ(kTestDataSize, rv); 567 EXPECT_EQ(kTestDataSize, rv);
682 stream.CloseSync(); 568 stream.reset();
683 569
684 ok = file_util::GetFileSize(temp_file_path(), &file_size); 570 ok = file_util::GetFileSize(temp_file_path(), &file_size);
685 EXPECT_TRUE(ok); 571 EXPECT_TRUE(ok);
686 EXPECT_EQ(kTestDataSize * 2, file_size); 572 EXPECT_EQ(kTestDataSize * 2, file_size);
687 } 573 }
688 574
689 TEST_F(FileStreamTest, BasicWriteRead) { 575 TEST_F(FileStreamTest, BasicWriteRead) {
690 int64 file_size; 576 int64 file_size;
691 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); 577 bool ok = file_util::GetFileSize(temp_file_path(), &file_size);
692 EXPECT_TRUE(ok); 578 EXPECT_TRUE(ok);
693 579
694 FileStream stream(NULL); 580 scoped_ptr<FileStream> stream(new FileStream(NULL));
695 int flags = base::PLATFORM_FILE_OPEN | 581 int flags = base::PLATFORM_FILE_OPEN |
696 base::PLATFORM_FILE_READ | 582 base::PLATFORM_FILE_READ |
697 base::PLATFORM_FILE_WRITE; 583 base::PLATFORM_FILE_WRITE;
698 int rv = stream.OpenSync(temp_file_path(), flags); 584 int rv = stream->OpenSync(temp_file_path(), flags);
699 EXPECT_EQ(OK, rv); 585 EXPECT_EQ(OK, rv);
700 586
701 int64 total_bytes_avail = stream.Available(); 587 int64 total_bytes_avail = stream->Available();
702 EXPECT_EQ(file_size, total_bytes_avail); 588 EXPECT_EQ(file_size, total_bytes_avail);
703 589
704 int64 offset = stream.SeekSync(FROM_END, 0); 590 int64 offset = stream->SeekSync(FROM_END, 0);
705 EXPECT_EQ(offset, file_size); 591 EXPECT_EQ(offset, file_size);
706 592
707 rv = stream.WriteSync(kTestData, kTestDataSize); 593 rv = stream->WriteSync(kTestData, kTestDataSize);
708 EXPECT_EQ(kTestDataSize, rv); 594 EXPECT_EQ(kTestDataSize, rv);
709 595
710 offset = stream.SeekSync(FROM_BEGIN, 0); 596 offset = stream->SeekSync(FROM_BEGIN, 0);
711 EXPECT_EQ(0, offset); 597 EXPECT_EQ(0, offset);
712 598
713 int64 total_bytes_read = 0; 599 int64 total_bytes_read = 0;
714 600
715 std::string data_read; 601 std::string data_read;
716 for (;;) { 602 for (;;) {
717 char buf[4]; 603 char buf[4];
718 rv = stream.ReadSync(buf, arraysize(buf)); 604 rv = stream->ReadSync(buf, arraysize(buf));
719 EXPECT_LE(0, rv); 605 EXPECT_LE(0, rv);
720 if (rv <= 0) 606 if (rv <= 0)
721 break; 607 break;
722 total_bytes_read += rv; 608 total_bytes_read += rv;
723 data_read.append(buf, rv); 609 data_read.append(buf, rv);
724 } 610 }
725 stream.CloseSync(); 611 stream.reset();
726 612
727 ok = file_util::GetFileSize(temp_file_path(), &file_size); 613 ok = file_util::GetFileSize(temp_file_path(), &file_size);
728 EXPECT_TRUE(ok); 614 EXPECT_TRUE(ok);
729 EXPECT_EQ(kTestDataSize * 2, file_size); 615 EXPECT_EQ(kTestDataSize * 2, file_size);
730 EXPECT_EQ(kTestDataSize * 2, total_bytes_read); 616 EXPECT_EQ(kTestDataSize * 2, total_bytes_read);
731 617
732 const std::string kExpectedFileData = 618 const std::string kExpectedFileData =
733 std::string(kTestData) + std::string(kTestData); 619 std::string(kTestData) + std::string(kTestData);
734 EXPECT_EQ(kExpectedFileData, data_read); 620 EXPECT_EQ(kExpectedFileData, data_read);
735 } 621 }
736 622
737 TEST_F(FileStreamTest, BasicAsyncReadWrite) { 623 TEST_F(FileStreamTest, BasicAsyncReadWrite) {
738 int64 file_size; 624 int64 file_size;
739 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); 625 bool ok = file_util::GetFileSize(temp_file_path(), &file_size);
740 EXPECT_TRUE(ok); 626 EXPECT_TRUE(ok);
741 627
742 FileStream stream(NULL); 628 scoped_ptr<FileStream> stream(new FileStream(NULL));
743 int flags = base::PLATFORM_FILE_OPEN | 629 int flags = base::PLATFORM_FILE_OPEN |
744 base::PLATFORM_FILE_READ | 630 base::PLATFORM_FILE_READ |
745 base::PLATFORM_FILE_WRITE | 631 base::PLATFORM_FILE_WRITE |
746 base::PLATFORM_FILE_ASYNC; 632 base::PLATFORM_FILE_ASYNC;
747 int rv = stream.OpenSync(temp_file_path(), flags); 633 int rv = stream->OpenSync(temp_file_path(), flags);
748 EXPECT_EQ(OK, rv); 634 EXPECT_EQ(OK, rv);
749 635
750 int64 total_bytes_avail = stream.Available(); 636 int64 total_bytes_avail = stream->Available();
751 EXPECT_EQ(file_size, total_bytes_avail); 637 EXPECT_EQ(file_size, total_bytes_avail);
752 638
753 TestCompletionCallback callback; 639 TestCompletionCallback callback;
754 int64 total_bytes_read = 0; 640 int64 total_bytes_read = 0;
755 641
756 std::string data_read; 642 std::string data_read;
757 for (;;) { 643 for (;;) {
758 scoped_refptr<IOBufferWithSize> buf = new IOBufferWithSize(4); 644 scoped_refptr<IOBufferWithSize> buf = new IOBufferWithSize(4);
759 rv = stream.Read(buf, buf->size(), callback.callback()); 645 rv = stream->Read(buf, buf->size(), callback.callback());
760 if (rv == ERR_IO_PENDING) 646 if (rv == ERR_IO_PENDING)
761 rv = callback.WaitForResult(); 647 rv = callback.WaitForResult();
762 EXPECT_LE(0, rv); 648 EXPECT_LE(0, rv);
763 if (rv <= 0) 649 if (rv <= 0)
764 break; 650 break;
765 total_bytes_read += rv; 651 total_bytes_read += rv;
766 data_read.append(buf->data(), rv); 652 data_read.append(buf->data(), rv);
767 } 653 }
768 EXPECT_EQ(file_size, total_bytes_read); 654 EXPECT_EQ(file_size, total_bytes_read);
769 EXPECT_TRUE(data_read == kTestData); 655 EXPECT_TRUE(data_read == kTestData);
770 656
771 int total_bytes_written = 0; 657 int total_bytes_written = 0;
772 658
773 scoped_refptr<IOBufferWithSize> buf = CreateTestDataBuffer(); 659 scoped_refptr<IOBufferWithSize> buf = CreateTestDataBuffer();
774 scoped_refptr<DrainableIOBuffer> drainable = 660 scoped_refptr<DrainableIOBuffer> drainable =
775 new DrainableIOBuffer(buf, buf->size()); 661 new DrainableIOBuffer(buf, buf->size());
776 while (total_bytes_written != kTestDataSize) { 662 while (total_bytes_written != kTestDataSize) {
777 rv = stream.Write(drainable, drainable->BytesRemaining(), 663 rv = stream->Write(drainable, drainable->BytesRemaining(),
778 callback.callback()); 664 callback.callback());
779 if (rv == ERR_IO_PENDING) 665 if (rv == ERR_IO_PENDING)
780 rv = callback.WaitForResult(); 666 rv = callback.WaitForResult();
781 EXPECT_LT(0, rv); 667 EXPECT_LT(0, rv);
782 if (rv <= 0) 668 if (rv <= 0)
783 break; 669 break;
784 drainable->DidConsume(rv); 670 drainable->DidConsume(rv);
785 total_bytes_written += rv; 671 total_bytes_written += rv;
786 } 672 }
787 673
788 stream.CloseSync(); 674 stream.reset();
789 675
790 ok = file_util::GetFileSize(temp_file_path(), &file_size); 676 ok = file_util::GetFileSize(temp_file_path(), &file_size);
791 EXPECT_TRUE(ok); 677 EXPECT_TRUE(ok);
792 EXPECT_EQ(kTestDataSize * 2, file_size); 678 EXPECT_EQ(kTestDataSize * 2, file_size);
793 } 679 }
794 680
795 TEST_F(FileStreamTest, BasicAsyncWriteRead) { 681 TEST_F(FileStreamTest, BasicAsyncWriteRead) {
796 int64 file_size; 682 int64 file_size;
797 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); 683 bool ok = file_util::GetFileSize(temp_file_path(), &file_size);
798 EXPECT_TRUE(ok); 684 EXPECT_TRUE(ok);
799 685
800 FileStream stream(NULL); 686 scoped_ptr<FileStream> stream(new FileStream(NULL));
801 int flags = base::PLATFORM_FILE_OPEN | 687 int flags = base::PLATFORM_FILE_OPEN |
802 base::PLATFORM_FILE_READ | 688 base::PLATFORM_FILE_READ |
803 base::PLATFORM_FILE_WRITE | 689 base::PLATFORM_FILE_WRITE |
804 base::PLATFORM_FILE_ASYNC; 690 base::PLATFORM_FILE_ASYNC;
805 int rv = stream.OpenSync(temp_file_path(), flags); 691 int rv = stream->OpenSync(temp_file_path(), flags);
806 EXPECT_EQ(OK, rv); 692 EXPECT_EQ(OK, rv);
807 693
808 int64 total_bytes_avail = stream.Available(); 694 int64 total_bytes_avail = stream->Available();
809 EXPECT_EQ(file_size, total_bytes_avail); 695 EXPECT_EQ(file_size, total_bytes_avail);
810 696
811 TestInt64CompletionCallback callback64; 697 TestInt64CompletionCallback callback64;
812 rv = stream.Seek(FROM_END, 0, callback64.callback()); 698 rv = stream->Seek(FROM_END, 0, callback64.callback());
813 ASSERT_EQ(ERR_IO_PENDING, rv); 699 ASSERT_EQ(ERR_IO_PENDING, rv);
814 int64 offset = callback64.WaitForResult(); 700 int64 offset = callback64.WaitForResult();
815 EXPECT_EQ(offset, file_size); 701 EXPECT_EQ(offset, file_size);
816 702
817 TestCompletionCallback callback; 703 TestCompletionCallback callback;
818 int total_bytes_written = 0; 704 int total_bytes_written = 0;
819 705
820 scoped_refptr<IOBufferWithSize> buf = CreateTestDataBuffer(); 706 scoped_refptr<IOBufferWithSize> buf = CreateTestDataBuffer();
821 scoped_refptr<DrainableIOBuffer> drainable = 707 scoped_refptr<DrainableIOBuffer> drainable =
822 new DrainableIOBuffer(buf, buf->size()); 708 new DrainableIOBuffer(buf, buf->size());
823 while (total_bytes_written != kTestDataSize) { 709 while (total_bytes_written != kTestDataSize) {
824 rv = stream.Write(drainable, drainable->BytesRemaining(), 710 rv = stream->Write(drainable, drainable->BytesRemaining(),
825 callback.callback()); 711 callback.callback());
826 if (rv == ERR_IO_PENDING) 712 if (rv == ERR_IO_PENDING)
827 rv = callback.WaitForResult(); 713 rv = callback.WaitForResult();
828 EXPECT_LT(0, rv); 714 EXPECT_LT(0, rv);
829 if (rv <= 0) 715 if (rv <= 0)
830 break; 716 break;
831 drainable->DidConsume(rv); 717 drainable->DidConsume(rv);
832 total_bytes_written += rv; 718 total_bytes_written += rv;
833 } 719 }
834 720
835 EXPECT_EQ(kTestDataSize, total_bytes_written); 721 EXPECT_EQ(kTestDataSize, total_bytes_written);
836 722
837 rv = stream.Seek(FROM_BEGIN, 0, callback64.callback()); 723 rv = stream->Seek(FROM_BEGIN, 0, callback64.callback());
838 ASSERT_EQ(ERR_IO_PENDING, rv); 724 ASSERT_EQ(ERR_IO_PENDING, rv);
839 offset = callback64.WaitForResult(); 725 offset = callback64.WaitForResult();
840 EXPECT_EQ(0, offset); 726 EXPECT_EQ(0, offset);
841 727
842 int total_bytes_read = 0; 728 int total_bytes_read = 0;
843 729
844 std::string data_read; 730 std::string data_read;
845 for (;;) { 731 for (;;) {
846 scoped_refptr<IOBufferWithSize> buf = new IOBufferWithSize(4); 732 scoped_refptr<IOBufferWithSize> buf = new IOBufferWithSize(4);
847 rv = stream.Read(buf, buf->size(), callback.callback()); 733 rv = stream->Read(buf, buf->size(), callback.callback());
848 if (rv == ERR_IO_PENDING) 734 if (rv == ERR_IO_PENDING)
849 rv = callback.WaitForResult(); 735 rv = callback.WaitForResult();
850 EXPECT_LE(0, rv); 736 EXPECT_LE(0, rv);
851 if (rv <= 0) 737 if (rv <= 0)
852 break; 738 break;
853 total_bytes_read += rv; 739 total_bytes_read += rv;
854 data_read.append(buf->data(), rv); 740 data_read.append(buf->data(), rv);
855 } 741 }
856 stream.CloseSync(); 742 stream.reset();
857 743
858 ok = file_util::GetFileSize(temp_file_path(), &file_size); 744 ok = file_util::GetFileSize(temp_file_path(), &file_size);
859 EXPECT_TRUE(ok); 745 EXPECT_TRUE(ok);
860 EXPECT_EQ(kTestDataSize * 2, file_size); 746 EXPECT_EQ(kTestDataSize * 2, file_size);
861 747
862 EXPECT_EQ(kTestDataSize * 2, total_bytes_read); 748 EXPECT_EQ(kTestDataSize * 2, total_bytes_read);
863 const std::string kExpectedFileData = 749 const std::string kExpectedFileData =
864 std::string(kTestData) + std::string(kTestData); 750 std::string(kTestData) + std::string(kTestData);
865 EXPECT_EQ(kExpectedFileData, data_read); 751 EXPECT_EQ(kExpectedFileData, data_read);
866 } 752 }
(...skipping 89 matching lines...) Expand 10 before | Expand all | Expand 10 after
956 scoped_refptr<DrainableIOBuffer> drainable_; 842 scoped_refptr<DrainableIOBuffer> drainable_;
957 843
958 DISALLOW_COPY_AND_ASSIGN(TestWriteReadCompletionCallback); 844 DISALLOW_COPY_AND_ASSIGN(TestWriteReadCompletionCallback);
959 }; 845 };
960 846
961 TEST_F(FileStreamTest, AsyncWriteRead) { 847 TEST_F(FileStreamTest, AsyncWriteRead) {
962 int64 file_size; 848 int64 file_size;
963 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); 849 bool ok = file_util::GetFileSize(temp_file_path(), &file_size);
964 EXPECT_TRUE(ok); 850 EXPECT_TRUE(ok);
965 851
966 FileStream stream(NULL); 852 scoped_ptr<FileStream> stream(new FileStream(NULL));
967 int flags = base::PLATFORM_FILE_OPEN | 853 int flags = base::PLATFORM_FILE_OPEN |
968 base::PLATFORM_FILE_READ | 854 base::PLATFORM_FILE_READ |
969 base::PLATFORM_FILE_WRITE | 855 base::PLATFORM_FILE_WRITE |
970 base::PLATFORM_FILE_ASYNC; 856 base::PLATFORM_FILE_ASYNC;
971 int rv = stream.OpenSync(temp_file_path(), flags); 857 int rv = stream->OpenSync(temp_file_path(), flags);
972 EXPECT_EQ(OK, rv); 858 EXPECT_EQ(OK, rv);
973 859
974 int64 total_bytes_avail = stream.Available(); 860 int64 total_bytes_avail = stream->Available();
975 EXPECT_EQ(file_size, total_bytes_avail); 861 EXPECT_EQ(file_size, total_bytes_avail);
976 862
977 int64 offset = stream.SeekSync(FROM_END, 0); 863 int64 offset = stream->SeekSync(FROM_END, 0);
978 EXPECT_EQ(offset, file_size); 864 EXPECT_EQ(offset, file_size);
979 865
980 int total_bytes_written = 0; 866 int total_bytes_written = 0;
981 int total_bytes_read = 0; 867 int total_bytes_read = 0;
982 std::string data_read; 868 std::string data_read;
983 TestWriteReadCompletionCallback callback(&stream, &total_bytes_written, 869 TestWriteReadCompletionCallback callback(stream.get(), &total_bytes_written,
984 &total_bytes_read, &data_read); 870 &total_bytes_read, &data_read);
985 871
986 scoped_refptr<IOBufferWithSize> buf = CreateTestDataBuffer(); 872 scoped_refptr<IOBufferWithSize> buf = CreateTestDataBuffer();
987 rv = stream.Write(buf, buf->size(), callback.callback()); 873 rv = stream->Write(buf, buf->size(), callback.callback());
988 if (rv == ERR_IO_PENDING) 874 if (rv == ERR_IO_PENDING)
989 rv = callback.WaitForResult(); 875 rv = callback.WaitForResult();
990 EXPECT_LT(0, rv); 876 EXPECT_LT(0, rv);
991 EXPECT_EQ(kTestDataSize, total_bytes_written); 877 EXPECT_EQ(kTestDataSize, total_bytes_written);
992 878
993 stream.CloseSync(); 879 stream.reset();
994 880
995 ok = file_util::GetFileSize(temp_file_path(), &file_size); 881 ok = file_util::GetFileSize(temp_file_path(), &file_size);
996 EXPECT_TRUE(ok); 882 EXPECT_TRUE(ok);
997 EXPECT_EQ(kTestDataSize * 2, file_size); 883 EXPECT_EQ(kTestDataSize * 2, file_size);
998 884
999 EXPECT_EQ(kTestDataSize * 2, total_bytes_read); 885 EXPECT_EQ(kTestDataSize * 2, total_bytes_read);
1000 const std::string kExpectedFileData = 886 const std::string kExpectedFileData =
1001 std::string(kTestData) + std::string(kTestData); 887 std::string(kTestData) + std::string(kTestData);
1002 EXPECT_EQ(kExpectedFileData, data_read); 888 EXPECT_EQ(kExpectedFileData, data_read);
1003 } 889 }
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after
1039 if (*total_bytes_written_ != kTestDataSize) { 925 if (*total_bytes_written_ != kTestDataSize) {
1040 // Recurse to finish writing all data. 926 // Recurse to finish writing all data.
1041 int total_bytes_written = 0; 927 int total_bytes_written = 0;
1042 TestWriteCloseCompletionCallback callback(stream_, &total_bytes_written); 928 TestWriteCloseCompletionCallback callback(stream_, &total_bytes_written);
1043 rv = stream_->Write(drainable_, drainable_->BytesRemaining(), 929 rv = stream_->Write(drainable_, drainable_->BytesRemaining(),
1044 callback.callback()); 930 callback.callback());
1045 DCHECK_EQ(ERR_IO_PENDING, rv); 931 DCHECK_EQ(ERR_IO_PENDING, rv);
1046 rv = callback.WaitForResult(); 932 rv = callback.WaitForResult();
1047 drainable_->DidConsume(total_bytes_written); 933 drainable_->DidConsume(total_bytes_written);
1048 *total_bytes_written_ += total_bytes_written; 934 *total_bytes_written_ += total_bytes_written;
1049 } else { // We're done writing all data. Close the file.
1050 stream_->CloseSync();
1051 } 935 }
1052 936
1053 result_ = *total_bytes_written_; 937 result_ = *total_bytes_written_;
1054 have_result_ = true; 938 have_result_ = true;
1055 if (waiting_for_result_) 939 if (waiting_for_result_)
1056 MessageLoop::current()->Quit(); 940 MessageLoop::current()->Quit();
1057 } 941 }
1058 942
1059 int result_; 943 int result_;
1060 bool have_result_; 944 bool have_result_;
1061 bool waiting_for_result_; 945 bool waiting_for_result_;
1062 FileStream* stream_; 946 FileStream* stream_;
1063 int* total_bytes_written_; 947 int* total_bytes_written_;
1064 const CompletionCallback callback_; 948 const CompletionCallback callback_;
1065 scoped_refptr<IOBufferWithSize> test_data_; 949 scoped_refptr<IOBufferWithSize> test_data_;
1066 scoped_refptr<DrainableIOBuffer> drainable_; 950 scoped_refptr<DrainableIOBuffer> drainable_;
1067 951
1068 DISALLOW_COPY_AND_ASSIGN(TestWriteCloseCompletionCallback); 952 DISALLOW_COPY_AND_ASSIGN(TestWriteCloseCompletionCallback);
1069 }; 953 };
1070 954
1071 TEST_F(FileStreamTest, AsyncWriteClose) { 955 TEST_F(FileStreamTest, AsyncWriteClose) {
1072 int64 file_size; 956 int64 file_size;
1073 bool ok = file_util::GetFileSize(temp_file_path(), &file_size); 957 bool ok = file_util::GetFileSize(temp_file_path(), &file_size);
1074 EXPECT_TRUE(ok); 958 EXPECT_TRUE(ok);
1075 959
1076 FileStream stream(NULL); 960 scoped_ptr<FileStream> stream(new FileStream(NULL));
1077 int flags = base::PLATFORM_FILE_OPEN | 961 int flags = base::PLATFORM_FILE_OPEN |
1078 base::PLATFORM_FILE_READ | 962 base::PLATFORM_FILE_READ |
1079 base::PLATFORM_FILE_WRITE | 963 base::PLATFORM_FILE_WRITE |
1080 base::PLATFORM_FILE_ASYNC; 964 base::PLATFORM_FILE_ASYNC;
1081 int rv = stream.OpenSync(temp_file_path(), flags); 965 int rv = stream->OpenSync(temp_file_path(), flags);
1082 EXPECT_EQ(OK, rv); 966 EXPECT_EQ(OK, rv);
1083 967
1084 int64 total_bytes_avail = stream.Available(); 968 int64 total_bytes_avail = stream->Available();
1085 EXPECT_EQ(file_size, total_bytes_avail); 969 EXPECT_EQ(file_size, total_bytes_avail);
1086 970
1087 int64 offset = stream.SeekSync(FROM_END, 0); 971 int64 offset = stream->SeekSync(FROM_END, 0);
1088 EXPECT_EQ(offset, file_size); 972 EXPECT_EQ(offset, file_size);
1089 973
1090 int total_bytes_written = 0; 974 int total_bytes_written = 0;
1091 TestWriteCloseCompletionCallback callback(&stream, &total_bytes_written); 975 TestWriteCloseCompletionCallback callback(stream.get(), &total_bytes_written);
1092 976
1093 scoped_refptr<IOBufferWithSize> buf = CreateTestDataBuffer(); 977 scoped_refptr<IOBufferWithSize> buf = CreateTestDataBuffer();
1094 rv = stream.Write(buf, buf->size(), callback.callback()); 978 rv = stream->Write(buf, buf->size(), callback.callback());
1095 if (rv == ERR_IO_PENDING) 979 if (rv == ERR_IO_PENDING)
1096 total_bytes_written = callback.WaitForResult(); 980 total_bytes_written = callback.WaitForResult();
1097 EXPECT_LT(0, total_bytes_written); 981 EXPECT_LT(0, total_bytes_written);
1098 EXPECT_EQ(kTestDataSize, total_bytes_written); 982 EXPECT_EQ(kTestDataSize, total_bytes_written);
1099 983
984 stream.reset();
985
1100 ok = file_util::GetFileSize(temp_file_path(), &file_size); 986 ok = file_util::GetFileSize(temp_file_path(), &file_size);
1101 EXPECT_TRUE(ok); 987 EXPECT_TRUE(ok);
1102 EXPECT_EQ(kTestDataSize * 2, file_size); 988 EXPECT_EQ(kTestDataSize * 2, file_size);
1103 } 989 }
1104 990
1105 // Tests truncating a file. 991 // Tests truncating a file.
1106 TEST_F(FileStreamTest, Truncate) { 992 TEST_F(FileStreamTest, Truncate) {
1107 int flags = base::PLATFORM_FILE_CREATE_ALWAYS | base::PLATFORM_FILE_WRITE; 993 int flags = base::PLATFORM_FILE_CREATE_ALWAYS | base::PLATFORM_FILE_WRITE;
1108 994
1109 FileStream write_stream(NULL); 995 scoped_ptr<FileStream> write_stream(new FileStream(NULL));
1110 ASSERT_EQ(OK, write_stream.OpenSync(temp_file_path(), flags)); 996 ASSERT_EQ(OK, write_stream->OpenSync(temp_file_path(), flags));
1111 997
1112 // Write some data to the file. 998 // Write some data to the file.
1113 const char test_data[] = "0123456789"; 999 const char test_data[] = "0123456789";
1114 write_stream.WriteSync(test_data, arraysize(test_data)); 1000 write_stream->WriteSync(test_data, arraysize(test_data));
1115 1001
1116 // Truncate the file. 1002 // Truncate the file.
1117 ASSERT_EQ(4, write_stream.Truncate(4)); 1003 ASSERT_EQ(4, write_stream->Truncate(4));
1118 1004
1119 // Write again. 1005 // Write again.
1120 write_stream.WriteSync(test_data, 4); 1006 write_stream->WriteSync(test_data, 4);
1121 1007
1122 // Close the stream. 1008 // Close the stream.
1123 write_stream.CloseSync(); 1009 write_stream.reset();
1124 1010
1125 // Read in the contents and make sure we get back what we expected. 1011 // Read in the contents and make sure we get back what we expected.
1126 std::string read_contents; 1012 std::string read_contents;
1127 EXPECT_TRUE(file_util::ReadFileToString(temp_file_path(), &read_contents)); 1013 EXPECT_TRUE(file_util::ReadFileToString(temp_file_path(), &read_contents));
1128 1014
1129 EXPECT_EQ("01230123", read_contents); 1015 EXPECT_EQ("01230123", read_contents);
1130 } 1016 }
1131 1017
1132 TEST_F(FileStreamTest, AsyncBasicOpenClose) {
1133 FileStream stream(NULL);
1134 int flags = base::PLATFORM_FILE_OPEN |
1135 base::PLATFORM_FILE_READ |
1136 base::PLATFORM_FILE_ASYNC;
1137 TestCompletionCallback callback;
1138 int rv = stream.Open(temp_file_path(), flags, callback.callback());
1139 EXPECT_EQ(ERR_IO_PENDING, rv);
1140 EXPECT_EQ(OK, callback.WaitForResult());
1141 EXPECT_TRUE(stream.IsOpen());
1142
1143 stream.Close(callback.callback());
1144 EXPECT_EQ(OK, callback.WaitForResult());
1145 EXPECT_FALSE(stream.IsOpen());
1146 }
1147
1148 TEST_F(FileStreamTest, SyncCloseTwice) {
1149 FileStream stream(NULL);
1150 int flags = base::PLATFORM_FILE_OPEN |
1151 base::PLATFORM_FILE_READ;
1152 int rv = stream.OpenSync(temp_file_path(), flags);
1153 EXPECT_EQ(OK, rv);
1154 EXPECT_TRUE(stream.IsOpen());
1155
1156 // Closing twice should be safe.
1157 stream.CloseSync();
1158 EXPECT_FALSE(stream.IsOpen());
1159
1160 stream.CloseSync();
1161 EXPECT_FALSE(stream.IsOpen());
1162 }
1163
1164 TEST_F(FileStreamTest, AsyncCloseTwice) {
1165 FileStream stream(NULL);
1166 int flags = base::PLATFORM_FILE_OPEN |
1167 base::PLATFORM_FILE_READ |
1168 base::PLATFORM_FILE_ASYNC;
1169 TestCompletionCallback callback;
1170 int rv = stream.Open(temp_file_path(), flags, callback.callback());
1171 EXPECT_EQ(ERR_IO_PENDING, rv);
1172 EXPECT_EQ(OK, callback.WaitForResult());
1173 EXPECT_TRUE(stream.IsOpen());
1174
1175 // Closing twice should be safe.
1176 stream.Close(callback.callback());
1177 EXPECT_EQ(OK, callback.WaitForResult());
1178 EXPECT_FALSE(stream.IsOpen());
1179
1180 stream.Close(callback.callback());
1181 EXPECT_EQ(OK, callback.WaitForResult());
1182 EXPECT_FALSE(stream.IsOpen());
1183 }
1184
1185 // TODO(satorux): This should be gone once all once all async clients are
1186 // migrated to use Close(). crbug.com/114783
1187 TEST_F(FileStreamTest, AsyncWriteAndCloseSync) {
1188 FileStream stream(NULL);
1189 int flags = base::PLATFORM_FILE_OPEN |
1190 base::PLATFORM_FILE_WRITE |
1191 base::PLATFORM_FILE_ASYNC;
1192 TestCompletionCallback callback;
1193 int rv = stream.Open(temp_file_path(), flags, callback.callback());
1194 EXPECT_EQ(ERR_IO_PENDING, rv);
1195 EXPECT_EQ(OK, callback.WaitForResult());
1196 EXPECT_TRUE(stream.IsOpen());
1197
1198 // Write some data asynchronously.
1199 scoped_refptr<IOBufferWithSize> buf = CreateTestDataBuffer();
1200 stream.Write(buf, buf->size(), callback.callback());
1201
1202 // Close the stream without waiting for the completion.
1203 stream.CloseSync();
1204 }
1205
1206 // TODO(satorux): This should be gone once all once all async clients are
1207 // migrated to use Close(). crbug.com/114783
1208 TEST_F(FileStreamTest, AsyncOpenAndCloseSync) {
1209 FileStream stream(NULL);
1210 int flags = base::PLATFORM_FILE_OPEN |
1211 base::PLATFORM_FILE_WRITE |
1212 base::PLATFORM_FILE_ASYNC;
1213 TestCompletionCallback open_callback;
1214 int rv = stream.Open(temp_file_path(), flags, open_callback.callback());
1215 EXPECT_EQ(ERR_IO_PENDING, rv);
1216
1217 // Close the stream without waiting for the completion. Should be safe.
1218 stream.CloseSync();
1219 // open_callback won't be called.
1220 EXPECT_FALSE(open_callback.have_result());
1221 }
1222
1223 TEST_F(FileStreamTest, AsyncOpenAndDelete) { 1018 TEST_F(FileStreamTest, AsyncOpenAndDelete) {
1224 scoped_ptr<FileStream> stream(new FileStream(NULL)); 1019 scoped_ptr<FileStream> stream(new FileStream(NULL));
1225 int flags = base::PLATFORM_FILE_OPEN | 1020 int flags = base::PLATFORM_FILE_OPEN |
1226 base::PLATFORM_FILE_WRITE | 1021 base::PLATFORM_FILE_WRITE |
1227 base::PLATFORM_FILE_ASYNC; 1022 base::PLATFORM_FILE_ASYNC;
1228 TestCompletionCallback open_callback; 1023 TestCompletionCallback open_callback;
1229 int rv = stream->Open(temp_file_path(), flags, open_callback.callback()); 1024 int rv = stream->Open(temp_file_path(), flags, open_callback.callback());
1230 EXPECT_EQ(ERR_IO_PENDING, rv); 1025 EXPECT_EQ(ERR_IO_PENDING, rv);
1231 1026
1232 // Delete the stream without waiting for the open operation to be 1027 // Delete the stream without waiting for the open operation to be
1233 // complete. Should be safe. 1028 // complete. Should be safe.
1234 stream.reset(); 1029 stream.reset();
1235 // open_callback won't be called. 1030 // open_callback won't be called.
1031 MessageLoop::current()->RunUntilIdle();
1236 EXPECT_FALSE(open_callback.have_result()); 1032 EXPECT_FALSE(open_callback.have_result());
1237 } 1033 }
1238 1034
1239 TEST_F(FileStreamTest, AsyncCloseAndDelete) {
1240 scoped_ptr<FileStream> stream(new FileStream(NULL));
1241 int flags = base::PLATFORM_FILE_OPEN |
1242 base::PLATFORM_FILE_WRITE |
1243 base::PLATFORM_FILE_ASYNC;
1244 TestCompletionCallback open_callback;
1245 int rv = stream->Open(temp_file_path(), flags, open_callback.callback());
1246 EXPECT_EQ(ERR_IO_PENDING, rv);
1247 EXPECT_EQ(OK, open_callback.WaitForResult());
1248 EXPECT_TRUE(stream->IsOpen());
1249
1250 TestCompletionCallback close_callback;
1251 stream->Close(close_callback.callback());
1252
1253 // Delete the stream without waiting for the close operation to be
1254 // complete. Should be safe.
1255 stream.reset();
1256 // close_callback won't be called.
1257 EXPECT_FALSE(close_callback.have_result());
1258 }
1259
1260 } // namespace 1035 } // namespace
1261 1036
1262 } // namespace net 1037 } // namespace net
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698