?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Revert of Revert of Use BoringSSL in the implementation of ClearKey for Chromecast...
[chromium-blink-merge.git] / net / disk_cache / entry_unittest.cc
blob228c654221e85c8a96a2d151183ff545f43a6931
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
3 // found in the LICENSE file.
4
5 #include "base/basictypes.h"
6 #include "base/bind.h"
7 #include "base/bind_helpers.h"
8 #include "base/files/file.h"
9 #include "base/files/file_util.h"
10 #include "base/strings/string_util.h"
11 #include "base/strings/stringprintf.h"
12 #include "base/threading/platform_thread.h"
13 #include "net/base/completion_callback.h"
14 #include "net/base/io_buffer.h"
15 #include "net/base/net_errors.h"
16 #include "net/base/test_completion_callback.h"
17 #include "net/disk_cache/blockfile/backend_impl.h"
18 #include "net/disk_cache/blockfile/entry_impl.h"
19 #include "net/disk_cache/disk_cache_test_base.h"
20 #include "net/disk_cache/disk_cache_test_util.h"
21 #include "net/disk_cache/memory/mem_entry_impl.h"
22 #include "net/disk_cache/simple/simple_entry_format.h"
23 #include "net/disk_cache/simple/simple_entry_impl.h"
24 #include "net/disk_cache/simple/simple_synchronous_entry.h"
25 #include "net/disk_cache/simple/simple_test_util.h"
26 #include "net/disk_cache/simple/simple_util.h"
27 #include "testing/gtest/include/gtest/gtest.h"
28
29 using base::Time;
30 using disk_cache::ScopedEntryPtr;
31
32 // Tests that can run with different types of caches.
33 class DiskCacheEntryTest : public DiskCacheTestWithCache {
34 public:
35 void InternalSyncIOBackground(disk_cache::Entry* entry);
36 void ExternalSyncIOBackground(disk_cache::Entry* entry);
37
38 protected:
39 void InternalSyncIO();
40 void InternalAsyncIO();
41 void ExternalSyncIO();
42 void ExternalAsyncIO();
43 void ReleaseBuffer(int stream_index);
44 void StreamAccess();
45 void GetKey();
46 void GetTimes(int stream_index);
47 void GrowData(int stream_index);
48 void TruncateData(int stream_index);
49 void ZeroLengthIO(int stream_index);
50 void Buffering();
51 void SizeAtCreate();
52 void SizeChanges(int stream_index);
53 void ReuseEntry(int size, int stream_index);
54 void InvalidData(int stream_index);
55 void ReadWriteDestroyBuffer(int stream_index);
56 void DoomNormalEntry();
57 void DoomEntryNextToOpenEntry();
58 void DoomedEntry(int stream_index);
59 void BasicSparseIO();
60 void HugeSparseIO();
61 void GetAvailableRange();
62 void CouldBeSparse();
63 void UpdateSparseEntry();
64 void DoomSparseEntry();
65 void PartialSparseEntry();
66 bool SimpleCacheMakeBadChecksumEntry(const std::string& key, int* data_size);
67 bool SimpleCacheThirdStreamFileExists(const char* key);
68 void SyncDoomEntry(const char* key);
69 };
70
71 // This part of the test runs on the background thread.
72 void DiskCacheEntryTest::InternalSyncIOBackground(disk_cache::Entry* entry) {
73 const int kSize1 = 10;
74 scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
75 CacheTestFillBuffer(buffer1->data(), kSize1, false);
76 EXPECT_EQ(
77 0,
78 entry->ReadData(0, 0, buffer1.get(), kSize1, net::CompletionCallback()));
79 base::strlcpy(buffer1->data(), "the data", kSize1);
80 EXPECT_EQ(10,
81 entry->WriteData(
82 0, 0, buffer1.get(), kSize1, net::CompletionCallback(), false));
83 memset(buffer1->data(), 0, kSize1);
84 EXPECT_EQ(
85 10,
86 entry->ReadData(0, 0, buffer1.get(), kSize1, net::CompletionCallback()));
87 EXPECT_STREQ("the data", buffer1->data());
88
89 const int kSize2 = 5000;
90 const int kSize3 = 10000;
91 scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize2));
92 scoped_refptr<net::IOBuffer> buffer3(new net::IOBuffer(kSize3));
93 memset(buffer3->data(), 0, kSize3);
94 CacheTestFillBuffer(buffer2->data(), kSize2, false);
95 base::strlcpy(buffer2->data(), "The really big data goes here", kSize2);
96 EXPECT_EQ(
97 5000,
98 entry->WriteData(
99 1, 1500, buffer2.get(), kSize2, net::CompletionCallback(), false));
100 memset(buffer2->data(), 0, kSize2);
101 EXPECT_EQ(4989,
102 entry->ReadData(
103 1, 1511, buffer2.get(), kSize2, net::CompletionCallback()));
104 EXPECT_STREQ("big data goes here", buffer2->data());
105 EXPECT_EQ(
106 5000,
107 entry->ReadData(1, 0, buffer2.get(), kSize2, net::CompletionCallback()));
108 EXPECT_EQ(0, memcmp(buffer2->data(), buffer3->data(), 1500));
109 EXPECT_EQ(1500,
110 entry->ReadData(
111 1, 5000, buffer2.get(), kSize2, net::CompletionCallback()));
112
113 EXPECT_EQ(0,
114 entry->ReadData(
115 1, 6500, buffer2.get(), kSize2, net::CompletionCallback()));
116 EXPECT_EQ(
117 6500,
118 entry->ReadData(1, 0, buffer3.get(), kSize3, net::CompletionCallback()));
119 EXPECT_EQ(8192,
120 entry->WriteData(
121 1, 0, buffer3.get(), 8192, net::CompletionCallback(), false));
122 EXPECT_EQ(
123 8192,
124 entry->ReadData(1, 0, buffer3.get(), kSize3, net::CompletionCallback()));
125 EXPECT_EQ(8192, entry->GetDataSize(1));
126
127 // We need to delete the memory buffer on this thread.
128 EXPECT_EQ(0, entry->WriteData(
129 0, 0, NULL, 0, net::CompletionCallback(), true));
130 EXPECT_EQ(0, entry->WriteData(
131 1, 0, NULL, 0, net::CompletionCallback(), true));
132 }
133
134 // We need to support synchronous IO even though it is not a supported operation
135 // from the point of view of the disk cache's public interface, because we use
136 // it internally, not just by a few tests, but as part of the implementation
137 // (see sparse_control.cc, for example).
138 void DiskCacheEntryTest::InternalSyncIO() {
139 disk_cache::Entry* entry = NULL;
140 ASSERT_EQ(net::OK, CreateEntry("the first key", &entry));
141 ASSERT_TRUE(NULL != entry);
142
143 // The bulk of the test runs from within the callback, on the cache thread.
144 RunTaskForTest(base::Bind(&DiskCacheEntryTest::InternalSyncIOBackground,
145 base::Unretained(this),
146 entry));
147
148
149 entry->Doom();
150 entry->Close();
151 FlushQueueForTest();
152 EXPECT_EQ(0, cache_->GetEntryCount());
153 }
154
155 TEST_F(DiskCacheEntryTest, InternalSyncIO) {
156 InitCache();
157 InternalSyncIO();
158 }
159
160 TEST_F(DiskCacheEntryTest, MemoryOnlyInternalSyncIO) {
161 SetMemoryOnlyMode();
162 InitCache();
163 InternalSyncIO();
164 }
165
166 void DiskCacheEntryTest::InternalAsyncIO() {
167 disk_cache::Entry* entry = NULL;
168 ASSERT_EQ(net::OK, CreateEntry("the first key", &entry));
169 ASSERT_TRUE(NULL != entry);
170
171 // Avoid using internal buffers for the test. We have to write something to
172 // the entry and close it so that we flush the internal buffer to disk. After
173 // that, IO operations will be really hitting the disk. We don't care about
174 // the content, so just extending the entry is enough (all extensions zero-
175 // fill any holes).
176 EXPECT_EQ(0, WriteData(entry, 0, 15 * 1024, NULL, 0, false));
177 EXPECT_EQ(0, WriteData(entry, 1, 15 * 1024, NULL, 0, false));
178 entry->Close();
179 ASSERT_EQ(net::OK, OpenEntry("the first key", &entry));
180
181 MessageLoopHelper helper;
182 // Let's verify that each IO goes to the right callback object.
183 CallbackTest callback1(&helper, false);
184 CallbackTest callback2(&helper, false);
185 CallbackTest callback3(&helper, false);
186 CallbackTest callback4(&helper, false);
187 CallbackTest callback5(&helper, false);
188 CallbackTest callback6(&helper, false);
189 CallbackTest callback7(&helper, false);
190 CallbackTest callback8(&helper, false);
191 CallbackTest callback9(&helper, false);
192 CallbackTest callback10(&helper, false);
193 CallbackTest callback11(&helper, false);
194 CallbackTest callback12(&helper, false);
195 CallbackTest callback13(&helper, false);
196
197 const int kSize1 = 10;
198 const int kSize2 = 5000;
199 const int kSize3 = 10000;
200 scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
201 scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize2));
202 scoped_refptr<net::IOBuffer> buffer3(new net::IOBuffer(kSize3));
203 CacheTestFillBuffer(buffer1->data(), kSize1, false);
204 CacheTestFillBuffer(buffer2->data(), kSize2, false);
205 CacheTestFillBuffer(buffer3->data(), kSize3, false);
206
207 EXPECT_EQ(0,
208 entry->ReadData(
209 0,
210 15 * 1024,
211 buffer1.get(),
212 kSize1,
213 base::Bind(&CallbackTest::Run, base::Unretained(&callback1))));
214 base::strlcpy(buffer1->data(), "the data", kSize1);
215 int expected = 0;
216 int ret = entry->WriteData(
217 0,
218 0,
219 buffer1.get(),
220 kSize1,
221 base::Bind(&CallbackTest::Run, base::Unretained(&callback2)),
222 false);
223 EXPECT_TRUE(10 == ret || net::ERR_IO_PENDING == ret);
224 if (net::ERR_IO_PENDING == ret)
225 expected++;
226
227 EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
228 memset(buffer2->data(), 0, kSize2);
229 ret = entry->ReadData(
230 0,
231 0,
232 buffer2.get(),
233 kSize1,
234 base::Bind(&CallbackTest::Run, base::Unretained(&callback3)));
235 EXPECT_TRUE(10 == ret || net::ERR_IO_PENDING == ret);
236 if (net::ERR_IO_PENDING == ret)
237 expected++;
238
239 EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
240 EXPECT_STREQ("the data", buffer2->data());
241
242 base::strlcpy(buffer2->data(), "The really big data goes here", kSize2);
243 ret = entry->WriteData(
244 1,
245 1500,
246 buffer2.get(),
247 kSize2,
248 base::Bind(&CallbackTest::Run, base::Unretained(&callback4)),
249 true);
250 EXPECT_TRUE(5000 == ret || net::ERR_IO_PENDING == ret);
251 if (net::ERR_IO_PENDING == ret)
252 expected++;
253
254 EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
255 memset(buffer3->data(), 0, kSize3);
256 ret = entry->ReadData(
257 1,
258 1511,
259 buffer3.get(),
260 kSize2,
261 base::Bind(&CallbackTest::Run, base::Unretained(&callback5)));
262 EXPECT_TRUE(4989 == ret || net::ERR_IO_PENDING == ret);
263 if (net::ERR_IO_PENDING == ret)
264 expected++;
265
266 EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
267 EXPECT_STREQ("big data goes here", buffer3->data());
268 ret = entry->ReadData(
269 1,
270 0,
271 buffer2.get(),
272 kSize2,
273 base::Bind(&CallbackTest::Run, base::Unretained(&callback6)));
274 EXPECT_TRUE(5000 == ret || net::ERR_IO_PENDING == ret);
275 if (net::ERR_IO_PENDING == ret)
276 expected++;
277
278 memset(buffer3->data(), 0, kSize3);
279
280 EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
281 EXPECT_EQ(0, memcmp(buffer2->data(), buffer3->data(), 1500));
282 ret = entry->ReadData(
283 1,
284 5000,
285 buffer2.get(),
286 kSize2,
287 base::Bind(&CallbackTest::Run, base::Unretained(&callback7)));
288 EXPECT_TRUE(1500 == ret || net::ERR_IO_PENDING == ret);
289 if (net::ERR_IO_PENDING == ret)
290 expected++;
291
292 ret = entry->ReadData(
293 1,
294 0,
295 buffer3.get(),
296 kSize3,
297 base::Bind(&CallbackTest::Run, base::Unretained(&callback9)));
298 EXPECT_TRUE(6500 == ret || net::ERR_IO_PENDING == ret);
299 if (net::ERR_IO_PENDING == ret)
300 expected++;
301
302 ret = entry->WriteData(
303 1,
304 0,
305 buffer3.get(),
306 8192,
307 base::Bind(&CallbackTest::Run, base::Unretained(&callback10)),
308 true);
309 EXPECT_TRUE(8192 == ret || net::ERR_IO_PENDING == ret);
310 if (net::ERR_IO_PENDING == ret)
311 expected++;
312
313 EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
314 ret = entry->ReadData(
315 1,
316 0,
317 buffer3.get(),
318 kSize3,
319 base::Bind(&CallbackTest::Run, base::Unretained(&callback11)));
320 EXPECT_TRUE(8192 == ret || net::ERR_IO_PENDING == ret);
321 if (net::ERR_IO_PENDING == ret)
322 expected++;
323
324 EXPECT_EQ(8192, entry->GetDataSize(1));
325
326 ret = entry->ReadData(
327 0,
328 0,
329 buffer1.get(),
330 kSize1,
331 base::Bind(&CallbackTest::Run, base::Unretained(&callback12)));
332 EXPECT_TRUE(10 == ret || net::ERR_IO_PENDING == ret);
333 if (net::ERR_IO_PENDING == ret)
334 expected++;
335
336 ret = entry->ReadData(
337 1,
338 0,
339 buffer2.get(),
340 kSize2,
341 base::Bind(&CallbackTest::Run, base::Unretained(&callback13)));
342 EXPECT_TRUE(5000 == ret || net::ERR_IO_PENDING == ret);
343 if (net::ERR_IO_PENDING == ret)
344 expected++;
345
346 EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
347
348 EXPECT_FALSE(helper.callback_reused_error());
349
350 entry->Doom();
351 entry->Close();
352 FlushQueueForTest();
353 EXPECT_EQ(0, cache_->GetEntryCount());
354 }
355
356 TEST_F(DiskCacheEntryTest, InternalAsyncIO) {
357 InitCache();
358 InternalAsyncIO();
359 }
360
361 TEST_F(DiskCacheEntryTest, MemoryOnlyInternalAsyncIO) {
362 SetMemoryOnlyMode();
363 InitCache();
364 InternalAsyncIO();
365 }
366
367 // This part of the test runs on the background thread.
368 void DiskCacheEntryTest::ExternalSyncIOBackground(disk_cache::Entry* entry) {
369 const int kSize1 = 17000;
370 const int kSize2 = 25000;
371 scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
372 scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize2));
373 CacheTestFillBuffer(buffer1->data(), kSize1, false);
374 CacheTestFillBuffer(buffer2->data(), kSize2, false);
375 base::strlcpy(buffer1->data(), "the data", kSize1);
376 EXPECT_EQ(17000,
377 entry->WriteData(
378 0, 0, buffer1.get(), kSize1, net::CompletionCallback(), false));
379 memset(buffer1->data(), 0, kSize1);
380 EXPECT_EQ(
381 17000,
382 entry->ReadData(0, 0, buffer1.get(), kSize1, net::CompletionCallback()));
383 EXPECT_STREQ("the data", buffer1->data());
384
385 base::strlcpy(buffer2->data(), "The really big data goes here", kSize2);
386 EXPECT_EQ(
387 25000,
388 entry->WriteData(
389 1, 10000, buffer2.get(), kSize2, net::CompletionCallback(), false));
390 memset(buffer2->data(), 0, kSize2);
391 EXPECT_EQ(24989,
392 entry->ReadData(
393 1, 10011, buffer2.get(), kSize2, net::CompletionCallback()));
394 EXPECT_STREQ("big data goes here", buffer2->data());
395 EXPECT_EQ(
396 25000,
397 entry->ReadData(1, 0, buffer2.get(), kSize2, net::CompletionCallback()));
398 EXPECT_EQ(5000,
399 entry->ReadData(
400 1, 30000, buffer2.get(), kSize2, net::CompletionCallback()));
401
402 EXPECT_EQ(0,
403 entry->ReadData(
404 1, 35000, buffer2.get(), kSize2, net::CompletionCallback()));
405 EXPECT_EQ(
406 17000,
407 entry->ReadData(1, 0, buffer1.get(), kSize1, net::CompletionCallback()));
408 EXPECT_EQ(
409 17000,
410 entry->WriteData(
411 1, 20000, buffer1.get(), kSize1, net::CompletionCallback(), false));
412 EXPECT_EQ(37000, entry->GetDataSize(1));
413
414 // We need to delete the memory buffer on this thread.
415 EXPECT_EQ(0, entry->WriteData(
416 0, 0, NULL, 0, net::CompletionCallback(), true));
417 EXPECT_EQ(0, entry->WriteData(
418 1, 0, NULL, 0, net::CompletionCallback(), true));
419 }
420
421 void DiskCacheEntryTest::ExternalSyncIO() {
422 disk_cache::Entry* entry;
423 ASSERT_EQ(net::OK, CreateEntry("the first key", &entry));
424
425 // The bulk of the test runs from within the callback, on the cache thread.
426 RunTaskForTest(base::Bind(&DiskCacheEntryTest::ExternalSyncIOBackground,
427 base::Unretained(this),
428 entry));
429
430 entry->Doom();
431 entry->Close();
432 FlushQueueForTest();
433 EXPECT_EQ(0, cache_->GetEntryCount());
434 }
435
436 TEST_F(DiskCacheEntryTest, ExternalSyncIO) {
437 InitCache();
438 ExternalSyncIO();
439 }
440
441 TEST_F(DiskCacheEntryTest, ExternalSyncIONoBuffer) {
442 InitCache();
443 cache_impl_->SetFlags(disk_cache::kNoBuffering);
444 ExternalSyncIO();
445 }
446
447 TEST_F(DiskCacheEntryTest, MemoryOnlyExternalSyncIO) {
448 SetMemoryOnlyMode();
449 InitCache();
450 ExternalSyncIO();
451 }
452
453 void DiskCacheEntryTest::ExternalAsyncIO() {
454 disk_cache::Entry* entry;
455 ASSERT_EQ(net::OK, CreateEntry("the first key", &entry));
456
457 int expected = 0;
458
459 MessageLoopHelper helper;
460 // Let's verify that each IO goes to the right callback object.
461 CallbackTest callback1(&helper, false);
462 CallbackTest callback2(&helper, false);
463 CallbackTest callback3(&helper, false);
464 CallbackTest callback4(&helper, false);
465 CallbackTest callback5(&helper, false);
466 CallbackTest callback6(&helper, false);
467 CallbackTest callback7(&helper, false);
468 CallbackTest callback8(&helper, false);
469 CallbackTest callback9(&helper, false);
470
471 const int kSize1 = 17000;
472 const int kSize2 = 25000;
473 const int kSize3 = 25000;
474 scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
475 scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize2));
476 scoped_refptr<net::IOBuffer> buffer3(new net::IOBuffer(kSize3));
477 CacheTestFillBuffer(buffer1->data(), kSize1, false);
478 CacheTestFillBuffer(buffer2->data(), kSize2, false);
479 CacheTestFillBuffer(buffer3->data(), kSize3, false);
480 base::strlcpy(buffer1->data(), "the data", kSize1);
481 int ret = entry->WriteData(
482 0,
483 0,
484 buffer1.get(),
485 kSize1,
486 base::Bind(&CallbackTest::Run, base::Unretained(&callback1)),
487 false);
488 EXPECT_TRUE(17000 == ret || net::ERR_IO_PENDING == ret);
489 if (net::ERR_IO_PENDING == ret)
490 expected++;
491
492 EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
493
494 memset(buffer2->data(), 0, kSize1);
495 ret = entry->ReadData(
496 0,
497 0,
498 buffer2.get(),
499 kSize1,
500 base::Bind(&CallbackTest::Run, base::Unretained(&callback2)));
501 EXPECT_TRUE(17000 == ret || net::ERR_IO_PENDING == ret);
502 if (net::ERR_IO_PENDING == ret)
503 expected++;
504
505 EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
506 EXPECT_STREQ("the data", buffer2->data());
507
508 base::strlcpy(buffer2->data(), "The really big data goes here", kSize2);
509 ret = entry->WriteData(
510 1,
511 10000,
512 buffer2.get(),
513 kSize2,
514 base::Bind(&CallbackTest::Run, base::Unretained(&callback3)),
515 false);
516 EXPECT_TRUE(25000 == ret || net::ERR_IO_PENDING == ret);
517 if (net::ERR_IO_PENDING == ret)
518 expected++;
519
520 EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
521
522 memset(buffer3->data(), 0, kSize3);
523 ret = entry->ReadData(
524 1,
525 10011,
526 buffer3.get(),
527 kSize3,
528 base::Bind(&CallbackTest::Run, base::Unretained(&callback4)));
529 EXPECT_TRUE(24989 == ret || net::ERR_IO_PENDING == ret);
530 if (net::ERR_IO_PENDING == ret)
531 expected++;
532
533 EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
534 EXPECT_STREQ("big data goes here", buffer3->data());
535 ret = entry->ReadData(
536 1,
537 0,
538 buffer2.get(),
539 kSize2,
540 base::Bind(&CallbackTest::Run, base::Unretained(&callback5)));
541 EXPECT_TRUE(25000 == ret || net::ERR_IO_PENDING == ret);
542 if (net::ERR_IO_PENDING == ret)
543 expected++;
544
545 EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
546 memset(buffer3->data(), 0, kSize3);
547 EXPECT_EQ(0, memcmp(buffer2->data(), buffer3->data(), 10000));
548 ret = entry->ReadData(
549 1,
550 30000,
551 buffer2.get(),
552 kSize2,
553 base::Bind(&CallbackTest::Run, base::Unretained(&callback6)));
554 EXPECT_TRUE(5000 == ret || net::ERR_IO_PENDING == ret);
555 if (net::ERR_IO_PENDING == ret)
556 expected++;
557
558 EXPECT_EQ(0,
559 entry->ReadData(
560 1,
561 35000,
562 buffer2.get(),
563 kSize2,
564 base::Bind(&CallbackTest::Run, base::Unretained(&callback7))));
565 ret = entry->ReadData(
566 1,
567 0,
568 buffer1.get(),
569 kSize1,
570 base::Bind(&CallbackTest::Run, base::Unretained(&callback8)));
571 EXPECT_TRUE(17000 == ret || net::ERR_IO_PENDING == ret);
572 if (net::ERR_IO_PENDING == ret)
573 expected++;
574 ret = entry->WriteData(
575 1,
576 20000,
577 buffer3.get(),
578 kSize1,
579 base::Bind(&CallbackTest::Run, base::Unretained(&callback9)),
580 false);
581 EXPECT_TRUE(17000 == ret || net::ERR_IO_PENDING == ret);
582 if (net::ERR_IO_PENDING == ret)
583 expected++;
584
585 EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
586 EXPECT_EQ(37000, entry->GetDataSize(1));
587
588 EXPECT_FALSE(helper.callback_reused_error());
589
590 entry->Doom();
591 entry->Close();
592 FlushQueueForTest();
593 EXPECT_EQ(0, cache_->GetEntryCount());
594 }
595
596 TEST_F(DiskCacheEntryTest, ExternalAsyncIO) {
597 InitCache();
598 ExternalAsyncIO();
599 }
600
601 TEST_F(DiskCacheEntryTest, ExternalAsyncIONoBuffer) {
602 InitCache();
603 cache_impl_->SetFlags(disk_cache::kNoBuffering);
604 ExternalAsyncIO();
605 }
606
607 TEST_F(DiskCacheEntryTest, MemoryOnlyExternalAsyncIO) {
608 SetMemoryOnlyMode();
609 InitCache();
610 ExternalAsyncIO();
611 }
612
613 // Tests that IOBuffers are not referenced after IO completes.
614 void DiskCacheEntryTest::ReleaseBuffer(int stream_index) {
615 disk_cache::Entry* entry = NULL;
616 ASSERT_EQ(net::OK, CreateEntry("the first key", &entry));
617 ASSERT_TRUE(NULL != entry);
618
619 const int kBufferSize = 1024;
620 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
621 CacheTestFillBuffer(buffer->data(), kBufferSize, false);
622
623 net::ReleaseBufferCompletionCallback cb(buffer.get());
624 int rv = entry->WriteData(
625 stream_index, 0, buffer.get(), kBufferSize, cb.callback(), false);
626 EXPECT_EQ(kBufferSize, cb.GetResult(rv));
627 entry->Close();
628 }
629
630 TEST_F(DiskCacheEntryTest, ReleaseBuffer) {
631 InitCache();
632 cache_impl_->SetFlags(disk_cache::kNoBuffering);
633 ReleaseBuffer(0);
634 }
635
636 TEST_F(DiskCacheEntryTest, MemoryOnlyReleaseBuffer) {
637 SetMemoryOnlyMode();
638 InitCache();
639 ReleaseBuffer(0);
640 }
641
642 void DiskCacheEntryTest::StreamAccess() {
643 disk_cache::Entry* entry = NULL;
644 ASSERT_EQ(net::OK, CreateEntry("the first key", &entry));
645 ASSERT_TRUE(NULL != entry);
646
647 const int kBufferSize = 1024;
648 const int kNumStreams = 3;
649 scoped_refptr<net::IOBuffer> reference_buffers[kNumStreams];
650 for (int i = 0; i < kNumStreams; i++) {
651 reference_buffers[i] = new net::IOBuffer(kBufferSize);
652 CacheTestFillBuffer(reference_buffers[i]->data(), kBufferSize, false);
653 }
654 scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kBufferSize));
655 for (int i = 0; i < kNumStreams; i++) {
656 EXPECT_EQ(
657 kBufferSize,
658 WriteData(entry, i, 0, reference_buffers[i].get(), kBufferSize, false));
659 memset(buffer1->data(), 0, kBufferSize);
660 EXPECT_EQ(kBufferSize, ReadData(entry, i, 0, buffer1.get(), kBufferSize));
661 EXPECT_EQ(
662 0, memcmp(reference_buffers[i]->data(), buffer1->data(), kBufferSize));
663 }
664 EXPECT_EQ(net::ERR_INVALID_ARGUMENT,
665 ReadData(entry, kNumStreams, 0, buffer1.get(), kBufferSize));
666 entry->Close();
667
668 // Open the entry and read it in chunks, including a read past the end.
669 ASSERT_EQ(net::OK, OpenEntry("the first key", &entry));
670 ASSERT_TRUE(NULL != entry);
671 const int kReadBufferSize = 600;
672 const int kFinalReadSize = kBufferSize - kReadBufferSize;
673 static_assert(kFinalReadSize < kReadBufferSize,
674 "should be exactly two reads");
675 scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kReadBufferSize));
676 for (int i = 0; i < kNumStreams; i++) {
677 memset(buffer2->data(), 0, kReadBufferSize);
678 EXPECT_EQ(kReadBufferSize,
679 ReadData(entry, i, 0, buffer2.get(), kReadBufferSize));
680 EXPECT_EQ(
681 0,
682 memcmp(reference_buffers[i]->data(), buffer2->data(), kReadBufferSize));
683
684 memset(buffer2->data(), 0, kReadBufferSize);
685 EXPECT_EQ(
686 kFinalReadSize,
687 ReadData(entry, i, kReadBufferSize, buffer2.get(), kReadBufferSize));
688 EXPECT_EQ(0,
689 memcmp(reference_buffers[i]->data() + kReadBufferSize,
690 buffer2->data(),
691 kFinalReadSize));
692 }
693
694 entry->Close();
695 }
696
697 TEST_F(DiskCacheEntryTest, StreamAccess) {
698 InitCache();
699 StreamAccess();
700 }
701
702 TEST_F(DiskCacheEntryTest, MemoryOnlyStreamAccess) {
703 SetMemoryOnlyMode();
704 InitCache();
705 StreamAccess();
706 }
707
708 void DiskCacheEntryTest::GetKey() {
709 std::string key("the first key");
710 disk_cache::Entry* entry;
711 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
712 EXPECT_EQ(key, entry->GetKey()) << "short key";
713 entry->Close();
714
715 int seed = static_cast<int>(Time::Now().ToInternalValue());
716 srand(seed);
717 char key_buffer[20000];
718
719 CacheTestFillBuffer(key_buffer, 3000, true);
720 key_buffer[1000] = '\0';
721
722 key = key_buffer;
723 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
724 EXPECT_TRUE(key == entry->GetKey()) << "1000 bytes key";
725 entry->Close();
726
727 key_buffer[1000] = 'p';
728 key_buffer[3000] = '\0';
729 key = key_buffer;
730 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
731 EXPECT_TRUE(key == entry->GetKey()) << "medium size key";
732 entry->Close();
733
734 CacheTestFillBuffer(key_buffer, sizeof(key_buffer), true);
735 key_buffer[19999] = '\0';
736
737 key = key_buffer;
738 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
739 EXPECT_TRUE(key == entry->GetKey()) << "long key";
740 entry->Close();
741
742 CacheTestFillBuffer(key_buffer, 0x4000, true);
743 key_buffer[0x4000] = '\0';
744
745 key = key_buffer;
746 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
747 EXPECT_TRUE(key == entry->GetKey()) << "16KB key";
748 entry->Close();
749 }
750
751 TEST_F(DiskCacheEntryTest, GetKey) {
752 InitCache();
753 GetKey();
754 }
755
756 TEST_F(DiskCacheEntryTest, MemoryOnlyGetKey) {
757 SetMemoryOnlyMode();
758 InitCache();
759 GetKey();
760 }
761
762 void DiskCacheEntryTest::GetTimes(int stream_index) {
763 std::string key("the first key");
764 disk_cache::Entry* entry;
765
766 Time t1 = Time::Now();
767 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
768 EXPECT_TRUE(entry->GetLastModified() >= t1);
769 EXPECT_TRUE(entry->GetLastModified() == entry->GetLastUsed());
770
771 AddDelay();
772 Time t2 = Time::Now();
773 EXPECT_TRUE(t2 > t1);
774 EXPECT_EQ(0, WriteData(entry, stream_index, 200, NULL, 0, false));
775 if (type_ == net::APP_CACHE) {
776 EXPECT_TRUE(entry->GetLastModified() < t2);
777 } else {
778 EXPECT_TRUE(entry->GetLastModified() >= t2);
779 }
780 EXPECT_TRUE(entry->GetLastModified() == entry->GetLastUsed());
781
782 AddDelay();
783 Time t3 = Time::Now();
784 EXPECT_TRUE(t3 > t2);
785 const int kSize = 200;
786 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
787 EXPECT_EQ(kSize, ReadData(entry, stream_index, 0, buffer.get(), kSize));
788 if (type_ == net::APP_CACHE) {
789 EXPECT_TRUE(entry->GetLastUsed() < t2);
790 EXPECT_TRUE(entry->GetLastModified() < t2);
791 } else if (type_ == net::SHADER_CACHE) {
792 EXPECT_TRUE(entry->GetLastUsed() < t3);
793 EXPECT_TRUE(entry->GetLastModified() < t3);
794 } else {
795 EXPECT_TRUE(entry->GetLastUsed() >= t3);
796 EXPECT_TRUE(entry->GetLastModified() < t3);
797 }
798 entry->Close();
799 }
800
801 TEST_F(DiskCacheEntryTest, GetTimes) {
802 InitCache();
803 GetTimes(0);
804 }
805
806 TEST_F(DiskCacheEntryTest, MemoryOnlyGetTimes) {
807 SetMemoryOnlyMode();
808 InitCache();
809 GetTimes(0);
810 }
811
812 TEST_F(DiskCacheEntryTest, AppCacheGetTimes) {
813 SetCacheType(net::APP_CACHE);
814 InitCache();
815 GetTimes(0);
816 }
817
818 TEST_F(DiskCacheEntryTest, ShaderCacheGetTimes) {
819 SetCacheType(net::SHADER_CACHE);
820 InitCache();
821 GetTimes(0);
822 }
823
824 void DiskCacheEntryTest::GrowData(int stream_index) {
825 std::string key1("the first key");
826 disk_cache::Entry* entry;
827 ASSERT_EQ(net::OK, CreateEntry(key1, &entry));
828
829 const int kSize = 20000;
830 scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
831 scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
832 CacheTestFillBuffer(buffer1->data(), kSize, false);
833 memset(buffer2->data(), 0, kSize);
834
835 base::strlcpy(buffer1->data(), "the data", kSize);
836 EXPECT_EQ(10, WriteData(entry, stream_index, 0, buffer1.get(), 10, false));
837 EXPECT_EQ(10, ReadData(entry, stream_index, 0, buffer2.get(), 10));
838 EXPECT_STREQ("the data", buffer2->data());
839 EXPECT_EQ(10, entry->GetDataSize(stream_index));
840
841 EXPECT_EQ(2000,
842 WriteData(entry, stream_index, 0, buffer1.get(), 2000, false));
843 EXPECT_EQ(2000, entry->GetDataSize(stream_index));
844 EXPECT_EQ(2000, ReadData(entry, stream_index, 0, buffer2.get(), 2000));
845 EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 2000));
846
847 EXPECT_EQ(20000,
848 WriteData(entry, stream_index, 0, buffer1.get(), kSize, false));
849 EXPECT_EQ(20000, entry->GetDataSize(stream_index));
850 EXPECT_EQ(20000, ReadData(entry, stream_index, 0, buffer2.get(), kSize));
851 EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), kSize));
852 entry->Close();
853
854 memset(buffer2->data(), 0, kSize);
855 std::string key2("Second key");
856 ASSERT_EQ(net::OK, CreateEntry(key2, &entry));
857 EXPECT_EQ(10, WriteData(entry, stream_index, 0, buffer1.get(), 10, false));
858 EXPECT_EQ(10, entry->GetDataSize(stream_index));
859 entry->Close();
860
861 // Go from an internal address to a bigger block size.
862 ASSERT_EQ(net::OK, OpenEntry(key2, &entry));
863 EXPECT_EQ(2000,
864 WriteData(entry, stream_index, 0, buffer1.get(), 2000, false));
865 EXPECT_EQ(2000, entry->GetDataSize(stream_index));
866 EXPECT_EQ(2000, ReadData(entry, stream_index, 0, buffer2.get(), 2000));
867 EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 2000));
868 entry->Close();
869 memset(buffer2->data(), 0, kSize);
870
871 // Go from an internal address to an external one.
872 ASSERT_EQ(net::OK, OpenEntry(key2, &entry));
873 EXPECT_EQ(20000,
874 WriteData(entry, stream_index, 0, buffer1.get(), kSize, false));
875 EXPECT_EQ(20000, entry->GetDataSize(stream_index));
876 EXPECT_EQ(20000, ReadData(entry, stream_index, 0, buffer2.get(), kSize));
877 EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), kSize));
878 entry->Close();
879
880 // Double check the size from disk.
881 ASSERT_EQ(net::OK, OpenEntry(key2, &entry));
882 EXPECT_EQ(20000, entry->GetDataSize(stream_index));
883
884 // Now extend the entry without actual data.
885 EXPECT_EQ(0, WriteData(entry, stream_index, 45500, buffer1.get(), 0, false));
886 entry->Close();
887
888 // And check again from disk.
889 ASSERT_EQ(net::OK, OpenEntry(key2, &entry));
890 EXPECT_EQ(45500, entry->GetDataSize(stream_index));
891 entry->Close();
892 }
893
894 TEST_F(DiskCacheEntryTest, GrowData) {
895 InitCache();
896 GrowData(0);
897 }
898
899 TEST_F(DiskCacheEntryTest, GrowDataNoBuffer) {
900 InitCache();
901 cache_impl_->SetFlags(disk_cache::kNoBuffering);
902 GrowData(0);
903 }
904
905 TEST_F(DiskCacheEntryTest, MemoryOnlyGrowData) {
906 SetMemoryOnlyMode();
907 InitCache();
908 GrowData(0);
909 }
910
911 void DiskCacheEntryTest::TruncateData(int stream_index) {
912 std::string key("the first key");
913 disk_cache::Entry* entry;
914 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
915
916 const int kSize1 = 20000;
917 const int kSize2 = 20000;
918 scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
919 scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize2));
920
921 CacheTestFillBuffer(buffer1->data(), kSize1, false);
922 memset(buffer2->data(), 0, kSize2);
923
924 // Simple truncation:
925 EXPECT_EQ(200, WriteData(entry, stream_index, 0, buffer1.get(), 200, false));
926 EXPECT_EQ(200, entry->GetDataSize(stream_index));
927 EXPECT_EQ(100, WriteData(entry, stream_index, 0, buffer1.get(), 100, false));
928 EXPECT_EQ(200, entry->GetDataSize(stream_index));
929 EXPECT_EQ(100, WriteData(entry, stream_index, 0, buffer1.get(), 100, true));
930 EXPECT_EQ(100, entry->GetDataSize(stream_index));
931 EXPECT_EQ(0, WriteData(entry, stream_index, 50, buffer1.get(), 0, true));
932 EXPECT_EQ(50, entry->GetDataSize(stream_index));
933 EXPECT_EQ(0, WriteData(entry, stream_index, 0, buffer1.get(), 0, true));
934 EXPECT_EQ(0, entry->GetDataSize(stream_index));
935 entry->Close();
936 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
937
938 // Go to an external file.
939 EXPECT_EQ(20000,
940 WriteData(entry, stream_index, 0, buffer1.get(), 20000, true));
941 EXPECT_EQ(20000, entry->GetDataSize(stream_index));
942 EXPECT_EQ(20000, ReadData(entry, stream_index, 0, buffer2.get(), 20000));
943 EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 20000));
944 memset(buffer2->data(), 0, kSize2);
945
946 // External file truncation
947 EXPECT_EQ(18000,
948 WriteData(entry, stream_index, 0, buffer1.get(), 18000, false));
949 EXPECT_EQ(20000, entry->GetDataSize(stream_index));
950 EXPECT_EQ(18000,
951 WriteData(entry, stream_index, 0, buffer1.get(), 18000, true));
952 EXPECT_EQ(18000, entry->GetDataSize(stream_index));
953 EXPECT_EQ(0, WriteData(entry, stream_index, 17500, buffer1.get(), 0, true));
954 EXPECT_EQ(17500, entry->GetDataSize(stream_index));
955
956 // And back to an internal block.
957 EXPECT_EQ(600,
958 WriteData(entry, stream_index, 1000, buffer1.get(), 600, true));
959 EXPECT_EQ(1600, entry->GetDataSize(stream_index));
960 EXPECT_EQ(600, ReadData(entry, stream_index, 1000, buffer2.get(), 600));
961 EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 600));
962 EXPECT_EQ(1000, ReadData(entry, stream_index, 0, buffer2.get(), 1000));
963 EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 1000))
964 << "Preserves previous data";
965
966 // Go from external file to zero length.
967 EXPECT_EQ(20000,
968 WriteData(entry, stream_index, 0, buffer1.get(), 20000, true));
969 EXPECT_EQ(20000, entry->GetDataSize(stream_index));
970 EXPECT_EQ(0, WriteData(entry, stream_index, 0, buffer1.get(), 0, true));
971 EXPECT_EQ(0, entry->GetDataSize(stream_index));
972
973 entry->Close();
974 }
975
976 TEST_F(DiskCacheEntryTest, TruncateData) {
977 InitCache();
978 TruncateData(0);
979 }
980
981 TEST_F(DiskCacheEntryTest, TruncateDataNoBuffer) {
982 InitCache();
983 cache_impl_->SetFlags(disk_cache::kNoBuffering);
984 TruncateData(0);
985 }
986
987 TEST_F(DiskCacheEntryTest, MemoryOnlyTruncateData) {
988 SetMemoryOnlyMode();
989 InitCache();
990 TruncateData(0);
991 }
992
993 void DiskCacheEntryTest::ZeroLengthIO(int stream_index) {
994 std::string key("the first key");
995 disk_cache::Entry* entry;
996 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
997
998 EXPECT_EQ(0, ReadData(entry, stream_index, 0, NULL, 0));
999 EXPECT_EQ(0, WriteData(entry, stream_index, 0, NULL, 0, false));
1000
1001 // This write should extend the entry.
1002 EXPECT_EQ(0, WriteData(entry, stream_index, 1000, NULL, 0, false));
1003 EXPECT_EQ(0, ReadData(entry, stream_index, 500, NULL, 0));
1004 EXPECT_EQ(0, ReadData(entry, stream_index, 2000, NULL, 0));
1005 EXPECT_EQ(1000, entry->GetDataSize(stream_index));
1006
1007 EXPECT_EQ(0, WriteData(entry, stream_index, 100000, NULL, 0, true));
1008 EXPECT_EQ(0, ReadData(entry, stream_index, 50000, NULL, 0));
1009 EXPECT_EQ(100000, entry->GetDataSize(stream_index));
1010
1011 // Let's verify the actual content.
1012 const int kSize = 20;
1013 const char zeros[kSize] = {};
1014 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
1015
1016 CacheTestFillBuffer(buffer->data(), kSize, false);
1017 EXPECT_EQ(kSize, ReadData(entry, stream_index, 500, buffer.get(), kSize));
1018 EXPECT_TRUE(!memcmp(buffer->data(), zeros, kSize));
1019
1020 CacheTestFillBuffer(buffer->data(), kSize, false);
1021 EXPECT_EQ(kSize, ReadData(entry, stream_index, 5000, buffer.get(), kSize));
1022 EXPECT_TRUE(!memcmp(buffer->data(), zeros, kSize));
1023
1024 CacheTestFillBuffer(buffer->data(), kSize, false);
1025 EXPECT_EQ(kSize, ReadData(entry, stream_index, 50000, buffer.get(), kSize));
1026 EXPECT_TRUE(!memcmp(buffer->data(), zeros, kSize));
1027
1028 entry->Close();
1029 }
1030
1031 TEST_F(DiskCacheEntryTest, ZeroLengthIO) {
1032 InitCache();
1033 ZeroLengthIO(0);
1034 }
1035
1036 TEST_F(DiskCacheEntryTest, ZeroLengthIONoBuffer) {
1037 InitCache();
1038 cache_impl_->SetFlags(disk_cache::kNoBuffering);
1039 ZeroLengthIO(0);
1040 }
1041
1042 TEST_F(DiskCacheEntryTest, MemoryOnlyZeroLengthIO) {
1043 SetMemoryOnlyMode();
1044 InitCache();
1045 ZeroLengthIO(0);
1046 }
1047
1048 // Tests that we handle the content correctly when buffering, a feature of the
1049 // standard cache that permits fast responses to certain reads.
1050 void DiskCacheEntryTest::Buffering() {
1051 std::string key("the first key");
1052 disk_cache::Entry* entry;
1053 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1054
1055 const int kSize = 200;
1056 scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
1057 scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
1058 CacheTestFillBuffer(buffer1->data(), kSize, true);
1059 CacheTestFillBuffer(buffer2->data(), kSize, true);
1060
1061 EXPECT_EQ(kSize, WriteData(entry, 1, 0, buffer1.get(), kSize, false));
1062 entry->Close();
1063
1064 // Write a little more and read what we wrote before.
1065 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
1066 EXPECT_EQ(kSize, WriteData(entry, 1, 5000, buffer1.get(), kSize, false));
1067 EXPECT_EQ(kSize, ReadData(entry, 1, 0, buffer2.get(), kSize));
1068 EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
1069
1070 // Now go to an external file.
1071 EXPECT_EQ(kSize, WriteData(entry, 1, 18000, buffer1.get(), kSize, false));
1072 entry->Close();
1073
1074 // Write something else and verify old data.
1075 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
1076 EXPECT_EQ(kSize, WriteData(entry, 1, 10000, buffer1.get(), kSize, false));
1077 CacheTestFillBuffer(buffer2->data(), kSize, true);
1078 EXPECT_EQ(kSize, ReadData(entry, 1, 5000, buffer2.get(), kSize));
1079 EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
1080 CacheTestFillBuffer(buffer2->data(), kSize, true);
1081 EXPECT_EQ(kSize, ReadData(entry, 1, 0, buffer2.get(), kSize));
1082 EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
1083 CacheTestFillBuffer(buffer2->data(), kSize, true);
1084 EXPECT_EQ(kSize, ReadData(entry, 1, 18000, buffer2.get(), kSize));
1085 EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
1086
1087 // Extend the file some more.
1088 EXPECT_EQ(kSize, WriteData(entry, 1, 23000, buffer1.get(), kSize, false));
1089 entry->Close();
1090
1091 // And now make sure that we can deal with data in both places (ram/disk).
1092 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
1093 EXPECT_EQ(kSize, WriteData(entry, 1, 17000, buffer1.get(), kSize, false));
1094
1095 // We should not overwrite the data at 18000 with this.
1096 EXPECT_EQ(kSize, WriteData(entry, 1, 19000, buffer1.get(), kSize, false));
1097 CacheTestFillBuffer(buffer2->data(), kSize, true);
1098 EXPECT_EQ(kSize, ReadData(entry, 1, 18000, buffer2.get(), kSize));
1099 EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
1100 CacheTestFillBuffer(buffer2->data(), kSize, true);
1101 EXPECT_EQ(kSize, ReadData(entry, 1, 17000, buffer2.get(), kSize));
1102 EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
1103
1104 EXPECT_EQ(kSize, WriteData(entry, 1, 22900, buffer1.get(), kSize, false));
1105 CacheTestFillBuffer(buffer2->data(), kSize, true);
1106 EXPECT_EQ(100, ReadData(entry, 1, 23000, buffer2.get(), kSize));
1107 EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data() + 100, 100));
1108
1109 CacheTestFillBuffer(buffer2->data(), kSize, true);
1110 EXPECT_EQ(100, ReadData(entry, 1, 23100, buffer2.get(), kSize));
1111 EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data() + 100, 100));
1112
1113 // Extend the file again and read before without closing the entry.
1114 EXPECT_EQ(kSize, WriteData(entry, 1, 25000, buffer1.get(), kSize, false));
1115 EXPECT_EQ(kSize, WriteData(entry, 1, 45000, buffer1.get(), kSize, false));
1116 CacheTestFillBuffer(buffer2->data(), kSize, true);
1117 EXPECT_EQ(kSize, ReadData(entry, 1, 25000, buffer2.get(), kSize));
1118 EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
1119 CacheTestFillBuffer(buffer2->data(), kSize, true);
1120 EXPECT_EQ(kSize, ReadData(entry, 1, 45000, buffer2.get(), kSize));
1121 EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
1122
1123 entry->Close();
1124 }
1125
1126 TEST_F(DiskCacheEntryTest, Buffering) {
1127 InitCache();
1128 Buffering();
1129 }
1130
1131 TEST_F(DiskCacheEntryTest, BufferingNoBuffer) {
1132 InitCache();
1133 cache_impl_->SetFlags(disk_cache::kNoBuffering);
1134 Buffering();
1135 }
1136
1137 // Checks that entries are zero length when created.
1138 void DiskCacheEntryTest::SizeAtCreate() {
1139 const char key[] = "the first key";
1140 disk_cache::Entry* entry;
1141 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1142
1143 const int kNumStreams = 3;
1144 for (int i = 0; i < kNumStreams; ++i)
1145 EXPECT_EQ(0, entry->GetDataSize(i));
1146 entry->Close();
1147 }
1148
1149 TEST_F(DiskCacheEntryTest, SizeAtCreate) {
1150 InitCache();
1151 SizeAtCreate();
1152 }
1153
1154 TEST_F(DiskCacheEntryTest, MemoryOnlySizeAtCreate) {
1155 SetMemoryOnlyMode();
1156 InitCache();
1157 SizeAtCreate();
1158 }
1159
1160 // Some extra tests to make sure that buffering works properly when changing
1161 // the entry size.
1162 void DiskCacheEntryTest::SizeChanges(int stream_index) {
1163 std::string key("the first key");
1164 disk_cache::Entry* entry;
1165 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1166
1167 const int kSize = 200;
1168 const char zeros[kSize] = {};
1169 scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
1170 scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
1171 CacheTestFillBuffer(buffer1->data(), kSize, true);
1172 CacheTestFillBuffer(buffer2->data(), kSize, true);
1173
1174 EXPECT_EQ(kSize,
1175 WriteData(entry, stream_index, 0, buffer1.get(), kSize, true));
1176 EXPECT_EQ(kSize,
1177 WriteData(entry, stream_index, 17000, buffer1.get(), kSize, true));
1178 EXPECT_EQ(kSize,
1179 WriteData(entry, stream_index, 23000, buffer1.get(), kSize, true));
1180 entry->Close();
1181
1182 // Extend the file and read between the old size and the new write.
1183 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
1184 EXPECT_EQ(23000 + kSize, entry->GetDataSize(stream_index));
1185 EXPECT_EQ(kSize,
1186 WriteData(entry, stream_index, 25000, buffer1.get(), kSize, true));
1187 EXPECT_EQ(25000 + kSize, entry->GetDataSize(stream_index));
1188 EXPECT_EQ(kSize, ReadData(entry, stream_index, 24000, buffer2.get(), kSize));
1189 EXPECT_TRUE(!memcmp(buffer2->data(), zeros, kSize));
1190
1191 // Read at the end of the old file size.
1192 EXPECT_EQ(
1193 kSize,
1194 ReadData(entry, stream_index, 23000 + kSize - 35, buffer2.get(), kSize));
1195 EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data() + kSize - 35, 35));
1196
1197 // Read slightly before the last write.
1198 CacheTestFillBuffer(buffer2->data(), kSize, true);
1199 EXPECT_EQ(kSize, ReadData(entry, stream_index, 24900, buffer2.get(), kSize));
1200 EXPECT_TRUE(!memcmp(buffer2->data(), zeros, 100));
1201 EXPECT_TRUE(!memcmp(buffer2->data() + 100, buffer1->data(), kSize - 100));
1202
1203 // Extend the entry a little more.
1204 EXPECT_EQ(kSize,
1205 WriteData(entry, stream_index, 26000, buffer1.get(), kSize, true));
1206 EXPECT_EQ(26000 + kSize, entry->GetDataSize(stream_index));
1207 CacheTestFillBuffer(buffer2->data(), kSize, true);
1208 EXPECT_EQ(kSize, ReadData(entry, stream_index, 25900, buffer2.get(), kSize));
1209 EXPECT_TRUE(!memcmp(buffer2->data(), zeros, 100));
1210 EXPECT_TRUE(!memcmp(buffer2->data() + 100, buffer1->data(), kSize - 100));
1211
1212 // And now reduce the size.
1213 EXPECT_EQ(kSize,
1214 WriteData(entry, stream_index, 25000, buffer1.get(), kSize, true));
1215 EXPECT_EQ(25000 + kSize, entry->GetDataSize(stream_index));
1216 EXPECT_EQ(
1217 28,
1218 ReadData(entry, stream_index, 25000 + kSize - 28, buffer2.get(), kSize));
1219 EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data() + kSize - 28, 28));
1220
1221 // Reduce the size with a buffer that is not extending the size.
1222 EXPECT_EQ(kSize,
1223 WriteData(entry, stream_index, 24000, buffer1.get(), kSize, false));
1224 EXPECT_EQ(25000 + kSize, entry->GetDataSize(stream_index));
1225 EXPECT_EQ(kSize,
1226 WriteData(entry, stream_index, 24500, buffer1.get(), kSize, true));
1227 EXPECT_EQ(24500 + kSize, entry->GetDataSize(stream_index));
1228 EXPECT_EQ(kSize, ReadData(entry, stream_index, 23900, buffer2.get(), kSize));
1229 EXPECT_TRUE(!memcmp(buffer2->data(), zeros, 100));
1230 EXPECT_TRUE(!memcmp(buffer2->data() + 100, buffer1->data(), kSize - 100));
1231
1232 // And now reduce the size below the old size.
1233 EXPECT_EQ(kSize,
1234 WriteData(entry, stream_index, 19000, buffer1.get(), kSize, true));
1235 EXPECT_EQ(19000 + kSize, entry->GetDataSize(stream_index));
1236 EXPECT_EQ(kSize, ReadData(entry, stream_index, 18900, buffer2.get(), kSize));
1237 EXPECT_TRUE(!memcmp(buffer2->data(), zeros, 100));
1238 EXPECT_TRUE(!memcmp(buffer2->data() + 100, buffer1->data(), kSize - 100));
1239
1240 // Verify that the actual file is truncated.
1241 entry->Close();
1242 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
1243 EXPECT_EQ(19000 + kSize, entry->GetDataSize(stream_index));
1244
1245 // Extend the newly opened file with a zero length write, expect zero fill.
1246 EXPECT_EQ(
1247 0,
1248 WriteData(entry, stream_index, 20000 + kSize, buffer1.get(), 0, false));
1249 EXPECT_EQ(kSize,
1250 ReadData(entry, stream_index, 19000 + kSize, buffer1.get(), kSize));
1251 EXPECT_EQ(0, memcmp(buffer1->data(), zeros, kSize));
1252
1253 entry->Close();
1254 }
1255
1256 TEST_F(DiskCacheEntryTest, SizeChanges) {
1257 InitCache();
1258 SizeChanges(1);
1259 }
1260
1261 TEST_F(DiskCacheEntryTest, SizeChangesNoBuffer) {
1262 InitCache();
1263 cache_impl_->SetFlags(disk_cache::kNoBuffering);
1264 SizeChanges(1);
1265 }
1266
1267 // Write more than the total cache capacity but to a single entry. |size| is the
1268 // amount of bytes to write each time.
1269 void DiskCacheEntryTest::ReuseEntry(int size, int stream_index) {
1270 std::string key1("the first key");
1271 disk_cache::Entry* entry;
1272 ASSERT_EQ(net::OK, CreateEntry(key1, &entry));
1273
1274 entry->Close();
1275 std::string key2("the second key");
1276 ASSERT_EQ(net::OK, CreateEntry(key2, &entry));
1277
1278 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(size));
1279 CacheTestFillBuffer(buffer->data(), size, false);
1280
1281 for (int i = 0; i < 15; i++) {
1282 EXPECT_EQ(0, WriteData(entry, stream_index, 0, buffer.get(), 0, true));
1283 EXPECT_EQ(size,
1284 WriteData(entry, stream_index, 0, buffer.get(), size, false));
1285 entry->Close();
1286 ASSERT_EQ(net::OK, OpenEntry(key2, &entry));
1287 }
1288
1289 entry->Close();
1290 ASSERT_EQ(net::OK, OpenEntry(key1, &entry)) << "have not evicted this entry";
1291 entry->Close();
1292 }
1293
1294 TEST_F(DiskCacheEntryTest, ReuseExternalEntry) {
1295 SetMaxSize(200 * 1024);
1296 InitCache();
1297 ReuseEntry(20 * 1024, 0);
1298 }
1299
1300 TEST_F(DiskCacheEntryTest, MemoryOnlyReuseExternalEntry) {
1301 SetMemoryOnlyMode();
1302 SetMaxSize(200 * 1024);
1303 InitCache();
1304 ReuseEntry(20 * 1024, 0);
1305 }
1306
1307 TEST_F(DiskCacheEntryTest, ReuseInternalEntry) {
1308 SetMaxSize(100 * 1024);
1309 InitCache();
1310 ReuseEntry(10 * 1024, 0);
1311 }
1312
1313 TEST_F(DiskCacheEntryTest, MemoryOnlyReuseInternalEntry) {
1314 SetMemoryOnlyMode();
1315 SetMaxSize(100 * 1024);
1316 InitCache();
1317 ReuseEntry(10 * 1024, 0);
1318 }
1319
1320 // Reading somewhere that was not written should return zeros.
1321 void DiskCacheEntryTest::InvalidData(int stream_index) {
1322 std::string key("the first key");
1323 disk_cache::Entry* entry;
1324 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1325
1326 const int kSize1 = 20000;
1327 const int kSize2 = 20000;
1328 const int kSize3 = 20000;
1329 scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
1330 scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize2));
1331 scoped_refptr<net::IOBuffer> buffer3(new net::IOBuffer(kSize3));
1332
1333 CacheTestFillBuffer(buffer1->data(), kSize1, false);
1334 memset(buffer2->data(), 0, kSize2);
1335
1336 // Simple data grow:
1337 EXPECT_EQ(200,
1338 WriteData(entry, stream_index, 400, buffer1.get(), 200, false));
1339 EXPECT_EQ(600, entry->GetDataSize(stream_index));
1340 EXPECT_EQ(100, ReadData(entry, stream_index, 300, buffer3.get(), 100));
1341 EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 100));
1342 entry->Close();
1343 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
1344
1345 // The entry is now on disk. Load it and extend it.
1346 EXPECT_EQ(200,
1347 WriteData(entry, stream_index, 800, buffer1.get(), 200, false));
1348 EXPECT_EQ(1000, entry->GetDataSize(stream_index));
1349 EXPECT_EQ(100, ReadData(entry, stream_index, 700, buffer3.get(), 100));
1350 EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 100));
1351 entry->Close();
1352 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
1353
1354 // This time using truncate.
1355 EXPECT_EQ(200,
1356 WriteData(entry, stream_index, 1800, buffer1.get(), 200, true));
1357 EXPECT_EQ(2000, entry->GetDataSize(stream_index));
1358 EXPECT_EQ(100, ReadData(entry, stream_index, 1500, buffer3.get(), 100));
1359 EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 100));
1360
1361 // Go to an external file.
1362 EXPECT_EQ(200,
1363 WriteData(entry, stream_index, 19800, buffer1.get(), 200, false));
1364 EXPECT_EQ(20000, entry->GetDataSize(stream_index));
1365 EXPECT_EQ(4000, ReadData(entry, stream_index, 14000, buffer3.get(), 4000));
1366 EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 4000));
1367
1368 // And back to an internal block.
1369 EXPECT_EQ(600,
1370 WriteData(entry, stream_index, 1000, buffer1.get(), 600, true));
1371 EXPECT_EQ(1600, entry->GetDataSize(stream_index));
1372 EXPECT_EQ(600, ReadData(entry, stream_index, 1000, buffer3.get(), 600));
1373 EXPECT_TRUE(!memcmp(buffer3->data(), buffer1->data(), 600));
1374
1375 // Extend it again.
1376 EXPECT_EQ(600,
1377 WriteData(entry, stream_index, 2000, buffer1.get(), 600, false));
1378 EXPECT_EQ(2600, entry->GetDataSize(stream_index));
1379 EXPECT_EQ(200, ReadData(entry, stream_index, 1800, buffer3.get(), 200));
1380 EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 200));
1381
1382 // And again (with truncation flag).
1383 EXPECT_EQ(600,
1384 WriteData(entry, stream_index, 3000, buffer1.get(), 600, true));
1385 EXPECT_EQ(3600, entry->GetDataSize(stream_index));
1386 EXPECT_EQ(200, ReadData(entry, stream_index, 2800, buffer3.get(), 200));
1387 EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 200));
1388
1389 entry->Close();
1390 }
1391
1392 TEST_F(DiskCacheEntryTest, InvalidData) {
1393 InitCache();
1394 InvalidData(0);
1395 }
1396
1397 TEST_F(DiskCacheEntryTest, InvalidDataNoBuffer) {
1398 InitCache();
1399 cache_impl_->SetFlags(disk_cache::kNoBuffering);
1400 InvalidData(0);
1401 }
1402
1403 TEST_F(DiskCacheEntryTest, MemoryOnlyInvalidData) {
1404 SetMemoryOnlyMode();
1405 InitCache();
1406 InvalidData(0);
1407 }
1408
1409 // Tests that the cache preserves the buffer of an IO operation.
1410 void DiskCacheEntryTest::ReadWriteDestroyBuffer(int stream_index) {
1411 std::string key("the first key");
1412 disk_cache::Entry* entry;
1413 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1414
1415 const int kSize = 200;
1416 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
1417 CacheTestFillBuffer(buffer->data(), kSize, false);
1418
1419 net::TestCompletionCallback cb;
1420 EXPECT_EQ(net::ERR_IO_PENDING,
1421 entry->WriteData(
1422 stream_index, 0, buffer.get(), kSize, cb.callback(), false));
1423
1424 // Release our reference to the buffer.
1425 buffer = NULL;
1426 EXPECT_EQ(kSize, cb.WaitForResult());
1427
1428 // And now test with a Read().
1429 buffer = new net::IOBuffer(kSize);
1430 CacheTestFillBuffer(buffer->data(), kSize, false);
1431
1432 EXPECT_EQ(
1433 net::ERR_IO_PENDING,
1434 entry->ReadData(stream_index, 0, buffer.get(), kSize, cb.callback()));
1435 buffer = NULL;
1436 EXPECT_EQ(kSize, cb.WaitForResult());
1437
1438 entry->Close();
1439 }
1440
1441 TEST_F(DiskCacheEntryTest, ReadWriteDestroyBuffer) {
1442 InitCache();
1443 ReadWriteDestroyBuffer(0);
1444 }
1445
1446 void DiskCacheEntryTest::DoomNormalEntry() {
1447 std::string key("the first key");
1448 disk_cache::Entry* entry;
1449 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1450 entry->Doom();
1451 entry->Close();
1452
1453 const int kSize = 20000;
1454 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
1455 CacheTestFillBuffer(buffer->data(), kSize, true);
1456 buffer->data()[19999] = '\0';
1457
1458 key = buffer->data();
1459 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1460 EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer.get(), kSize, false));
1461 EXPECT_EQ(20000, WriteData(entry, 1, 0, buffer.get(), kSize, false));
1462 entry->Doom();
1463 entry->Close();
1464
1465 FlushQueueForTest();
1466 EXPECT_EQ(0, cache_->GetEntryCount());
1467 }
1468
1469 TEST_F(DiskCacheEntryTest, DoomEntry) {
1470 InitCache();
1471 DoomNormalEntry();
1472 }
1473
1474 TEST_F(DiskCacheEntryTest, MemoryOnlyDoomEntry) {
1475 SetMemoryOnlyMode();
1476 InitCache();
1477 DoomNormalEntry();
1478 }
1479
1480 // Tests dooming an entry that's linked to an open entry.
1481 void DiskCacheEntryTest::DoomEntryNextToOpenEntry() {
1482 disk_cache::Entry* entry1;
1483 disk_cache::Entry* entry2;
1484 ASSERT_EQ(net::OK, CreateEntry("fixed", &entry1));
1485 entry1->Close();
1486 ASSERT_EQ(net::OK, CreateEntry("foo", &entry1));
1487 entry1->Close();
1488 ASSERT_EQ(net::OK, CreateEntry("bar", &entry1));
1489 entry1->Close();
1490
1491 ASSERT_EQ(net::OK, OpenEntry("foo", &entry1));
1492 ASSERT_EQ(net::OK, OpenEntry("bar", &entry2));
1493 entry2->Doom();
1494 entry2->Close();
1495
1496 ASSERT_EQ(net::OK, OpenEntry("foo", &entry2));
1497 entry2->Doom();
1498 entry2->Close();
1499 entry1->Close();
1500
1501 ASSERT_EQ(net::OK, OpenEntry("fixed", &entry1));
1502 entry1->Close();
1503 }
1504
1505 TEST_F(DiskCacheEntryTest, DoomEntryNextToOpenEntry) {
1506 InitCache();
1507 DoomEntryNextToOpenEntry();
1508 }
1509
1510 TEST_F(DiskCacheEntryTest, NewEvictionDoomEntryNextToOpenEntry) {
1511 SetNewEviction();
1512 InitCache();
1513 DoomEntryNextToOpenEntry();
1514 }
1515
1516 TEST_F(DiskCacheEntryTest, AppCacheDoomEntryNextToOpenEntry) {
1517 SetCacheType(net::APP_CACHE);
1518 InitCache();
1519 DoomEntryNextToOpenEntry();
1520 }
1521
1522 // Verify that basic operations work as expected with doomed entries.
1523 void DiskCacheEntryTest::DoomedEntry(int stream_index) {
1524 std::string key("the first key");
1525 disk_cache::Entry* entry;
1526 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1527 entry->Doom();
1528
1529 FlushQueueForTest();
1530 EXPECT_EQ(0, cache_->GetEntryCount());
1531 Time initial = Time::Now();
1532 AddDelay();
1533
1534 const int kSize1 = 2000;
1535 const int kSize2 = 2000;
1536 scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
1537 scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize2));
1538 CacheTestFillBuffer(buffer1->data(), kSize1, false);
1539 memset(buffer2->data(), 0, kSize2);
1540
1541 EXPECT_EQ(2000,
1542 WriteData(entry, stream_index, 0, buffer1.get(), 2000, false));
1543 EXPECT_EQ(2000, ReadData(entry, stream_index, 0, buffer2.get(), 2000));
1544 EXPECT_EQ(0, memcmp(buffer1->data(), buffer2->data(), kSize1));
1545 EXPECT_EQ(key, entry->GetKey());
1546 EXPECT_TRUE(initial < entry->GetLastModified());
1547 EXPECT_TRUE(initial < entry->GetLastUsed());
1548
1549 entry->Close();
1550 }
1551
1552 TEST_F(DiskCacheEntryTest, DoomedEntry) {
1553 InitCache();
1554 DoomedEntry(0);
1555 }
1556
1557 TEST_F(DiskCacheEntryTest, MemoryOnlyDoomedEntry) {
1558 SetMemoryOnlyMode();
1559 InitCache();
1560 DoomedEntry(0);
1561 }
1562
1563 // Tests that we discard entries if the data is missing.
1564 TEST_F(DiskCacheEntryTest, MissingData) {
1565 InitCache();
1566
1567 std::string key("the first key");
1568 disk_cache::Entry* entry;
1569 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1570
1571 // Write to an external file.
1572 const int kSize = 20000;
1573 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
1574 CacheTestFillBuffer(buffer->data(), kSize, false);
1575 EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
1576 entry->Close();
1577 FlushQueueForTest();
1578
1579 disk_cache::Addr address(0x80000001);
1580 base::FilePath name = cache_impl_->GetFileName(address);
1581 EXPECT_TRUE(base::DeleteFile(name, false));
1582
1583 // Attempt to read the data.
1584 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
1585 EXPECT_EQ(net::ERR_FILE_NOT_FOUND,
1586 ReadData(entry, 0, 0, buffer.get(), kSize));
1587 entry->Close();
1588
1589 // The entry should be gone.
1590 ASSERT_NE(net::OK, OpenEntry(key, &entry));
1591 }
1592
1593 // Test that child entries in a memory cache backend are not visible from
1594 // enumerations.
1595 TEST_F(DiskCacheEntryTest, MemoryOnlyEnumerationWithSparseEntries) {
1596 SetMemoryOnlyMode();
1597 InitCache();
1598
1599 const int kSize = 4096;
1600 scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
1601 CacheTestFillBuffer(buf->data(), kSize, false);
1602
1603 std::string key("the first key");
1604 disk_cache::Entry* parent_entry;
1605 ASSERT_EQ(net::OK, CreateEntry(key, &parent_entry));
1606
1607 // Writes to the parent entry.
1608 EXPECT_EQ(kSize,
1609 parent_entry->WriteSparseData(
1610 0, buf.get(), kSize, net::CompletionCallback()));
1611
1612 // This write creates a child entry and writes to it.
1613 EXPECT_EQ(kSize,
1614 parent_entry->WriteSparseData(
1615 8192, buf.get(), kSize, net::CompletionCallback()));
1616
1617 parent_entry->Close();
1618
1619 // Perform the enumerations.
1620 scoped_ptr<TestIterator> iter = CreateIterator();
1621 disk_cache::Entry* entry = NULL;
1622 int count = 0;
1623 while (iter->OpenNextEntry(&entry) == net::OK) {
1624 ASSERT_TRUE(entry != NULL);
1625 ++count;
1626 disk_cache::MemEntryImpl* mem_entry =
1627 reinterpret_cast<disk_cache::MemEntryImpl*>(entry);
1628 EXPECT_EQ(disk_cache::MemEntryImpl::kParentEntry, mem_entry->type());
1629 mem_entry->Close();
1630 }
1631 EXPECT_EQ(1, count);
1632 }
1633
1634 // Writes |buf_1| to offset and reads it back as |buf_2|.
1635 void VerifySparseIO(disk_cache::Entry* entry, int64 offset,
1636 net::IOBuffer* buf_1, int size, net::IOBuffer* buf_2) {
1637 net::TestCompletionCallback cb;
1638
1639 memset(buf_2->data(), 0, size);
1640 int ret = entry->ReadSparseData(offset, buf_2, size, cb.callback());
1641 EXPECT_EQ(0, cb.GetResult(ret));
1642
1643 ret = entry->WriteSparseData(offset, buf_1, size, cb.callback());
1644 EXPECT_EQ(size, cb.GetResult(ret));
1645
1646 ret = entry->ReadSparseData(offset, buf_2, size, cb.callback());
1647 EXPECT_EQ(size, cb.GetResult(ret));
1648
1649 EXPECT_EQ(0, memcmp(buf_1->data(), buf_2->data(), size));
1650 }
1651
1652 // Reads |size| bytes from |entry| at |offset| and verifies that they are the
1653 // same as the content of the provided |buffer|.
1654 void VerifyContentSparseIO(disk_cache::Entry* entry, int64 offset, char* buffer,
1655 int size) {
1656 net::TestCompletionCallback cb;
1657
1658 scoped_refptr<net::IOBuffer> buf_1(new net::IOBuffer(size));
1659 memset(buf_1->data(), 0, size);
1660 int ret = entry->ReadSparseData(offset, buf_1.get(), size, cb.callback());
1661 EXPECT_EQ(size, cb.GetResult(ret));
1662 EXPECT_EQ(0, memcmp(buf_1->data(), buffer, size));
1663 }
1664
1665 void DiskCacheEntryTest::BasicSparseIO() {
1666 std::string key("the first key");
1667 disk_cache::Entry* entry;
1668 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1669
1670 const int kSize = 2048;
1671 scoped_refptr<net::IOBuffer> buf_1(new net::IOBuffer(kSize));
1672 scoped_refptr<net::IOBuffer> buf_2(new net::IOBuffer(kSize));
1673 CacheTestFillBuffer(buf_1->data(), kSize, false);
1674
1675 // Write at offset 0.
1676 VerifySparseIO(entry, 0, buf_1.get(), kSize, buf_2.get());
1677
1678 // Write at offset 0x400000 (4 MB).
1679 VerifySparseIO(entry, 0x400000, buf_1.get(), kSize, buf_2.get());
1680
1681 // Write at offset 0x800000000 (32 GB).
1682 VerifySparseIO(entry, 0x800000000LL, buf_1.get(), kSize, buf_2.get());
1683
1684 entry->Close();
1685
1686 // Check everything again.
1687 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
1688 VerifyContentSparseIO(entry, 0, buf_1->data(), kSize);
1689 VerifyContentSparseIO(entry, 0x400000, buf_1->data(), kSize);
1690 VerifyContentSparseIO(entry, 0x800000000LL, buf_1->data(), kSize);
1691 entry->Close();
1692 }
1693
1694 TEST_F(DiskCacheEntryTest, BasicSparseIO) {
1695 InitCache();
1696 BasicSparseIO();
1697 }
1698
1699 TEST_F(DiskCacheEntryTest, MemoryOnlyBasicSparseIO) {
1700 SetMemoryOnlyMode();
1701 InitCache();
1702 BasicSparseIO();
1703 }
1704
1705 void DiskCacheEntryTest::HugeSparseIO() {
1706 std::string key("the first key");
1707 disk_cache::Entry* entry;
1708 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1709
1710 // Write 1.2 MB so that we cover multiple entries.
1711 const int kSize = 1200 * 1024;
1712 scoped_refptr<net::IOBuffer> buf_1(new net::IOBuffer(kSize));
1713 scoped_refptr<net::IOBuffer> buf_2(new net::IOBuffer(kSize));
1714 CacheTestFillBuffer(buf_1->data(), kSize, false);
1715
1716 // Write at offset 0x20F0000 (33 MB - 64 KB).
1717 VerifySparseIO(entry, 0x20F0000, buf_1.get(), kSize, buf_2.get());
1718 entry->Close();
1719
1720 // Check it again.
1721 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
1722 VerifyContentSparseIO(entry, 0x20F0000, buf_1->data(), kSize);
1723 entry->Close();
1724 }
1725
1726 TEST_F(DiskCacheEntryTest, HugeSparseIO) {
1727 InitCache();
1728 HugeSparseIO();
1729 }
1730
1731 TEST_F(DiskCacheEntryTest, MemoryOnlyHugeSparseIO) {
1732 SetMemoryOnlyMode();
1733 InitCache();
1734 HugeSparseIO();
1735 }
1736
1737 void DiskCacheEntryTest::GetAvailableRange() {
1738 std::string key("the first key");
1739 disk_cache::Entry* entry;
1740 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1741
1742 const int kSize = 16 * 1024;
1743 scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
1744 CacheTestFillBuffer(buf->data(), kSize, false);
1745
1746 // Write at offset 0x20F0000 (33 MB - 64 KB), and 0x20F4400 (33 MB - 47 KB).
1747 EXPECT_EQ(kSize, WriteSparseData(entry, 0x20F0000, buf.get(), kSize));
1748 EXPECT_EQ(kSize, WriteSparseData(entry, 0x20F4400, buf.get(), kSize));
1749
1750 // We stop at the first empty block.
1751 int64 start;
1752 net::TestCompletionCallback cb;
1753 int rv = entry->GetAvailableRange(
1754 0x20F0000, kSize * 2, &start, cb.callback());
1755 EXPECT_EQ(kSize, cb.GetResult(rv));
1756 EXPECT_EQ(0x20F0000, start);
1757
1758 start = 0;
1759 rv = entry->GetAvailableRange(0, kSize, &start, cb.callback());
1760 EXPECT_EQ(0, cb.GetResult(rv));
1761 rv = entry->GetAvailableRange(
1762 0x20F0000 - kSize, kSize, &start, cb.callback());
1763 EXPECT_EQ(0, cb.GetResult(rv));
1764 rv = entry->GetAvailableRange(0, 0x2100000, &start, cb.callback());
1765 EXPECT_EQ(kSize, cb.GetResult(rv));
1766 EXPECT_EQ(0x20F0000, start);
1767
1768 // We should be able to Read based on the results of GetAvailableRange.
1769 start = -1;
1770 rv = entry->GetAvailableRange(0x2100000, kSize, &start, cb.callback());
1771 EXPECT_EQ(0, cb.GetResult(rv));
1772 rv = entry->ReadSparseData(start, buf.get(), kSize, cb.callback());
1773 EXPECT_EQ(0, cb.GetResult(rv));
1774
1775 start = 0;
1776 rv = entry->GetAvailableRange(0x20F2000, kSize, &start, cb.callback());
1777 EXPECT_EQ(0x2000, cb.GetResult(rv));
1778 EXPECT_EQ(0x20F2000, start);
1779 EXPECT_EQ(0x2000, ReadSparseData(entry, start, buf.get(), kSize));
1780
1781 // Make sure that we respect the |len| argument.
1782 start = 0;
1783 rv = entry->GetAvailableRange(
1784 0x20F0001 - kSize, kSize, &start, cb.callback());
1785 EXPECT_EQ(1, cb.GetResult(rv));
1786 EXPECT_EQ(0x20F0000, start);
1787
1788 entry->Close();
1789 }
1790
1791 TEST_F(DiskCacheEntryTest, GetAvailableRange) {
1792 InitCache();
1793 GetAvailableRange();
1794 }
1795
1796 TEST_F(DiskCacheEntryTest, MemoryOnlyGetAvailableRange) {
1797 SetMemoryOnlyMode();
1798 InitCache();
1799 GetAvailableRange();
1800 }
1801
1802 // Tests that non-sequential writes that are not aligned with the minimum sparse
1803 // data granularity (1024 bytes) do in fact result in dropped data.
1804 TEST_F(DiskCacheEntryTest, SparseWriteDropped) {
1805 InitCache();
1806 std::string key("the first key");
1807 disk_cache::Entry* entry;
1808 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1809
1810 const int kSize = 180;
1811 scoped_refptr<net::IOBuffer> buf_1(new net::IOBuffer(kSize));
1812 scoped_refptr<net::IOBuffer> buf_2(new net::IOBuffer(kSize));
1813 CacheTestFillBuffer(buf_1->data(), kSize, false);
1814
1815 // Do small writes (180 bytes) that get increasingly close to a 1024-byte
1816 // boundary. All data should be dropped until a boundary is crossed, at which
1817 // point the data after the boundary is saved (at least for a while).
1818 int offset = 1024 - 500;
1819 int rv = 0;
1820 net::TestCompletionCallback cb;
1821 int64 start;
1822 for (int i = 0; i < 5; i++) {
1823 // Check result of last GetAvailableRange.
1824 EXPECT_EQ(0, rv);
1825
1826 rv = entry->WriteSparseData(offset, buf_1.get(), kSize, cb.callback());
1827 EXPECT_EQ(kSize, cb.GetResult(rv));
1828
1829 rv = entry->GetAvailableRange(offset - 100, kSize, &start, cb.callback());
1830 EXPECT_EQ(0, cb.GetResult(rv));
1831
1832 rv = entry->GetAvailableRange(offset, kSize, &start, cb.callback());
1833 rv = cb.GetResult(rv);
1834 if (!rv) {
1835 rv = entry->ReadSparseData(offset, buf_2.get(), kSize, cb.callback());
1836 EXPECT_EQ(0, cb.GetResult(rv));
1837 rv = 0;
1838 }
1839 offset += 1024 * i + 100;
1840 }
1841
1842 // The last write started 100 bytes below a bundary, so there should be 80
1843 // bytes after the boundary.
1844 EXPECT_EQ(80, rv);
1845 EXPECT_EQ(1024 * 7, start);
1846 rv = entry->ReadSparseData(start, buf_2.get(), kSize, cb.callback());
1847 EXPECT_EQ(80, cb.GetResult(rv));
1848 EXPECT_EQ(0, memcmp(buf_1.get()->data() + 100, buf_2.get()->data(), 80));
1849
1850 // And even that part is dropped when another write changes the offset.
1851 offset = start;
1852 rv = entry->WriteSparseData(0, buf_1.get(), kSize, cb.callback());
1853 EXPECT_EQ(kSize, cb.GetResult(rv));
1854
1855 rv = entry->GetAvailableRange(offset, kSize, &start, cb.callback());
1856 EXPECT_EQ(0, cb.GetResult(rv));
1857 entry->Close();
1858 }
1859
1860 // Tests that small sequential writes are not dropped.
1861 TEST_F(DiskCacheEntryTest, SparseSquentialWriteNotDropped) {
1862 InitCache();
1863 std::string key("the first key");
1864 disk_cache::Entry* entry;
1865 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1866
1867 const int kSize = 180;
1868 scoped_refptr<net::IOBuffer> buf_1(new net::IOBuffer(kSize));
1869 scoped_refptr<net::IOBuffer> buf_2(new net::IOBuffer(kSize));
1870 CacheTestFillBuffer(buf_1->data(), kSize, false);
1871
1872 // Any starting offset is fine as long as it is 1024-bytes aligned.
1873 int rv = 0;
1874 net::TestCompletionCallback cb;
1875 int64 start;
1876 int64 offset = 1024 * 11;
1877 for (; offset < 20000; offset += kSize) {
1878 rv = entry->WriteSparseData(offset, buf_1.get(), kSize, cb.callback());
1879 EXPECT_EQ(kSize, cb.GetResult(rv));
1880
1881 rv = entry->GetAvailableRange(offset, kSize, &start, cb.callback());
1882 EXPECT_EQ(kSize, cb.GetResult(rv));
1883 EXPECT_EQ(offset, start);
1884
1885 rv = entry->ReadSparseData(offset, buf_2.get(), kSize, cb.callback());
1886 EXPECT_EQ(kSize, cb.GetResult(rv));
1887 EXPECT_EQ(0, memcmp(buf_1.get()->data(), buf_2.get()->data(), kSize));
1888 }
1889
1890 entry->Close();
1891 FlushQueueForTest();
1892
1893 // Verify again the last write made.
1894 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
1895 offset -= kSize;
1896 rv = entry->GetAvailableRange(offset, kSize, &start, cb.callback());
1897 EXPECT_EQ(kSize, cb.GetResult(rv));
1898 EXPECT_EQ(offset, start);
1899
1900 rv = entry->ReadSparseData(offset, buf_2.get(), kSize, cb.callback());
1901 EXPECT_EQ(kSize, cb.GetResult(rv));
1902 EXPECT_EQ(0, memcmp(buf_1.get()->data(), buf_2.get()->data(), kSize));
1903
1904 entry->Close();
1905 }
1906
1907 void DiskCacheEntryTest::CouldBeSparse() {
1908 std::string key("the first key");
1909 disk_cache::Entry* entry;
1910 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1911
1912 const int kSize = 16 * 1024;
1913 scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
1914 CacheTestFillBuffer(buf->data(), kSize, false);
1915
1916 // Write at offset 0x20F0000 (33 MB - 64 KB).
1917 EXPECT_EQ(kSize, WriteSparseData(entry, 0x20F0000, buf.get(), kSize));
1918
1919 EXPECT_TRUE(entry->CouldBeSparse());
1920 entry->Close();
1921
1922 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
1923 EXPECT_TRUE(entry->CouldBeSparse());
1924 entry->Close();
1925
1926 // Now verify a regular entry.
1927 key.assign("another key");
1928 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1929 EXPECT_FALSE(entry->CouldBeSparse());
1930
1931 EXPECT_EQ(kSize, WriteData(entry, 0, 0, buf.get(), kSize, false));
1932 EXPECT_EQ(kSize, WriteData(entry, 1, 0, buf.get(), kSize, false));
1933 EXPECT_EQ(kSize, WriteData(entry, 2, 0, buf.get(), kSize, false));
1934
1935 EXPECT_FALSE(entry->CouldBeSparse());
1936 entry->Close();
1937
1938 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
1939 EXPECT_FALSE(entry->CouldBeSparse());
1940 entry->Close();
1941 }
1942
1943 TEST_F(DiskCacheEntryTest, CouldBeSparse) {
1944 InitCache();
1945 CouldBeSparse();
1946 }
1947
1948 TEST_F(DiskCacheEntryTest, MemoryCouldBeSparse) {
1949 SetMemoryOnlyMode();
1950 InitCache();
1951 CouldBeSparse();
1952 }
1953
1954 TEST_F(DiskCacheEntryTest, MemoryOnlyMisalignedSparseIO) {
1955 SetMemoryOnlyMode();
1956 InitCache();
1957
1958 const int kSize = 8192;
1959 scoped_refptr<net::IOBuffer> buf_1(new net::IOBuffer(kSize));
1960 scoped_refptr<net::IOBuffer> buf_2(new net::IOBuffer(kSize));
1961 CacheTestFillBuffer(buf_1->data(), kSize, false);
1962
1963 std::string key("the first key");
1964 disk_cache::Entry* entry;
1965 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1966
1967 // This loop writes back to back starting from offset 0 and 9000.
1968 for (int i = 0; i < kSize; i += 1024) {
1969 scoped_refptr<net::WrappedIOBuffer> buf_3(
1970 new net::WrappedIOBuffer(buf_1->data() + i));
1971 VerifySparseIO(entry, i, buf_3.get(), 1024, buf_2.get());
1972 VerifySparseIO(entry, 9000 + i, buf_3.get(), 1024, buf_2.get());
1973 }
1974
1975 // Make sure we have data written.
1976 VerifyContentSparseIO(entry, 0, buf_1->data(), kSize);
1977 VerifyContentSparseIO(entry, 9000, buf_1->data(), kSize);
1978
1979 // This tests a large write that spans 3 entries from a misaligned offset.
1980 VerifySparseIO(entry, 20481, buf_1.get(), 8192, buf_2.get());
1981
1982 entry->Close();
1983 }
1984
1985 TEST_F(DiskCacheEntryTest, MemoryOnlyMisalignedGetAvailableRange) {
1986 SetMemoryOnlyMode();
1987 InitCache();
1988
1989 const int kSize = 8192;
1990 scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
1991 CacheTestFillBuffer(buf->data(), kSize, false);
1992
1993 disk_cache::Entry* entry;
1994 std::string key("the first key");
1995 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1996
1997 // Writes in the middle of an entry.
1998 EXPECT_EQ(
1999 1024,
2000 entry->WriteSparseData(0, buf.get(), 1024, net::CompletionCallback()));
2001 EXPECT_EQ(
2002 1024,
2003 entry->WriteSparseData(5120, buf.get(), 1024, net::CompletionCallback()));
2004 EXPECT_EQ(1024,
2005 entry->WriteSparseData(
2006 10000, buf.get(), 1024, net::CompletionCallback()));
2007
2008 // Writes in the middle of an entry and spans 2 child entries.
2009 EXPECT_EQ(8192,
2010 entry->WriteSparseData(
2011 50000, buf.get(), 8192, net::CompletionCallback()));
2012
2013 int64 start;
2014 net::TestCompletionCallback cb;
2015 // Test that we stop at a discontinuous child at the second block.
2016 int rv = entry->GetAvailableRange(0, 10000, &start, cb.callback());
2017 EXPECT_EQ(1024, cb.GetResult(rv));
2018 EXPECT_EQ(0, start);
2019
2020 // Test that number of bytes is reported correctly when we start from the
2021 // middle of a filled region.
2022 rv = entry->GetAvailableRange(512, 10000, &start, cb.callback());
2023 EXPECT_EQ(512, cb.GetResult(rv));
2024 EXPECT_EQ(512, start);
2025
2026 // Test that we found bytes in the child of next block.
2027 rv = entry->GetAvailableRange(1024, 10000, &start, cb.callback());
2028 EXPECT_EQ(1024, cb.GetResult(rv));
2029 EXPECT_EQ(5120, start);
2030
2031 // Test that the desired length is respected. It starts within a filled
2032 // region.
2033 rv = entry->GetAvailableRange(5500, 512, &start, cb.callback());
2034 EXPECT_EQ(512, cb.GetResult(rv));
2035 EXPECT_EQ(5500, start);
2036
2037 // Test that the desired length is respected. It starts before a filled
2038 // region.
2039 rv = entry->GetAvailableRange(5000, 620, &start, cb.callback());
2040 EXPECT_EQ(500, cb.GetResult(rv));
2041 EXPECT_EQ(5120, start);
2042
2043 // Test that multiple blocks are scanned.
2044 rv = entry->GetAvailableRange(40000, 20000, &start, cb.callback());
2045 EXPECT_EQ(8192, cb.GetResult(rv));
2046 EXPECT_EQ(50000, start);
2047
2048 entry->Close();
2049 }
2050
2051 void DiskCacheEntryTest::UpdateSparseEntry() {
2052 std::string key("the first key");
2053 disk_cache::Entry* entry1;
2054 ASSERT_EQ(net::OK, CreateEntry(key, &entry1));
2055
2056 const int kSize = 2048;
2057 scoped_refptr<net::IOBuffer> buf_1(new net::IOBuffer(kSize));
2058 scoped_refptr<net::IOBuffer> buf_2(new net::IOBuffer(kSize));
2059 CacheTestFillBuffer(buf_1->data(), kSize, false);
2060
2061 // Write at offset 0.
2062 VerifySparseIO(entry1, 0, buf_1.get(), kSize, buf_2.get());
2063 entry1->Close();
2064
2065 // Write at offset 2048.
2066 ASSERT_EQ(net::OK, OpenEntry(key, &entry1));
2067 VerifySparseIO(entry1, 2048, buf_1.get(), kSize, buf_2.get());
2068
2069 disk_cache::Entry* entry2;
2070 ASSERT_EQ(net::OK, CreateEntry("the second key", &entry2));
2071
2072 entry1->Close();
2073 entry2->Close();
2074 FlushQueueForTest();
2075 if (memory_only_ || simple_cache_mode_)
2076 EXPECT_EQ(2, cache_->GetEntryCount());
2077 else
2078 EXPECT_EQ(3, cache_->GetEntryCount());
2079 }
2080
2081 TEST_F(DiskCacheEntryTest, UpdateSparseEntry) {
2082 SetCacheType(net::MEDIA_CACHE);
2083 InitCache();
2084 UpdateSparseEntry();
2085 }
2086
2087 TEST_F(DiskCacheEntryTest, MemoryOnlyUpdateSparseEntry) {
2088 SetMemoryOnlyMode();
2089 SetCacheType(net::MEDIA_CACHE);
2090 InitCache();
2091 UpdateSparseEntry();
2092 }
2093
2094 void DiskCacheEntryTest::DoomSparseEntry() {
2095 std::string key1("the first key");
2096 std::string key2("the second key");
2097 disk_cache::Entry *entry1, *entry2;
2098 ASSERT_EQ(net::OK, CreateEntry(key1, &entry1));
2099 ASSERT_EQ(net::OK, CreateEntry(key2, &entry2));
2100
2101 const int kSize = 4 * 1024;
2102 scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
2103 CacheTestFillBuffer(buf->data(), kSize, false);
2104
2105 int64 offset = 1024;
2106 // Write to a bunch of ranges.
2107 for (int i = 0; i < 12; i++) {
2108 EXPECT_EQ(kSize, WriteSparseData(entry1, offset, buf.get(), kSize));
2109 // Keep the second map under the default size.
2110 if (i < 9)
2111 EXPECT_EQ(kSize, WriteSparseData(entry2, offset, buf.get(), kSize));
2112
2113 offset *= 4;
2114 }
2115
2116 if (memory_only_ || simple_cache_mode_)
2117 EXPECT_EQ(2, cache_->GetEntryCount());
2118 else
2119 EXPECT_EQ(15, cache_->GetEntryCount());
2120
2121 // Doom the first entry while it's still open.
2122 entry1->Doom();
2123 entry1->Close();
2124 entry2->Close();
2125
2126 // Doom the second entry after it's fully saved.
2127 EXPECT_EQ(net::OK, DoomEntry(key2));
2128
2129 // Make sure we do all needed work. This may fail for entry2 if between Close
2130 // and DoomEntry the system decides to remove all traces of the file from the
2131 // system cache so we don't see that there is pending IO.
2132 base::MessageLoop::current()->RunUntilIdle();
2133
2134 if (memory_only_) {
2135 EXPECT_EQ(0, cache_->GetEntryCount());
2136 } else {
2137 if (5 == cache_->GetEntryCount()) {
2138 // Most likely we are waiting for the result of reading the sparse info
2139 // (it's always async on Posix so it is easy to miss). Unfortunately we
2140 // don't have any signal to watch for so we can only wait.
2141 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(500));
2142 base::MessageLoop::current()->RunUntilIdle();
2143 }
2144 EXPECT_EQ(0, cache_->GetEntryCount());
2145 }
2146 }
2147
2148 TEST_F(DiskCacheEntryTest, DoomSparseEntry) {
2149 UseCurrentThread();
2150 InitCache();
2151 DoomSparseEntry();
2152 }
2153
2154 TEST_F(DiskCacheEntryTest, MemoryOnlyDoomSparseEntry) {
2155 SetMemoryOnlyMode();
2156 InitCache();
2157 DoomSparseEntry();
2158 }
2159
2160 // A CompletionCallback wrapper that deletes the cache from within the callback.
2161 // The way a CompletionCallback works means that all tasks (even new ones)
2162 // are executed by the message loop before returning to the caller so the only
2163 // way to simulate a race is to execute what we want on the callback.
2164 class SparseTestCompletionCallback: public net::TestCompletionCallback {
2165 public:
2166 explicit SparseTestCompletionCallback(scoped_ptr<disk_cache::Backend> cache)
2167 : cache_(cache.Pass()) {
2168 }
2169
2170 private:
2171 void SetResult(int result) override {
2172 cache_.reset();
2173 TestCompletionCallback::SetResult(result);
2174 }
2175
2176 scoped_ptr<disk_cache::Backend> cache_;
2177 DISALLOW_COPY_AND_ASSIGN(SparseTestCompletionCallback);
2178 };
2179
2180 // Tests that we don't crash when the backend is deleted while we are working
2181 // deleting the sub-entries of a sparse entry.
2182 TEST_F(DiskCacheEntryTest, DoomSparseEntry2) {
2183 UseCurrentThread();
2184 InitCache();
2185 std::string key("the key");
2186 disk_cache::Entry* entry;
2187 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
2188
2189 const int kSize = 4 * 1024;
2190 scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
2191 CacheTestFillBuffer(buf->data(), kSize, false);
2192
2193 int64 offset = 1024;
2194 // Write to a bunch of ranges.
2195 for (int i = 0; i < 12; i++) {
2196 EXPECT_EQ(kSize,
2197 entry->WriteSparseData(
2198 offset, buf.get(), kSize, net::CompletionCallback()));
2199 offset *= 4;
2200 }
2201 EXPECT_EQ(9, cache_->GetEntryCount());
2202
2203 entry->Close();
2204 disk_cache::Backend* cache = cache_.get();
2205 SparseTestCompletionCallback cb(cache_.Pass());
2206 int rv = cache->DoomEntry(key, cb.callback());
2207 EXPECT_EQ(net::ERR_IO_PENDING, rv);
2208 EXPECT_EQ(net::OK, cb.WaitForResult());
2209 }
2210
2211 void DiskCacheEntryTest::PartialSparseEntry() {
2212 std::string key("the first key");
2213 disk_cache::Entry* entry;
2214 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
2215
2216 // We should be able to deal with IO that is not aligned to the block size
2217 // of a sparse entry, at least to write a big range without leaving holes.
2218 const int kSize = 4 * 1024;
2219 const int kSmallSize = 128;
2220 scoped_refptr<net::IOBuffer> buf1(new net::IOBuffer(kSize));
2221 CacheTestFillBuffer(buf1->data(), kSize, false);
2222
2223 // The first write is just to extend the entry. The third write occupies
2224 // a 1KB block partially, it may not be written internally depending on the
2225 // implementation.
2226 EXPECT_EQ(kSize, WriteSparseData(entry, 20000, buf1.get(), kSize));
2227 EXPECT_EQ(kSize, WriteSparseData(entry, 500, buf1.get(), kSize));
2228 EXPECT_EQ(kSmallSize,
2229 WriteSparseData(entry, 1080321, buf1.get(), kSmallSize));
2230 entry->Close();
2231 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
2232
2233 scoped_refptr<net::IOBuffer> buf2(new net::IOBuffer(kSize));
2234 memset(buf2->data(), 0, kSize);
2235 EXPECT_EQ(0, ReadSparseData(entry, 8000, buf2.get(), kSize));
2236
2237 EXPECT_EQ(500, ReadSparseData(entry, kSize, buf2.get(), kSize));
2238 EXPECT_EQ(0, memcmp(buf2->data(), buf1->data() + kSize - 500, 500));
2239 EXPECT_EQ(0, ReadSparseData(entry, 0, buf2.get(), kSize));
2240
2241 // This read should not change anything.
2242 if (memory_only_ || simple_cache_mode_)
2243 EXPECT_EQ(96, ReadSparseData(entry, 24000, buf2.get(), kSize));
2244 else
2245 EXPECT_EQ(0, ReadSparseData(entry, 24000, buf2.get(), kSize));
2246
2247 EXPECT_EQ(500, ReadSparseData(entry, kSize, buf2.get(), kSize));
2248 EXPECT_EQ(0, ReadSparseData(entry, 99, buf2.get(), kSize));
2249
2250 int rv;
2251 int64 start;
2252 net::TestCompletionCallback cb;
2253 if (memory_only_ || simple_cache_mode_) {
2254 rv = entry->GetAvailableRange(0, 600, &start, cb.callback());
2255 EXPECT_EQ(100, cb.GetResult(rv));
2256 EXPECT_EQ(500, start);
2257 } else {
2258 rv = entry->GetAvailableRange(0, 2048, &start, cb.callback());
2259 EXPECT_EQ(1024, cb.GetResult(rv));
2260 EXPECT_EQ(1024, start);
2261 }
2262 rv = entry->GetAvailableRange(kSize, kSize, &start, cb.callback());
2263 EXPECT_EQ(500, cb.GetResult(rv));
2264 EXPECT_EQ(kSize, start);
2265 rv = entry->GetAvailableRange(20 * 1024, 10000, &start, cb.callback());
2266 if (memory_only_ || simple_cache_mode_)
2267 EXPECT_EQ(3616, cb.GetResult(rv));
2268 else
2269 EXPECT_EQ(3072, cb.GetResult(rv));
2270
2271 EXPECT_EQ(20 * 1024, start);
2272
2273 // 1. Query before a filled 1KB block.
2274 // 2. Query within a filled 1KB block.
2275 // 3. Query beyond a filled 1KB block.
2276 if (memory_only_ || simple_cache_mode_) {
2277 rv = entry->GetAvailableRange(19400, kSize, &start, cb.callback());
2278 EXPECT_EQ(3496, cb.GetResult(rv));
2279 EXPECT_EQ(20000, start);
2280 } else {
2281 rv = entry->GetAvailableRange(19400, kSize, &start, cb.callback());
2282 EXPECT_EQ(3016, cb.GetResult(rv));
2283 EXPECT_EQ(20480, start);
2284 }
2285 rv = entry->GetAvailableRange(3073, kSize, &start, cb.callback());
2286 EXPECT_EQ(1523, cb.GetResult(rv));
2287 EXPECT_EQ(3073, start);
2288 rv = entry->GetAvailableRange(4600, kSize, &start, cb.callback());
2289 EXPECT_EQ(0, cb.GetResult(rv));
2290 EXPECT_EQ(4600, start);
2291
2292 // Now make another write and verify that there is no hole in between.
2293 EXPECT_EQ(kSize, WriteSparseData(entry, 500 + kSize, buf1.get(), kSize));
2294 rv = entry->GetAvailableRange(1024, 10000, &start, cb.callback());
2295 EXPECT_EQ(7 * 1024 + 500, cb.GetResult(rv));
2296 EXPECT_EQ(1024, start);
2297 EXPECT_EQ(kSize, ReadSparseData(entry, kSize, buf2.get(), kSize));
2298 EXPECT_EQ(0, memcmp(buf2->data(), buf1->data() + kSize - 500, 500));
2299 EXPECT_EQ(0, memcmp(buf2->data() + 500, buf1->data(), kSize - 500));
2300
2301 entry->Close();
2302 }
2303
2304 TEST_F(DiskCacheEntryTest, PartialSparseEntry) {
2305 InitCache();
2306 PartialSparseEntry();
2307 }
2308
2309 TEST_F(DiskCacheEntryTest, MemoryPartialSparseEntry) {
2310 SetMemoryOnlyMode();
2311 InitCache();
2312 PartialSparseEntry();
2313 }
2314
2315 // Tests that corrupt sparse children are removed automatically.
2316 TEST_F(DiskCacheEntryTest, CleanupSparseEntry) {
2317 InitCache();
2318 std::string key("the first key");
2319 disk_cache::Entry* entry;
2320 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
2321
2322 const int kSize = 4 * 1024;
2323 scoped_refptr<net::IOBuffer> buf1(new net::IOBuffer(kSize));
2324 CacheTestFillBuffer(buf1->data(), kSize, false);
2325
2326 const int k1Meg = 1024 * 1024;
2327 EXPECT_EQ(kSize, WriteSparseData(entry, 8192, buf1.get(), kSize));
2328 EXPECT_EQ(kSize, WriteSparseData(entry, k1Meg + 8192, buf1.get(), kSize));
2329 EXPECT_EQ(kSize, WriteSparseData(entry, 2 * k1Meg + 8192, buf1.get(), kSize));
2330 entry->Close();
2331 EXPECT_EQ(4, cache_->GetEntryCount());
2332
2333 scoped_ptr<TestIterator> iter = CreateIterator();
2334 int count = 0;
2335 std::string child_key[2];
2336 while (iter->OpenNextEntry(&entry) == net::OK) {
2337 ASSERT_TRUE(entry != NULL);
2338 // Writing to an entry will alter the LRU list and invalidate the iterator.
2339 if (entry->GetKey() != key && count < 2)
2340 child_key[count++] = entry->GetKey();
2341 entry->Close();
2342 }
2343 for (int i = 0; i < 2; i++) {
2344 ASSERT_EQ(net::OK, OpenEntry(child_key[i], &entry));
2345 // Overwrite the header's magic and signature.
2346 EXPECT_EQ(12, WriteData(entry, 2, 0, buf1.get(), 12, false));
2347 entry->Close();
2348 }
2349
2350 EXPECT_EQ(4, cache_->GetEntryCount());
2351 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
2352
2353 // Two children should be gone. One while reading and one while writing.
2354 EXPECT_EQ(0, ReadSparseData(entry, 2 * k1Meg + 8192, buf1.get(), kSize));
2355 EXPECT_EQ(kSize, WriteSparseData(entry, k1Meg + 16384, buf1.get(), kSize));
2356 EXPECT_EQ(0, ReadSparseData(entry, k1Meg + 8192, buf1.get(), kSize));
2357
2358 // We never touched this one.
2359 EXPECT_EQ(kSize, ReadSparseData(entry, 8192, buf1.get(), kSize));
2360 entry->Close();
2361
2362 // We re-created one of the corrupt children.
2363 EXPECT_EQ(3, cache_->GetEntryCount());
2364 }
2365
2366 TEST_F(DiskCacheEntryTest, CancelSparseIO) {
2367 UseCurrentThread();
2368 InitCache();
2369 std::string key("the first key");
2370 disk_cache::Entry* entry;
2371 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
2372
2373 const int kSize = 40 * 1024;
2374 scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
2375 CacheTestFillBuffer(buf->data(), kSize, false);
2376
2377 // This will open and write two "real" entries.
2378 net::TestCompletionCallback cb1, cb2, cb3, cb4, cb5;
2379 int rv = entry->WriteSparseData(
2380 1024 * 1024 - 4096, buf.get(), kSize, cb1.callback());
2381 EXPECT_EQ(net::ERR_IO_PENDING, rv);
2382
2383 int64 offset = 0;
2384 rv = entry->GetAvailableRange(offset, kSize, &offset, cb5.callback());
2385 rv = cb5.GetResult(rv);
2386 if (!cb1.have_result()) {
2387 // We may or may not have finished writing to the entry. If we have not,
2388 // we cannot start another operation at this time.
2389 EXPECT_EQ(net::ERR_CACHE_OPERATION_NOT_SUPPORTED, rv);
2390 }
2391
2392 // We cancel the pending operation, and register multiple notifications.
2393 entry->CancelSparseIO();
2394 EXPECT_EQ(net::ERR_IO_PENDING, entry->ReadyForSparseIO(cb2.callback()));
2395 EXPECT_EQ(net::ERR_IO_PENDING, entry->ReadyForSparseIO(cb3.callback()));
2396 entry->CancelSparseIO(); // Should be a no op at this point.
2397 EXPECT_EQ(net::ERR_IO_PENDING, entry->ReadyForSparseIO(cb4.callback()));
2398
2399 if (!cb1.have_result()) {
2400 EXPECT_EQ(net::ERR_CACHE_OPERATION_NOT_SUPPORTED,
2401 entry->ReadSparseData(
2402 offset, buf.get(), kSize, net::CompletionCallback()));
2403 EXPECT_EQ(net::ERR_CACHE_OPERATION_NOT_SUPPORTED,
2404 entry->WriteSparseData(
2405 offset, buf.get(), kSize, net::CompletionCallback()));
2406 }
2407
2408 // Now see if we receive all notifications. Note that we should not be able
2409 // to write everything (unless the timing of the system is really weird).
2410 rv = cb1.WaitForResult();
2411 EXPECT_TRUE(rv == 4096 || rv == kSize);
2412 EXPECT_EQ(net::OK, cb2.WaitForResult());
2413 EXPECT_EQ(net::OK, cb3.WaitForResult());
2414 EXPECT_EQ(net::OK, cb4.WaitForResult());
2415
2416 rv = entry->GetAvailableRange(offset, kSize, &offset, cb5.callback());
2417 EXPECT_EQ(0, cb5.GetResult(rv));
2418 entry->Close();
2419 }
2420
2421 // Tests that we perform sanity checks on an entry's key. Note that there are
2422 // other tests that exercise sanity checks by using saved corrupt files.
2423 TEST_F(DiskCacheEntryTest, KeySanityCheck) {
2424 UseCurrentThread();
2425 InitCache();
2426 std::string key("the first key");
2427 disk_cache::Entry* entry;
2428 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
2429
2430 disk_cache::EntryImpl* entry_impl =
2431 static_cast<disk_cache::EntryImpl*>(entry);
2432 disk_cache::EntryStore* store = entry_impl->entry()->Data();
2433
2434 // We have reserved space for a short key (one block), let's say that the key
2435 // takes more than one block, and remove the NULLs after the actual key.
2436 store->key_len = 800;
2437 memset(store->key + key.size(), 'k', sizeof(store->key) - key.size());
2438 entry_impl->entry()->set_modified();
2439 entry->Close();
2440
2441 // We have a corrupt entry. Now reload it. We should NOT read beyond the
2442 // allocated buffer here.
2443 ASSERT_NE(net::OK, OpenEntry(key, &entry));
2444 DisableIntegrityCheck();
2445 }
2446
2447 TEST_F(DiskCacheEntryTest, SimpleCacheInternalAsyncIO) {
2448 SetSimpleCacheMode();
2449 InitCache();
2450 InternalAsyncIO();
2451 }
2452
2453 TEST_F(DiskCacheEntryTest, SimpleCacheExternalAsyncIO) {
2454 SetSimpleCacheMode();
2455 InitCache();
2456 ExternalAsyncIO();
2457 }
2458
2459 TEST_F(DiskCacheEntryTest, SimpleCacheReleaseBuffer) {
2460 SetSimpleCacheMode();
2461 InitCache();
2462 for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) {
2463 EXPECT_EQ(net::OK, DoomAllEntries());
2464 ReleaseBuffer(i);
2465 }
2466 }
2467
2468 TEST_F(DiskCacheEntryTest, SimpleCacheStreamAccess) {
2469 SetSimpleCacheMode();
2470 InitCache();
2471 StreamAccess();
2472 }
2473
2474 TEST_F(DiskCacheEntryTest, SimpleCacheGetKey) {
2475 SetSimpleCacheMode();
2476 InitCache();
2477 GetKey();
2478 }
2479
2480 TEST_F(DiskCacheEntryTest, SimpleCacheGetTimes) {
2481 SetSimpleCacheMode();
2482 InitCache();
2483 for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) {
2484 EXPECT_EQ(net::OK, DoomAllEntries());
2485 GetTimes(i);
2486 }
2487 }
2488
2489 TEST_F(DiskCacheEntryTest, SimpleCacheGrowData) {
2490 SetSimpleCacheMode();
2491 InitCache();
2492 for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) {
2493 EXPECT_EQ(net::OK, DoomAllEntries());
2494 GrowData(i);
2495 }
2496 }
2497
2498 TEST_F(DiskCacheEntryTest, SimpleCacheTruncateData) {
2499 SetSimpleCacheMode();
2500 InitCache();
2501 for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) {
2502 EXPECT_EQ(net::OK, DoomAllEntries());
2503 TruncateData(i);
2504 }
2505 }
2506
2507 TEST_F(DiskCacheEntryTest, SimpleCacheZeroLengthIO) {
2508 SetSimpleCacheMode();
2509 InitCache();
2510 for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) {
2511 EXPECT_EQ(net::OK, DoomAllEntries());
2512 ZeroLengthIO(i);
2513 }
2514 }
2515
2516 TEST_F(DiskCacheEntryTest, SimpleCacheSizeAtCreate) {
2517 SetSimpleCacheMode();
2518 InitCache();
2519 SizeAtCreate();
2520 }
2521
2522 TEST_F(DiskCacheEntryTest, SimpleCacheReuseExternalEntry) {
2523 SetSimpleCacheMode();
2524 SetMaxSize(200 * 1024);
2525 InitCache();
2526 for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) {
2527 EXPECT_EQ(net::OK, DoomAllEntries());
2528 ReuseEntry(20 * 1024, i);
2529 }
2530 }
2531
2532 TEST_F(DiskCacheEntryTest, SimpleCacheReuseInternalEntry) {
2533 SetSimpleCacheMode();
2534 SetMaxSize(100 * 1024);
2535 InitCache();
2536 for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) {
2537 EXPECT_EQ(net::OK, DoomAllEntries());
2538 ReuseEntry(10 * 1024, i);
2539 }
2540 }
2541
2542 TEST_F(DiskCacheEntryTest, SimpleCacheSizeChanges) {
2543 SetSimpleCacheMode();
2544 InitCache();
2545 for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) {
2546 EXPECT_EQ(net::OK, DoomAllEntries());
2547 SizeChanges(i);
2548 }
2549 }
2550
2551 TEST_F(DiskCacheEntryTest, SimpleCacheInvalidData) {
2552 SetSimpleCacheMode();
2553 InitCache();
2554 for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) {
2555 EXPECT_EQ(net::OK, DoomAllEntries());
2556 InvalidData(i);
2557 }
2558 }
2559
2560 TEST_F(DiskCacheEntryTest, SimpleCacheReadWriteDestroyBuffer) {
2561 // Proving that the test works well with optimistic operations enabled is
2562 // subtle, instead run only in APP_CACHE mode to disable optimistic
2563 // operations. Stream 0 always uses optimistic operations, so the test is not
2564 // run on stream 0.
2565 SetCacheType(net::APP_CACHE);
2566 SetSimpleCacheMode();
2567 InitCache();
2568 for (int i = 1; i < disk_cache::kSimpleEntryStreamCount; ++i) {
2569 EXPECT_EQ(net::OK, DoomAllEntries());
2570 ReadWriteDestroyBuffer(i);
2571 }
2572 }
2573
2574 TEST_F(DiskCacheEntryTest, SimpleCacheDoomEntry) {
2575 SetSimpleCacheMode();
2576 InitCache();
2577 DoomNormalEntry();
2578 }
2579
2580 TEST_F(DiskCacheEntryTest, SimpleCacheDoomEntryNextToOpenEntry) {
2581 SetSimpleCacheMode();
2582 InitCache();
2583 DoomEntryNextToOpenEntry();
2584 }
2585
2586 TEST_F(DiskCacheEntryTest, SimpleCacheDoomedEntry) {
2587 SetSimpleCacheMode();
2588 InitCache();
2589 // Stream 2 is excluded because the implementation does not support writing to
2590 // it on a doomed entry, if it was previously lazily omitted.
2591 for (int i = 0; i < disk_cache::kSimpleEntryStreamCount - 1; ++i) {
2592 EXPECT_EQ(net::OK, DoomAllEntries());
2593 DoomedEntry(i);
2594 }
2595 }
2596
2597 // Creates an entry with corrupted last byte in stream 0.
2598 // Requires SimpleCacheMode.
2599 bool DiskCacheEntryTest::SimpleCacheMakeBadChecksumEntry(const std::string& key,
2600 int* data_size) {
2601 disk_cache::Entry* entry = NULL;
2602
2603 if (CreateEntry(key, &entry) != net::OK || !entry) {
2604 LOG(ERROR) << "Could not create entry";
2605 return false;
2606 }
2607
2608 const char data[] = "this is very good data";
2609 const int kDataSize = arraysize(data);
2610 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kDataSize));
2611 base::strlcpy(buffer->data(), data, kDataSize);
2612
2613 EXPECT_EQ(kDataSize, WriteData(entry, 1, 0, buffer.get(), kDataSize, false));
2614 entry->Close();
2615 entry = NULL;
2616
2617 // Corrupt the last byte of the data.
2618 base::FilePath entry_file0_path = cache_path_.AppendASCII(
2619 disk_cache::simple_util::GetFilenameFromKeyAndFileIndex(key, 0));
2620 base::File entry_file0(entry_file0_path,
2621 base::File::FLAG_WRITE | base::File::FLAG_OPEN);
2622 if (!entry_file0.IsValid())
2623 return false;
2624
2625 int64 file_offset =
2626 sizeof(disk_cache::SimpleFileHeader) + key.size() + kDataSize - 2;
2627 EXPECT_EQ(1, entry_file0.Write(file_offset, "X", 1));
2628 *data_size = kDataSize;
2629 return true;
2630 }
2631
2632 // Tests that the simple cache can detect entries that have bad data.
2633 TEST_F(DiskCacheEntryTest, SimpleCacheBadChecksum) {
2634 SetSimpleCacheMode();
2635 InitCache();
2636
2637 const char key[] = "the first key";
2638 int size_unused;
2639 ASSERT_TRUE(SimpleCacheMakeBadChecksumEntry(key, &size_unused));
2640
2641 disk_cache::Entry* entry = NULL;
2642
2643 // Open the entry.
2644 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
2645 ScopedEntryPtr entry_closer(entry);
2646
2647 const int kReadBufferSize = 200;
2648 EXPECT_GE(kReadBufferSize, entry->GetDataSize(1));
2649 scoped_refptr<net::IOBuffer> read_buffer(new net::IOBuffer(kReadBufferSize));
2650 EXPECT_EQ(net::ERR_CACHE_CHECKSUM_MISMATCH,
2651 ReadData(entry, 1, 0, read_buffer.get(), kReadBufferSize));
2652 }
2653
2654 // Tests that an entry that has had an IO error occur can still be Doomed().
2655 TEST_F(DiskCacheEntryTest, SimpleCacheErrorThenDoom) {
2656 SetSimpleCacheMode();
2657 InitCache();
2658
2659 const char key[] = "the first key";
2660 int size_unused;
2661 ASSERT_TRUE(SimpleCacheMakeBadChecksumEntry(key, &size_unused));
2662
2663 disk_cache::Entry* entry = NULL;
2664
2665 // Open the entry, forcing an IO error.
2666 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
2667 ScopedEntryPtr entry_closer(entry);
2668
2669 const int kReadBufferSize = 200;
2670 EXPECT_GE(kReadBufferSize, entry->GetDataSize(1));
2671 scoped_refptr<net::IOBuffer> read_buffer(new net::IOBuffer(kReadBufferSize));
2672 EXPECT_EQ(net::ERR_CACHE_CHECKSUM_MISMATCH,
2673 ReadData(entry, 1, 0, read_buffer.get(), kReadBufferSize));
2674
2675 entry->Doom(); // Should not crash.
2676 }
2677
2678 bool TruncatePath(const base::FilePath& file_path, int64 length) {
2679 base::File file(file_path, base::File::FLAG_WRITE | base::File::FLAG_OPEN);
2680 if (!file.IsValid())
2681 return false;
2682 return file.SetLength(length);
2683 }
2684
2685 TEST_F(DiskCacheEntryTest, SimpleCacheNoEOF) {
2686 SetSimpleCacheMode();
2687 InitCache();
2688
2689 const char key[] = "the first key";
2690
2691 disk_cache::Entry* entry = NULL;
2692 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
2693 disk_cache::Entry* null = NULL;
2694 EXPECT_NE(null, entry);
2695 entry->Close();
2696 entry = NULL;
2697
2698 // Force the entry to flush to disk, so subsequent platform file operations
2699 // succed.
2700 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
2701 entry->Close();
2702 entry = NULL;
2703
2704 // Truncate the file such that the length isn't sufficient to have an EOF
2705 // record.
2706 int kTruncationBytes = -implicit_cast<int>(sizeof(disk_cache::SimpleFileEOF));
2707 const base::FilePath entry_path = cache_path_.AppendASCII(
2708 disk_cache::simple_util::GetFilenameFromKeyAndFileIndex(key, 0));
2709 const int64 invalid_size =
2710 disk_cache::simple_util::GetFileSizeFromKeyAndDataSize(key,
2711 kTruncationBytes);
2712 EXPECT_TRUE(TruncatePath(entry_path, invalid_size));
2713 EXPECT_EQ(net::ERR_FAILED, OpenEntry(key, &entry));
2714 DisableIntegrityCheck();
2715 }
2716
2717 TEST_F(DiskCacheEntryTest, SimpleCacheNonOptimisticOperationsBasic) {
2718 // Test sequence:
2719 // Create, Write, Read, Close.
2720 SetCacheType(net::APP_CACHE); // APP_CACHE doesn't use optimistic operations.
2721 SetSimpleCacheMode();
2722 InitCache();
2723 disk_cache::Entry* const null_entry = NULL;
2724
2725 disk_cache::Entry* entry = NULL;
2726 EXPECT_EQ(net::OK, CreateEntry("my key", &entry));
2727 ASSERT_NE(null_entry, entry);
2728 ScopedEntryPtr entry_closer(entry);
2729
2730 const int kBufferSize = 10;
2731 scoped_refptr<net::IOBufferWithSize> write_buffer(
2732 new net::IOBufferWithSize(kBufferSize));
2733 CacheTestFillBuffer(write_buffer->data(), write_buffer->size(), false);
2734 EXPECT_EQ(
2735 write_buffer->size(),
2736 WriteData(entry, 1, 0, write_buffer.get(), write_buffer->size(), false));
2737
2738 scoped_refptr<net::IOBufferWithSize> read_buffer(
2739 new net::IOBufferWithSize(kBufferSize));
2740 EXPECT_EQ(read_buffer->size(),
2741 ReadData(entry, 1, 0, read_buffer.get(), read_buffer->size()));
2742 }
2743
2744 TEST_F(DiskCacheEntryTest, SimpleCacheNonOptimisticOperationsDontBlock) {
2745 // Test sequence:
2746 // Create, Write, Close.
2747 SetCacheType(net::APP_CACHE); // APP_CACHE doesn't use optimistic operations.
2748 SetSimpleCacheMode();
2749 InitCache();
2750 disk_cache::Entry* const null_entry = NULL;
2751
2752 MessageLoopHelper helper;
2753 CallbackTest create_callback(&helper, false);
2754
2755 int expected_callback_runs = 0;
2756 const int kBufferSize = 10;
2757 scoped_refptr<net::IOBufferWithSize> write_buffer(
2758 new net::IOBufferWithSize(kBufferSize));
2759
2760 disk_cache::Entry* entry = NULL;
2761 EXPECT_EQ(net::OK, CreateEntry("my key", &entry));
2762 ASSERT_NE(null_entry, entry);
2763 ScopedEntryPtr entry_closer(entry);
2764
2765 CacheTestFillBuffer(write_buffer->data(), write_buffer->size(), false);
2766 CallbackTest write_callback(&helper, false);
2767 int ret = entry->WriteData(
2768 1,
2769 0,
2770 write_buffer.get(),
2771 write_buffer->size(),
2772 base::Bind(&CallbackTest::Run, base::Unretained(&write_callback)),
2773 false);
2774 ASSERT_EQ(net::ERR_IO_PENDING, ret);
2775 helper.WaitUntilCacheIoFinished(++expected_callback_runs);
2776 }
2777
2778 TEST_F(DiskCacheEntryTest,
2779 SimpleCacheNonOptimisticOperationsBasicsWithoutWaiting) {
2780 // Test sequence:
2781 // Create, Write, Read, Close.
2782 SetCacheType(net::APP_CACHE); // APP_CACHE doesn't use optimistic operations.
2783 SetSimpleCacheMode();
2784 InitCache();
2785 disk_cache::Entry* const null_entry = NULL;
2786 MessageLoopHelper helper;
2787
2788 disk_cache::Entry* entry = NULL;
2789 // Note that |entry| is only set once CreateEntry() completed which is why we
2790 // have to wait (i.e. use the helper CreateEntry() function).
2791 EXPECT_EQ(net::OK, CreateEntry("my key", &entry));
2792 ASSERT_NE(null_entry, entry);
2793 ScopedEntryPtr entry_closer(entry);
2794
2795 const int kBufferSize = 10;
2796 scoped_refptr<net::IOBufferWithSize> write_buffer(
2797 new net::IOBufferWithSize(kBufferSize));
2798 CacheTestFillBuffer(write_buffer->data(), write_buffer->size(), false);
2799 CallbackTest write_callback(&helper, false);
2800 int ret = entry->WriteData(
2801 1,
2802 0,
2803 write_buffer.get(),
2804 write_buffer->size(),
2805 base::Bind(&CallbackTest::Run, base::Unretained(&write_callback)),
2806 false);
2807 EXPECT_EQ(net::ERR_IO_PENDING, ret);
2808 int expected_callback_runs = 1;
2809
2810 scoped_refptr<net::IOBufferWithSize> read_buffer(
2811 new net::IOBufferWithSize(kBufferSize));
2812 CallbackTest read_callback(&helper, false);
2813 ret = entry->ReadData(
2814 1,
2815 0,
2816 read_buffer.get(),
2817 read_buffer->size(),
2818 base::Bind(&CallbackTest::Run, base::Unretained(&read_callback)));
2819 EXPECT_EQ(net::ERR_IO_PENDING, ret);
2820 ++expected_callback_runs;
2821
2822 helper.WaitUntilCacheIoFinished(expected_callback_runs);
2823 ASSERT_EQ(read_buffer->size(), write_buffer->size());
2824 EXPECT_EQ(
2825 0,
2826 memcmp(read_buffer->data(), write_buffer->data(), read_buffer->size()));
2827 }
2828
2829 TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic) {
2830 // Test sequence:
2831 // Create, Write, Read, Write, Read, Close.
2832 SetSimpleCacheMode();
2833 InitCache();
2834 disk_cache::Entry* null = NULL;
2835 const char key[] = "the first key";
2836
2837 MessageLoopHelper helper;
2838 CallbackTest callback1(&helper, false);
2839 CallbackTest callback2(&helper, false);
2840 CallbackTest callback3(&helper, false);
2841 CallbackTest callback4(&helper, false);
2842 CallbackTest callback5(&helper, false);
2843
2844 int expected = 0;
2845 const int kSize1 = 10;
2846 const int kSize2 = 20;
2847 scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
2848 scoped_refptr<net::IOBuffer> buffer1_read(new net::IOBuffer(kSize1));
2849 scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize2));
2850 scoped_refptr<net::IOBuffer> buffer2_read(new net::IOBuffer(kSize2));
2851 CacheTestFillBuffer(buffer1->data(), kSize1, false);
2852 CacheTestFillBuffer(buffer2->data(), kSize2, false);
2853
2854 disk_cache::Entry* entry = NULL;
2855 // Create is optimistic, must return OK.
2856 ASSERT_EQ(net::OK,
2857 cache_->CreateEntry(key, &entry,
2858 base::Bind(&CallbackTest::Run,
2859 base::Unretained(&callback1))));
2860 EXPECT_NE(null, entry);
2861 ScopedEntryPtr entry_closer(entry);
2862
2863 // This write may or may not be optimistic (it depends if the previous
2864 // optimistic create already finished by the time we call the write here).
2865 int ret = entry->WriteData(
2866 1,
2867 0,
2868 buffer1.get(),
2869 kSize1,
2870 base::Bind(&CallbackTest::Run, base::Unretained(&callback2)),
2871 false);
2872 EXPECT_TRUE(kSize1 == ret || net::ERR_IO_PENDING == ret);
2873 if (net::ERR_IO_PENDING == ret)
2874 expected++;
2875
2876 // This Read must not be optimistic, since we don't support that yet.
2877 EXPECT_EQ(net::ERR_IO_PENDING,
2878 entry->ReadData(
2879 1,
2880 0,
2881 buffer1_read.get(),
2882 kSize1,
2883 base::Bind(&CallbackTest::Run, base::Unretained(&callback3))));
2884 expected++;
2885 EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
2886 EXPECT_EQ(0, memcmp(buffer1->data(), buffer1_read->data(), kSize1));
2887
2888 // At this point after waiting, the pending operations queue on the entry
2889 // should be empty, so the next Write operation must run as optimistic.
2890 EXPECT_EQ(kSize2,
2891 entry->WriteData(
2892 1,
2893 0,
2894 buffer2.get(),
2895 kSize2,
2896 base::Bind(&CallbackTest::Run, base::Unretained(&callback4)),
2897 false));
2898
2899 // Lets do another read so we block until both the write and the read
2900 // operation finishes and we can then test for HasOneRef() below.
2901 EXPECT_EQ(net::ERR_IO_PENDING,
2902 entry->ReadData(
2903 1,
2904 0,
2905 buffer2_read.get(),
2906 kSize2,
2907 base::Bind(&CallbackTest::Run, base::Unretained(&callback5))));
2908 expected++;
2909
2910 EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
2911 EXPECT_EQ(0, memcmp(buffer2->data(), buffer2_read->data(), kSize2));
2912
2913 // Check that we are not leaking.
2914 EXPECT_NE(entry, null);
2915 EXPECT_TRUE(
2916 static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef());
2917 }
2918
2919 TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic2) {
2920 // Test sequence:
2921 // Create, Open, Close, Close.
2922 SetSimpleCacheMode();
2923 InitCache();
2924 disk_cache::Entry* null = NULL;
2925 const char key[] = "the first key";
2926
2927 MessageLoopHelper helper;
2928 CallbackTest callback1(&helper, false);
2929 CallbackTest callback2(&helper, false);
2930
2931 disk_cache::Entry* entry = NULL;
2932 ASSERT_EQ(net::OK,
2933 cache_->CreateEntry(key, &entry,
2934 base::Bind(&CallbackTest::Run,
2935 base::Unretained(&callback1))));
2936 EXPECT_NE(null, entry);
2937 ScopedEntryPtr entry_closer(entry);
2938
2939 disk_cache::Entry* entry2 = NULL;
2940 ASSERT_EQ(net::ERR_IO_PENDING,
2941 cache_->OpenEntry(key, &entry2,
2942 base::Bind(&CallbackTest::Run,
2943 base::Unretained(&callback2))));
2944 ASSERT_TRUE(helper.WaitUntilCacheIoFinished(1));
2945
2946 EXPECT_NE(null, entry2);
2947 EXPECT_EQ(entry, entry2);
2948
2949 // We have to call close twice, since we called create and open above.
2950 entry->Close();
2951
2952 // Check that we are not leaking.
2953 EXPECT_TRUE(
2954 static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef());
2955 }
2956
2957 TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic3) {
2958 // Test sequence:
2959 // Create, Close, Open, Close.
2960 SetSimpleCacheMode();
2961 InitCache();
2962 disk_cache::Entry* null = NULL;
2963 const char key[] = "the first key";
2964
2965 disk_cache::Entry* entry = NULL;
2966 ASSERT_EQ(net::OK,
2967 cache_->CreateEntry(key, &entry, net::CompletionCallback()));
2968 EXPECT_NE(null, entry);
2969 entry->Close();
2970
2971 net::TestCompletionCallback cb;
2972 disk_cache::Entry* entry2 = NULL;
2973 ASSERT_EQ(net::ERR_IO_PENDING,
2974 cache_->OpenEntry(key, &entry2, cb.callback()));
2975 ASSERT_EQ(net::OK, cb.GetResult(net::ERR_IO_PENDING));
2976 ScopedEntryPtr entry_closer(entry2);
2977
2978 EXPECT_NE(null, entry2);
2979 EXPECT_EQ(entry, entry2);
2980
2981 // Check that we are not leaking.
2982 EXPECT_TRUE(
2983 static_cast<disk_cache::SimpleEntryImpl*>(entry2)->HasOneRef());
2984 }
2985
2986 TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic4) {
2987 // Test sequence:
2988 // Create, Close, Write, Open, Open, Close, Write, Read, Close.
2989 SetSimpleCacheMode();
2990 InitCache();
2991 disk_cache::Entry* null = NULL;
2992 const char key[] = "the first key";
2993
2994 net::TestCompletionCallback cb;
2995 const int kSize1 = 10;
2996 scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
2997 CacheTestFillBuffer(buffer1->data(), kSize1, false);
2998 disk_cache::Entry* entry = NULL;
2999
3000 ASSERT_EQ(net::OK,
3001 cache_->CreateEntry(key, &entry, net::CompletionCallback()));
3002 EXPECT_NE(null, entry);
3003 entry->Close();
3004
3005 // Lets do a Write so we block until both the Close and the Write
3006 // operation finishes. Write must fail since we are writing in a closed entry.
3007 EXPECT_EQ(
3008 net::ERR_IO_PENDING,
3009 entry->WriteData(1, 0, buffer1.get(), kSize1, cb.callback(), false));
3010 EXPECT_EQ(net::ERR_FAILED, cb.GetResult(net::ERR_IO_PENDING));
3011
3012 // Finish running the pending tasks so that we fully complete the close
3013 // operation and destroy the entry object.
3014 base::MessageLoop::current()->RunUntilIdle();
3015
3016 // At this point the |entry| must have been destroyed, and called
3017 // RemoveSelfFromBackend().
3018 disk_cache::Entry* entry2 = NULL;
3019 ASSERT_EQ(net::ERR_IO_PENDING,
3020 cache_->OpenEntry(key, &entry2, cb.callback()));
3021 ASSERT_EQ(net::OK, cb.GetResult(net::ERR_IO_PENDING));
3022 EXPECT_NE(null, entry2);
3023
3024 disk_cache::Entry* entry3 = NULL;
3025 ASSERT_EQ(net::ERR_IO_PENDING,
3026 cache_->OpenEntry(key, &entry3, cb.callback()));
3027 ASSERT_EQ(net::OK, cb.GetResult(net::ERR_IO_PENDING));
3028 EXPECT_NE(null, entry3);
3029 EXPECT_EQ(entry2, entry3);
3030 entry3->Close();
3031
3032 // The previous Close doesn't actually closes the entry since we opened it
3033 // twice, so the next Write operation must succeed and it must be able to
3034 // perform it optimistically, since there is no operation running on this
3035 // entry.
3036 EXPECT_EQ(kSize1,
3037 entry2->WriteData(
3038 1, 0, buffer1.get(), kSize1, net::CompletionCallback(), false));
3039
3040 // Lets do another read so we block until both the write and the read
3041 // operation finishes and we can then test for HasOneRef() below.
3042 EXPECT_EQ(net::ERR_IO_PENDING,
3043 entry2->ReadData(1, 0, buffer1.get(), kSize1, cb.callback()));
3044 EXPECT_EQ(kSize1, cb.GetResult(net::ERR_IO_PENDING));
3045
3046 // Check that we are not leaking.
3047 EXPECT_TRUE(
3048 static_cast<disk_cache::SimpleEntryImpl*>(entry2)->HasOneRef());
3049 entry2->Close();
3050 }
3051
3052 TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic5) {
3053 // Test sequence:
3054 // Create, Doom, Write, Read, Close.
3055 SetSimpleCacheMode();
3056 InitCache();
3057 disk_cache::Entry* null = NULL;
3058 const char key[] = "the first key";
3059
3060 net::TestCompletionCallback cb;
3061 const int kSize1 = 10;
3062 scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
3063 CacheTestFillBuffer(buffer1->data(), kSize1, false);
3064 disk_cache::Entry* entry = NULL;
3065
3066 ASSERT_EQ(net::OK,
3067 cache_->CreateEntry(key, &entry, net::CompletionCallback()));
3068 EXPECT_NE(null, entry);
3069 ScopedEntryPtr entry_closer(entry);
3070 entry->Doom();
3071
3072 EXPECT_EQ(
3073 net::ERR_IO_PENDING,
3074 entry->WriteData(1, 0, buffer1.get(), kSize1, cb.callback(), false));
3075 EXPECT_EQ(kSize1, cb.GetResult(net::ERR_IO_PENDING));
3076
3077 EXPECT_EQ(net::ERR_IO_PENDING,
3078 entry->ReadData(1, 0, buffer1.get(), kSize1, cb.callback()));
3079 EXPECT_EQ(kSize1, cb.GetResult(net::ERR_IO_PENDING));
3080
3081 // Check that we are not leaking.
3082 EXPECT_TRUE(
3083 static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef());
3084 }
3085
3086 TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic6) {
3087 // Test sequence:
3088 // Create, Write, Doom, Doom, Read, Doom, Close.
3089 SetSimpleCacheMode();
3090 InitCache();
3091 disk_cache::Entry* null = NULL;
3092 const char key[] = "the first key";
3093
3094 net::TestCompletionCallback cb;
3095 const int kSize1 = 10;
3096 scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
3097 scoped_refptr<net::IOBuffer> buffer1_read(new net::IOBuffer(kSize1));
3098 CacheTestFillBuffer(buffer1->data(), kSize1, false);
3099 disk_cache::Entry* entry = NULL;
3100
3101 ASSERT_EQ(net::OK,
3102 cache_->CreateEntry(key, &entry, net::CompletionCallback()));
3103 EXPECT_NE(null, entry);
3104 ScopedEntryPtr entry_closer(entry);
3105
3106 EXPECT_EQ(
3107 net::ERR_IO_PENDING,
3108 entry->WriteData(1, 0, buffer1.get(), kSize1, cb.callback(), false));
3109 EXPECT_EQ(kSize1, cb.GetResult(net::ERR_IO_PENDING));
3110
3111 entry->Doom();
3112 entry->Doom();
3113
3114 // This Read must not be optimistic, since we don't support that yet.
3115 EXPECT_EQ(net::ERR_IO_PENDING,
3116 entry->ReadData(1, 0, buffer1_read.get(), kSize1, cb.callback()));
3117 EXPECT_EQ(kSize1, cb.GetResult(net::ERR_IO_PENDING));
3118 EXPECT_EQ(0, memcmp(buffer1->data(), buffer1_read->data(), kSize1));
3119
3120 entry->Doom();
3121 }
3122
3123 // Confirm that IO buffers are not referenced by the Simple Cache after a write
3124 // completes.
3125 TEST_F(DiskCacheEntryTest, SimpleCacheOptimisticWriteReleases) {
3126 SetSimpleCacheMode();
3127 InitCache();
3128
3129 const char key[] = "the first key";
3130 disk_cache::Entry* entry = NULL;
3131
3132 // First, an optimistic create.
3133 ASSERT_EQ(net::OK,
3134 cache_->CreateEntry(key, &entry, net::CompletionCallback()));
3135 ASSERT_TRUE(entry);
3136 ScopedEntryPtr entry_closer(entry);
3137
3138 const int kWriteSize = 512;
3139 scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kWriteSize));
3140 EXPECT_TRUE(buffer1->HasOneRef());
3141 CacheTestFillBuffer(buffer1->data(), kWriteSize, false);
3142
3143 // An optimistic write happens only when there is an empty queue of pending
3144 // operations. To ensure the queue is empty, we issue a write and wait until
3145 // it completes.
3146 EXPECT_EQ(kWriteSize,
3147 WriteData(entry, 1, 0, buffer1.get(), kWriteSize, false));
3148 EXPECT_TRUE(buffer1->HasOneRef());
3149
3150 // Finally, we should perform an optimistic write and confirm that all
3151 // references to the IO buffer have been released.
3152 EXPECT_EQ(
3153 kWriteSize,
3154 entry->WriteData(
3155 1, 0, buffer1.get(), kWriteSize, net::CompletionCallback(), false));
3156 EXPECT_TRUE(buffer1->HasOneRef());
3157 }
3158
3159 TEST_F(DiskCacheEntryTest, SimpleCacheCreateDoomRace) {
3160 // Test sequence:
3161 // Create, Doom, Write, Close, Check files are not on disk anymore.
3162 SetSimpleCacheMode();
3163 InitCache();
3164 disk_cache::Entry* null = NULL;
3165 const char key[] = "the first key";
3166
3167 net::TestCompletionCallback cb;
3168 const int kSize1 = 10;
3169 scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
3170 CacheTestFillBuffer(buffer1->data(), kSize1, false);
3171 disk_cache::Entry* entry = NULL;
3172
3173 ASSERT_EQ(net::OK,
3174 cache_->CreateEntry(key, &entry, net::CompletionCallback()));
3175 EXPECT_NE(null, entry);
3176
3177 EXPECT_EQ(net::ERR_IO_PENDING, cache_->DoomEntry(key, cb.callback()));
3178 EXPECT_EQ(net::OK, cb.GetResult(net::ERR_IO_PENDING));
3179
3180 EXPECT_EQ(
3181 kSize1,
3182 entry->WriteData(0, 0, buffer1.get(), kSize1, cb.callback(), false));
3183
3184 entry->Close();
3185
3186 // Finish running the pending tasks so that we fully complete the close
3187 // operation and destroy the entry object.
3188 base::MessageLoop::current()->RunUntilIdle();
3189
3190 for (int i = 0; i < disk_cache::kSimpleEntryFileCount; ++i) {
3191 base::FilePath entry_file_path = cache_path_.AppendASCII(
3192 disk_cache::simple_util::GetFilenameFromKeyAndFileIndex(key, i));
3193 base::File::Info info;
3194 EXPECT_FALSE(base::GetFileInfo(entry_file_path, &info));
3195 }
3196 }
3197
3198 TEST_F(DiskCacheEntryTest, SimpleCacheDoomCreateRace) {
3199 // This test runs as APP_CACHE to make operations more synchronous. Test
3200 // sequence:
3201 // Create, Doom, Create.
3202 SetCacheType(net::APP_CACHE);
3203 SetSimpleCacheMode();
3204 InitCache();
3205 disk_cache::Entry* null = NULL;
3206 const char key[] = "the first key";
3207
3208 net::TestCompletionCallback create_callback;
3209
3210 disk_cache::Entry* entry1 = NULL;
3211 ASSERT_EQ(net::OK,
3212 create_callback.GetResult(
3213 cache_->CreateEntry(key, &entry1, create_callback.callback())));
3214 ScopedEntryPtr entry1_closer(entry1);
3215 EXPECT_NE(null, entry1);
3216
3217 net::TestCompletionCallback doom_callback;
3218 EXPECT_EQ(net::ERR_IO_PENDING,
3219 cache_->DoomEntry(key, doom_callback.callback()));
3220
3221 disk_cache::Entry* entry2 = NULL;
3222 ASSERT_EQ(net::OK,
3223 create_callback.GetResult(
3224 cache_->CreateEntry(key, &entry2, create_callback.callback())));
3225 ScopedEntryPtr entry2_closer(entry2);
3226 EXPECT_EQ(net::OK, doom_callback.GetResult(net::ERR_IO_PENDING));
3227 }
3228
3229 TEST_F(DiskCacheEntryTest, SimpleCacheDoomDoom) {
3230 // Test sequence:
3231 // Create, Doom, Create, Doom (1st entry), Open.
3232 SetSimpleCacheMode();
3233 InitCache();
3234 disk_cache::Entry* null = NULL;
3235
3236 const char key[] = "the first key";
3237
3238 disk_cache::Entry* entry1 = NULL;
3239 ASSERT_EQ(net::OK, CreateEntry(key, &entry1));
3240 ScopedEntryPtr entry1_closer(entry1);
3241 EXPECT_NE(null, entry1);
3242
3243 EXPECT_EQ(net::OK, DoomEntry(key));
3244
3245 disk_cache::Entry* entry2 = NULL;
3246 ASSERT_EQ(net::OK, CreateEntry(key, &entry2));
3247 ScopedEntryPtr entry2_closer(entry2);
3248 EXPECT_NE(null, entry2);
3249
3250 // Redundantly dooming entry1 should not delete entry2.
3251 disk_cache::SimpleEntryImpl* simple_entry1 =
3252 static_cast<disk_cache::SimpleEntryImpl*>(entry1);
3253 net::TestCompletionCallback cb;
3254 EXPECT_EQ(net::OK,
3255 cb.GetResult(simple_entry1->DoomEntry(cb.callback())));
3256
3257 disk_cache::Entry* entry3 = NULL;
3258 ASSERT_EQ(net::OK, OpenEntry(key, &entry3));
3259 ScopedEntryPtr entry3_closer(entry3);
3260 EXPECT_NE(null, entry3);
3261 }
3262
3263 TEST_F(DiskCacheEntryTest, SimpleCacheDoomCreateDoom) {
3264 // Test sequence:
3265 // Create, Doom, Create, Doom.
3266 SetSimpleCacheMode();
3267 InitCache();
3268
3269 disk_cache::Entry* null = NULL;
3270
3271 const char key[] = "the first key";
3272
3273 disk_cache::Entry* entry1 = NULL;
3274 ASSERT_EQ(net::OK, CreateEntry(key, &entry1));
3275 ScopedEntryPtr entry1_closer(entry1);
3276 EXPECT_NE(null, entry1);
3277
3278 entry1->Doom();
3279
3280 disk_cache::Entry* entry2 = NULL;
3281 ASSERT_EQ(net::OK, CreateEntry(key, &entry2));
3282 ScopedEntryPtr entry2_closer(entry2);
3283 EXPECT_NE(null, entry2);
3284
3285 entry2->Doom();
3286
3287 // This test passes if it doesn't crash.
3288 }
3289
3290 TEST_F(DiskCacheEntryTest, SimpleCacheDoomCloseCreateCloseOpen) {
3291 // Test sequence: Create, Doom, Close, Create, Close, Open.
3292 SetSimpleCacheMode();
3293 InitCache();
3294
3295 disk_cache::Entry* null = NULL;
3296
3297 const char key[] = "this is a key";
3298
3299 disk_cache::Entry* entry1 = NULL;
3300 ASSERT_EQ(net::OK, CreateEntry(key, &entry1));
3301 ScopedEntryPtr entry1_closer(entry1);
3302 EXPECT_NE(null, entry1);
3303
3304 entry1->Doom();
3305 entry1_closer.reset();
3306 entry1 = NULL;
3307
3308 disk_cache::Entry* entry2 = NULL;
3309 ASSERT_EQ(net::OK, CreateEntry(key, &entry2));
3310 ScopedEntryPtr entry2_closer(entry2);
3311 EXPECT_NE(null, entry2);
3312
3313 entry2_closer.reset();
3314 entry2 = NULL;
3315
3316 disk_cache::Entry* entry3 = NULL;
3317 ASSERT_EQ(net::OK, OpenEntry(key, &entry3));
3318 ScopedEntryPtr entry3_closer(entry3);
3319 EXPECT_NE(null, entry3);
3320 }
3321
3322 // Checks that an optimistic Create would fail later on a racing Open.
3323 TEST_F(DiskCacheEntryTest, SimpleCacheOptimisticCreateFailsOnOpen) {
3324 SetSimpleCacheMode();
3325 InitCache();
3326
3327 // Create a corrupt file in place of a future entry. Optimistic create should
3328 // initially succeed, but realize later that creation failed.
3329 const std::string key = "the key";
3330 net::TestCompletionCallback cb;
3331 disk_cache::Entry* entry = NULL;
3332 disk_cache::Entry* entry2 = NULL;
3333
3334 EXPECT_TRUE(disk_cache::simple_util::CreateCorruptFileForTests(
3335 key, cache_path_));
3336 EXPECT_EQ(net::OK, cache_->CreateEntry(key, &entry, cb.callback()));
3337 ASSERT_TRUE(entry);
3338 ScopedEntryPtr entry_closer(entry);
3339 ASSERT_NE(net::OK, OpenEntry(key, &entry2));
3340
3341 // Check that we are not leaking.
3342 EXPECT_TRUE(
3343 static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef());
3344
3345 DisableIntegrityCheck();
3346 }
3347
3348 // Tests that old entries are evicted while new entries remain in the index.
3349 // This test relies on non-mandatory properties of the simple Cache Backend:
3350 // LRU eviction, specific values of high-watermark and low-watermark etc.
3351 // When changing the eviction algorithm, the test will have to be re-engineered.
3352 TEST_F(DiskCacheEntryTest, SimpleCacheEvictOldEntries) {
3353 const int kMaxSize = 200 * 1024;
3354 const int kWriteSize = kMaxSize / 10;
3355 const int kNumExtraEntries = 12;
3356 SetSimpleCacheMode();
3357 SetMaxSize(kMaxSize);
3358 InitCache();
3359
3360 std::string key1("the first key");
3361 disk_cache::Entry* entry;
3362 ASSERT_EQ(net::OK, CreateEntry(key1, &entry));
3363 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kWriteSize));
3364 CacheTestFillBuffer(buffer->data(), kWriteSize, false);
3365 EXPECT_EQ(kWriteSize,
3366 WriteData(entry, 1, 0, buffer.get(), kWriteSize, false));
3367 entry->Close();
3368 AddDelay();
3369
3370 std::string key2("the key prefix");
3371 for (int i = 0; i < kNumExtraEntries; i++) {
3372 if (i == kNumExtraEntries - 2) {
3373 // Create a distinct timestamp for the last two entries. These entries
3374 // will be checked for outliving the eviction.
3375 AddDelay();
3376 }
3377 ASSERT_EQ(net::OK, CreateEntry(key2 + base::StringPrintf("%d", i), &entry));
3378 ScopedEntryPtr entry_closer(entry);
3379 EXPECT_EQ(kWriteSize,
3380 WriteData(entry, 1, 0, buffer.get(), kWriteSize, false));
3381 }
3382
3383 // TODO(pasko): Find a way to wait for the eviction task(s) to finish by using
3384 // the internal knowledge about |SimpleBackendImpl|.
3385 ASSERT_NE(net::OK, OpenEntry(key1, &entry))
3386 << "Should have evicted the old entry";
3387 for (int i = 0; i < 2; i++) {
3388 int entry_no = kNumExtraEntries - i - 1;
3389 // Generally there is no guarantee that at this point the backround eviction
3390 // is finished. We are testing the positive case, i.e. when the eviction
3391 // never reaches this entry, should be non-flaky.
3392 ASSERT_EQ(net::OK, OpenEntry(key2 + base::StringPrintf("%d", entry_no),
3393 &entry))
3394 << "Should not have evicted fresh entry " << entry_no;
3395 entry->Close();
3396 }
3397 }
3398
3399 // Tests that if a read and a following in-flight truncate are both in progress
3400 // simultaniously that they both can occur successfully. See
3401 // http://crbug.com/239223
3402 TEST_F(DiskCacheEntryTest, SimpleCacheInFlightTruncate) {
3403 SetSimpleCacheMode();
3404 InitCache();
3405
3406 const char key[] = "the first key";
3407
3408 const int kBufferSize = 1024;
3409 scoped_refptr<net::IOBuffer> write_buffer(new net::IOBuffer(kBufferSize));
3410 CacheTestFillBuffer(write_buffer->data(), kBufferSize, false);
3411
3412 disk_cache::Entry* entry = NULL;
3413 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
3414
3415 EXPECT_EQ(kBufferSize,
3416 WriteData(entry, 1, 0, write_buffer.get(), kBufferSize, false));
3417 entry->Close();
3418 entry = NULL;
3419
3420 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
3421 ScopedEntryPtr entry_closer(entry);
3422
3423 MessageLoopHelper helper;
3424 int expected = 0;
3425
3426 // Make a short read.
3427 const int kReadBufferSize = 512;
3428 scoped_refptr<net::IOBuffer> read_buffer(new net::IOBuffer(kReadBufferSize));
3429 CallbackTest read_callback(&helper, false);
3430 EXPECT_EQ(net::ERR_IO_PENDING,
3431 entry->ReadData(1,
3432 0,
3433 read_buffer.get(),
3434 kReadBufferSize,
3435 base::Bind(&CallbackTest::Run,
3436 base::Unretained(&read_callback))));
3437 ++expected;
3438
3439 // Truncate the entry to the length of that read.
3440 scoped_refptr<net::IOBuffer>
3441 truncate_buffer(new net::IOBuffer(kReadBufferSize));
3442 CacheTestFillBuffer(truncate_buffer->data(), kReadBufferSize, false);
3443 CallbackTest truncate_callback(&helper, false);
3444 EXPECT_EQ(net::ERR_IO_PENDING,
3445 entry->WriteData(1,
3446 0,
3447 truncate_buffer.get(),
3448 kReadBufferSize,
3449 base::Bind(&CallbackTest::Run,
3450 base::Unretained(&truncate_callback)),
3451 true));
3452 ++expected;
3453
3454 // Wait for both the read and truncation to finish, and confirm that both
3455 // succeeded.
3456 EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
3457 EXPECT_EQ(kReadBufferSize, read_callback.last_result());
3458 EXPECT_EQ(kReadBufferSize, truncate_callback.last_result());
3459 EXPECT_EQ(0,
3460 memcmp(write_buffer->data(), read_buffer->data(), kReadBufferSize));
3461 }
3462
3463 // Tests that if a write and a read dependant on it are both in flight
3464 // simultaneiously that they both can complete successfully without erroneous
3465 // early returns. See http://crbug.com/239223
3466 TEST_F(DiskCacheEntryTest, SimpleCacheInFlightRead) {
3467 SetSimpleCacheMode();
3468 InitCache();
3469
3470 const char key[] = "the first key";
3471 disk_cache::Entry* entry = NULL;
3472 ASSERT_EQ(net::OK,
3473 cache_->CreateEntry(key, &entry, net::CompletionCallback()));
3474 ScopedEntryPtr entry_closer(entry);
3475
3476 const int kBufferSize = 1024;
3477 scoped_refptr<net::IOBuffer> write_buffer(new net::IOBuffer(kBufferSize));
3478 CacheTestFillBuffer(write_buffer->data(), kBufferSize, false);
3479
3480 MessageLoopHelper helper;
3481 int expected = 0;
3482
3483 CallbackTest write_callback(&helper, false);
3484 EXPECT_EQ(net::ERR_IO_PENDING,
3485 entry->WriteData(1,
3486 0,
3487 write_buffer.get(),
3488 kBufferSize,
3489 base::Bind(&CallbackTest::Run,
3490 base::Unretained(&write_callback)),
3491 true));
3492 ++expected;
3493
3494 scoped_refptr<net::IOBuffer> read_buffer(new net::IOBuffer(kBufferSize));
3495 CallbackTest read_callback(&helper, false);
3496 EXPECT_EQ(net::ERR_IO_PENDING,
3497 entry->ReadData(1,
3498 0,
3499 read_buffer.get(),
3500 kBufferSize,
3501 base::Bind(&CallbackTest::Run,
3502 base::Unretained(&read_callback))));
3503 ++expected;
3504
3505 EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
3506 EXPECT_EQ(kBufferSize, write_callback.last_result());
3507 EXPECT_EQ(kBufferSize, read_callback.last_result());
3508 EXPECT_EQ(0, memcmp(write_buffer->data(), read_buffer->data(), kBufferSize));
3509 }
3510
3511 TEST_F(DiskCacheEntryTest, SimpleCacheOpenCreateRaceWithNoIndex) {
3512 SetSimpleCacheMode();
3513 DisableSimpleCacheWaitForIndex();
3514 DisableIntegrityCheck();
3515 InitCache();
3516
3517 // Assume the index is not initialized, which is likely, since we are blocking
3518 // the IO thread from executing the index finalization step.
3519 disk_cache::Entry* entry1;
3520 net::TestCompletionCallback cb1;
3521 disk_cache::Entry* entry2;
3522 net::TestCompletionCallback cb2;
3523 int rv1 = cache_->OpenEntry("key", &entry1, cb1.callback());
3524 int rv2 = cache_->CreateEntry("key", &entry2, cb2.callback());
3525
3526 EXPECT_EQ(net::ERR_FAILED, cb1.GetResult(rv1));
3527 ASSERT_EQ(net::OK, cb2.GetResult(rv2));
3528 entry2->Close();
3529 }
3530
3531 // Checks that reading two entries simultaneously does not discard a CRC check.
3532 // TODO(pasko): make it work with Simple Cache.
3533 TEST_F(DiskCacheEntryTest, DISABLED_SimpleCacheMultipleReadersCheckCRC) {
3534 SetSimpleCacheMode();
3535 InitCache();
3536
3537 const char key[] = "key";
3538
3539 int size;
3540 ASSERT_TRUE(SimpleCacheMakeBadChecksumEntry(key, &size));
3541
3542 scoped_refptr<net::IOBuffer> read_buffer1(new net::IOBuffer(size));
3543 scoped_refptr<net::IOBuffer> read_buffer2(new net::IOBuffer(size));
3544
3545 // Advance the first reader a little.
3546 disk_cache::Entry* entry = NULL;
3547 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
3548 EXPECT_EQ(1, ReadData(entry, 0, 0, read_buffer1.get(), 1));
3549
3550 // Make the second reader pass the point where the first one is, and close.
3551 disk_cache::Entry* entry2 = NULL;
3552 EXPECT_EQ(net::OK, OpenEntry(key, &entry2));
3553 EXPECT_EQ(1, ReadData(entry2, 0, 0, read_buffer2.get(), 1));
3554 EXPECT_EQ(1, ReadData(entry2, 0, 1, read_buffer2.get(), 1));
3555 entry2->Close();
3556
3557 // Read the data till the end should produce an error.
3558 EXPECT_GT(0, ReadData(entry, 0, 1, read_buffer1.get(), size));
3559 entry->Close();
3560 DisableIntegrityCheck();
3561 }
3562
3563 // Checking one more scenario of overlapped reading of a bad entry.
3564 // Differs from the |SimpleCacheMultipleReadersCheckCRC| only by the order of
3565 // last two reads.
3566 TEST_F(DiskCacheEntryTest, SimpleCacheMultipleReadersCheckCRC2) {
3567 SetSimpleCacheMode();
3568 InitCache();
3569
3570 const char key[] = "key";
3571 int size;
3572 ASSERT_TRUE(SimpleCacheMakeBadChecksumEntry(key, &size));
3573
3574 scoped_refptr<net::IOBuffer> read_buffer1(new net::IOBuffer(size));
3575 scoped_refptr<net::IOBuffer> read_buffer2(new net::IOBuffer(size));
3576
3577 // Advance the first reader a little.
3578 disk_cache::Entry* entry = NULL;
3579 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
3580 ScopedEntryPtr entry_closer(entry);
3581 EXPECT_EQ(1, ReadData(entry, 1, 0, read_buffer1.get(), 1));
3582
3583 // Advance the 2nd reader by the same amount.
3584 disk_cache::Entry* entry2 = NULL;
3585 EXPECT_EQ(net::OK, OpenEntry(key, &entry2));
3586 ScopedEntryPtr entry2_closer(entry2);
3587 EXPECT_EQ(1, ReadData(entry2, 1, 0, read_buffer2.get(), 1));
3588
3589 // Continue reading 1st.
3590 EXPECT_GT(0, ReadData(entry, 1, 1, read_buffer1.get(), size));
3591
3592 // This read should fail as well because we have previous read failures.
3593 EXPECT_GT(0, ReadData(entry2, 1, 1, read_buffer2.get(), 1));
3594 DisableIntegrityCheck();
3595 }
3596
3597 // Test if we can sequentially read each subset of the data until all the data
3598 // is read, then the CRC is calculated correctly and the reads are successful.
3599 TEST_F(DiskCacheEntryTest, SimpleCacheReadCombineCRC) {
3600 // Test sequence:
3601 // Create, Write, Read (first half of data), Read (second half of data),
3602 // Close.
3603 SetSimpleCacheMode();
3604 InitCache();
3605 disk_cache::Entry* null = NULL;
3606 const char key[] = "the first key";
3607
3608 const int kHalfSize = 200;
3609 const int kSize = 2 * kHalfSize;
3610 scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
3611 CacheTestFillBuffer(buffer1->data(), kSize, false);
3612 disk_cache::Entry* entry = NULL;
3613
3614 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
3615 EXPECT_NE(null, entry);
3616
3617 EXPECT_EQ(kSize, WriteData(entry, 1, 0, buffer1.get(), kSize, false));
3618 entry->Close();
3619
3620 disk_cache::Entry* entry2 = NULL;
3621 ASSERT_EQ(net::OK, OpenEntry(key, &entry2));
3622 EXPECT_EQ(entry, entry2);
3623
3624 // Read the first half of the data.
3625 int offset = 0;
3626 int buf_len = kHalfSize;
3627 scoped_refptr<net::IOBuffer> buffer1_read1(new net::IOBuffer(buf_len));
3628 EXPECT_EQ(buf_len, ReadData(entry2, 1, offset, buffer1_read1.get(), buf_len));
3629 EXPECT_EQ(0, memcmp(buffer1->data(), buffer1_read1->data(), buf_len));
3630
3631 // Read the second half of the data.
3632 offset = buf_len;
3633 buf_len = kHalfSize;
3634 scoped_refptr<net::IOBuffer> buffer1_read2(new net::IOBuffer(buf_len));
3635 EXPECT_EQ(buf_len, ReadData(entry2, 1, offset, buffer1_read2.get(), buf_len));
3636 char* buffer1_data = buffer1->data() + offset;
3637 EXPECT_EQ(0, memcmp(buffer1_data, buffer1_read2->data(), buf_len));
3638
3639 // Check that we are not leaking.
3640 EXPECT_NE(entry, null);
3641 EXPECT_TRUE(
3642 static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef());
3643 entry->Close();
3644 entry = NULL;
3645 }
3646
3647 // Test if we can write the data not in sequence and read correctly. In
3648 // this case the CRC will not be present.
3649 TEST_F(DiskCacheEntryTest, SimpleCacheNonSequentialWrite) {
3650 // Test sequence:
3651 // Create, Write (second half of data), Write (first half of data), Read,
3652 // Close.
3653 SetSimpleCacheMode();
3654 InitCache();
3655 disk_cache::Entry* null = NULL;
3656 const char key[] = "the first key";
3657
3658 const int kHalfSize = 200;
3659 const int kSize = 2 * kHalfSize;
3660 scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
3661 scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
3662 CacheTestFillBuffer(buffer1->data(), kSize, false);
3663 char* buffer1_data = buffer1->data() + kHalfSize;
3664 memcpy(buffer2->data(), buffer1_data, kHalfSize);
3665
3666 disk_cache::Entry* entry = NULL;
3667 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
3668 entry->Close();
3669 for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) {
3670 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
3671 EXPECT_NE(null, entry);
3672
3673 int offset = kHalfSize;
3674 int buf_len = kHalfSize;
3675
3676 EXPECT_EQ(buf_len,
3677 WriteData(entry, i, offset, buffer2.get(), buf_len, false));
3678 offset = 0;
3679 buf_len = kHalfSize;
3680 EXPECT_EQ(buf_len,
3681 WriteData(entry, i, offset, buffer1.get(), buf_len, false));
3682 entry->Close();
3683
3684 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
3685
3686 scoped_refptr<net::IOBuffer> buffer1_read1(new net::IOBuffer(kSize));
3687 EXPECT_EQ(kSize, ReadData(entry, i, 0, buffer1_read1.get(), kSize));
3688 EXPECT_EQ(0, memcmp(buffer1->data(), buffer1_read1->data(), kSize));
3689 // Check that we are not leaking.
3690 ASSERT_NE(entry, null);
3691 EXPECT_TRUE(static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef());
3692 entry->Close();
3693 }
3694 }
3695
3696 // Test that changing stream1 size does not affect stream0 (stream0 and stream1
3697 // are stored in the same file in Simple Cache).
3698 TEST_F(DiskCacheEntryTest, SimpleCacheStream1SizeChanges) {
3699 SetSimpleCacheMode();
3700 InitCache();
3701 disk_cache::Entry* entry = NULL;
3702 const char key[] = "the key";
3703 const int kSize = 100;
3704 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
3705 scoped_refptr<net::IOBuffer> buffer_read(new net::IOBuffer(kSize));
3706 CacheTestFillBuffer(buffer->data(), kSize, false);
3707
3708 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
3709 EXPECT_TRUE(entry);
3710
3711 // Write something into stream0.
3712 EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
3713 EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer_read.get(), kSize));
3714 EXPECT_EQ(0, memcmp(buffer->data(), buffer_read->data(), kSize));
3715 entry->Close();
3716
3717 // Extend stream1.
3718 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
3719 int stream1_size = 100;
3720 EXPECT_EQ(0, WriteData(entry, 1, stream1_size, buffer.get(), 0, false));
3721 EXPECT_EQ(stream1_size, entry->GetDataSize(1));
3722 entry->Close();
3723
3724 // Check that stream0 data has not been modified and that the EOF record for
3725 // stream 0 contains a crc.
3726 // The entry needs to be reopened before checking the crc: Open will perform
3727 // the synchronization with the previous Close. This ensures the EOF records
3728 // have been written to disk before we attempt to read them independently.
3729 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
3730 base::FilePath entry_file0_path = cache_path_.AppendASCII(
3731 disk_cache::simple_util::GetFilenameFromKeyAndFileIndex(key, 0));
3732 base::File entry_file0(entry_file0_path,
3733 base::File::FLAG_READ | base::File::FLAG_OPEN);
3734 ASSERT_TRUE(entry_file0.IsValid());
3735
3736 int data_size[disk_cache::kSimpleEntryStreamCount] = {kSize, stream1_size, 0};
3737 int sparse_data_size = 0;
3738 disk_cache::SimpleEntryStat entry_stat(
3739 base::Time::Now(), base::Time::Now(), data_size, sparse_data_size);
3740 int eof_offset = entry_stat.GetEOFOffsetInFile(key, 0);
3741 disk_cache::SimpleFileEOF eof_record;
3742 ASSERT_EQ(static_cast<int>(sizeof(eof_record)),
3743 entry_file0.Read(eof_offset, reinterpret_cast<char*>(&eof_record),
3744 sizeof(eof_record)));
3745 EXPECT_EQ(disk_cache::kSimpleFinalMagicNumber, eof_record.final_magic_number);
3746 EXPECT_TRUE((eof_record.flags & disk_cache::SimpleFileEOF::FLAG_HAS_CRC32) ==
3747 disk_cache::SimpleFileEOF::FLAG_HAS_CRC32);
3748
3749 buffer_read = new net::IOBuffer(kSize);
3750 EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer_read.get(), kSize));
3751 EXPECT_EQ(0, memcmp(buffer->data(), buffer_read->data(), kSize));
3752
3753 // Shrink stream1.
3754 stream1_size = 50;
3755 EXPECT_EQ(0, WriteData(entry, 1, stream1_size, buffer.get(), 0, true));
3756 EXPECT_EQ(stream1_size, entry->GetDataSize(1));
3757 entry->Close();
3758
3759 // Check that stream0 data has not been modified.
3760 buffer_read = new net::IOBuffer(kSize);
3761 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
3762 EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer_read.get(), kSize));
3763 EXPECT_EQ(0, memcmp(buffer->data(), buffer_read->data(), kSize));
3764 entry->Close();
3765 entry = NULL;
3766 }
3767
3768 // Test that writing within the range for which the crc has already been
3769 // computed will properly invalidate the computed crc.
3770 TEST_F(DiskCacheEntryTest, SimpleCacheCRCRewrite) {
3771 // Test sequence:
3772 // Create, Write (big data), Write (small data in the middle), Close.
3773 // Open, Read (all), Close.
3774 SetSimpleCacheMode();
3775 InitCache();
3776 disk_cache::Entry* null = NULL;
3777 const char key[] = "the first key";
3778
3779 const int kHalfSize = 200;
3780 const int kSize = 2 * kHalfSize;
3781 scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
3782 scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kHalfSize));
3783 CacheTestFillBuffer(buffer1->data(), kSize, false);
3784 CacheTestFillBuffer(buffer2->data(), kHalfSize, false);
3785
3786 disk_cache::Entry* entry = NULL;
3787 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
3788 EXPECT_NE(null, entry);
3789 entry->Close();
3790
3791 for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) {
3792 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
3793 int offset = 0;
3794 int buf_len = kSize;
3795
3796 EXPECT_EQ(buf_len,
3797 WriteData(entry, i, offset, buffer1.get(), buf_len, false));
3798 offset = kHalfSize;
3799 buf_len = kHalfSize;
3800 EXPECT_EQ(buf_len,
3801 WriteData(entry, i, offset, buffer2.get(), buf_len, false));
3802 entry->Close();
3803
3804 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
3805
3806 scoped_refptr<net::IOBuffer> buffer1_read1(new net::IOBuffer(kSize));
3807 EXPECT_EQ(kSize, ReadData(entry, i, 0, buffer1_read1.get(), kSize));
3808 EXPECT_EQ(0, memcmp(buffer1->data(), buffer1_read1->data(), kHalfSize));
3809 EXPECT_EQ(
3810 0,
3811 memcmp(buffer2->data(), buffer1_read1->data() + kHalfSize, kHalfSize));
3812
3813 entry->Close();
3814 }
3815 }
3816
3817 bool DiskCacheEntryTest::SimpleCacheThirdStreamFileExists(const char* key) {
3818 int third_stream_file_index =
3819 disk_cache::simple_util::GetFileIndexFromStreamIndex(2);
3820 base::FilePath third_stream_file_path = cache_path_.AppendASCII(
3821 disk_cache::simple_util::GetFilenameFromKeyAndFileIndex(
3822 key, third_stream_file_index));
3823 return PathExists(third_stream_file_path);
3824 }
3825
3826 void DiskCacheEntryTest::SyncDoomEntry(const char* key) {
3827 net::TestCompletionCallback callback;
3828 cache_->DoomEntry(key, callback.callback());
3829 callback.WaitForResult();
3830 }
3831
3832 // Check that a newly-created entry with no third-stream writes omits the
3833 // third stream file.
3834 TEST_F(DiskCacheEntryTest, SimpleCacheOmittedThirdStream1) {
3835 SetSimpleCacheMode();
3836 InitCache();
3837
3838 const char key[] = "key";
3839
3840 disk_cache::Entry* entry;
3841
3842 // Create entry and close without writing: third stream file should be
3843 // omitted, since the stream is empty.
3844 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
3845 entry->Close();
3846 EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
3847
3848 SyncDoomEntry(key);
3849 EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
3850 }
3851
3852 // Check that a newly-created entry with only a single zero-offset, zero-length
3853 // write omits the third stream file.
3854 TEST_F(DiskCacheEntryTest, SimpleCacheOmittedThirdStream2) {
3855 SetSimpleCacheMode();
3856 InitCache();
3857
3858 const int kHalfSize = 8;
3859 const int kSize = kHalfSize * 2;
3860 const char key[] = "key";
3861 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
3862 CacheTestFillBuffer(buffer->data(), kHalfSize, false);
3863
3864 disk_cache::Entry* entry;
3865
3866 // Create entry, write empty buffer to third stream, and close: third stream
3867 // should still be omitted, since the entry ignores writes that don't modify
3868 // data or change the length.
3869 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
3870 EXPECT_EQ(0, WriteData(entry, 2, 0, buffer.get(), 0, true));
3871 entry->Close();
3872 EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
3873
3874 SyncDoomEntry(key);
3875 EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
3876 }
3877
3878 // Check that we can read back data written to the third stream.
3879 TEST_F(DiskCacheEntryTest, SimpleCacheOmittedThirdStream3) {
3880 SetSimpleCacheMode();
3881 InitCache();
3882
3883 const int kHalfSize = 8;
3884 const int kSize = kHalfSize * 2;
3885 const char key[] = "key";
3886 scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
3887 scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
3888 CacheTestFillBuffer(buffer1->data(), kHalfSize, false);
3889
3890 disk_cache::Entry* entry;
3891
3892 // Create entry, write data to third stream, and close: third stream should
3893 // not be omitted, since it contains data. Re-open entry and ensure there
3894 // are that many bytes in the third stream.
3895 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
3896 EXPECT_EQ(kHalfSize, WriteData(entry, 2, 0, buffer1.get(), kHalfSize, true));
3897 entry->Close();
3898 EXPECT_TRUE(SimpleCacheThirdStreamFileExists(key));
3899
3900 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
3901 EXPECT_EQ(kHalfSize, ReadData(entry, 2, 0, buffer2.get(), kSize));
3902 EXPECT_EQ(0, memcmp(buffer1->data(), buffer2->data(), kHalfSize));
3903 entry->Close();
3904 EXPECT_TRUE(SimpleCacheThirdStreamFileExists(key));
3905
3906 SyncDoomEntry(key);
3907 EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
3908 }
3909
3910 // Check that we remove the third stream file upon opening an entry and finding
3911 // the third stream empty. (This is the upgrade path for entries written
3912 // before the third stream was optional.)
3913 TEST_F(DiskCacheEntryTest, SimpleCacheOmittedThirdStream4) {
3914 SetSimpleCacheMode();
3915 InitCache();
3916
3917 const int kHalfSize = 8;
3918 const int kSize = kHalfSize * 2;
3919 const char key[] = "key";
3920 scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
3921 scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
3922 CacheTestFillBuffer(buffer1->data(), kHalfSize, false);
3923
3924 disk_cache::Entry* entry;
3925
3926 // Create entry, write data to third stream, truncate third stream back to
3927 // empty, and close: third stream will not initially be omitted, since entry
3928 // creates the file when the first significant write comes in, and only
3929 // removes it on open if it is empty. Reopen, ensure that the file is
3930 // deleted, and that there's no data in the third stream.
3931 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
3932 EXPECT_EQ(kHalfSize, WriteData(entry, 2, 0, buffer1.get(), kHalfSize, true));
3933 EXPECT_EQ(0, WriteData(entry, 2, 0, buffer1.get(), 0, true));
3934 entry->Close();
3935 EXPECT_TRUE(SimpleCacheThirdStreamFileExists(key));
3936
3937 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
3938 EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
3939 EXPECT_EQ(0, ReadData(entry, 2, 0, buffer2.get(), kSize));
3940 entry->Close();
3941 EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
3942
3943 SyncDoomEntry(key);
3944 EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
3945 }
3946
3947 // Check that we don't accidentally create the third stream file once the entry
3948 // has been doomed.
3949 TEST_F(DiskCacheEntryTest, SimpleCacheOmittedThirdStream5) {
3950 SetSimpleCacheMode();
3951 InitCache();
3952
3953 const int kHalfSize = 8;
3954 const int kSize = kHalfSize * 2;
3955 const char key[] = "key";
3956 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
3957 CacheTestFillBuffer(buffer->data(), kHalfSize, false);
3958
3959 disk_cache::Entry* entry;
3960
3961 // Create entry, doom entry, write data to third stream, and close: third
3962 // stream should not exist. (Note: We don't care if the write fails, just
3963 // that it doesn't cause the file to be created on disk.)
3964 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
3965 entry->Doom();
3966 WriteData(entry, 2, 0, buffer.get(), kHalfSize, true);
3967 entry->Close();
3968 EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
3969 }
3970
3971 // There could be a race between Doom and an optimistic write.
3972 TEST_F(DiskCacheEntryTest, SimpleCacheDoomOptimisticWritesRace) {
3973 // Test sequence:
3974 // Create, first Write, second Write, Close.
3975 // Open, Close.
3976 SetSimpleCacheMode();
3977 InitCache();
3978 disk_cache::Entry* null = NULL;
3979 const char key[] = "the first key";
3980
3981 const int kSize = 200;
3982 scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
3983 scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
3984 CacheTestFillBuffer(buffer1->data(), kSize, false);
3985 CacheTestFillBuffer(buffer2->data(), kSize, false);
3986
3987 // The race only happens on stream 1 and stream 2.
3988 for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) {
3989 ASSERT_EQ(net::OK, DoomAllEntries());
3990 disk_cache::Entry* entry = NULL;
3991
3992 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
3993 EXPECT_NE(null, entry);
3994 entry->Close();
3995 entry = NULL;
3996
3997 ASSERT_EQ(net::OK, DoomAllEntries());
3998 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
3999 EXPECT_NE(null, entry);
4000
4001 int offset = 0;
4002 int buf_len = kSize;
4003 // This write should not be optimistic (since create is).
4004 EXPECT_EQ(buf_len,
4005 WriteData(entry, i, offset, buffer1.get(), buf_len, false));
4006
4007 offset = kSize;
4008 // This write should be optimistic.
4009 EXPECT_EQ(buf_len,
4010 WriteData(entry, i, offset, buffer2.get(), buf_len, false));
4011 entry->Close();
4012
4013 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
4014 EXPECT_NE(null, entry);
4015
4016 entry->Close();
4017 entry = NULL;
4018 }
4019 }
4020
4021 // Tests for a regression in crbug.com/317138 , in which deleting an already
4022 // doomed entry was removing the active entry from the index.
4023 TEST_F(DiskCacheEntryTest, SimpleCachePreserveActiveEntries) {
4024 SetSimpleCacheMode();
4025 InitCache();
4026
4027 disk_cache::Entry* null = NULL;
4028
4029 const char key[] = "this is a key";
4030
4031 disk_cache::Entry* entry1 = NULL;
4032 ASSERT_EQ(net::OK, CreateEntry(key, &entry1));
4033 ScopedEntryPtr entry1_closer(entry1);
4034 EXPECT_NE(null, entry1);
4035 entry1->Doom();
4036
4037 disk_cache::Entry* entry2 = NULL;
4038 ASSERT_EQ(net::OK, CreateEntry(key, &entry2));
4039 ScopedEntryPtr entry2_closer(entry2);
4040 EXPECT_NE(null, entry2);
4041 entry2_closer.reset();
4042
4043 // Closing then reopening entry2 insures that entry2 is serialized, and so
4044 // it can be opened from files without error.
4045 entry2 = NULL;
4046 ASSERT_EQ(net::OK, OpenEntry(key, &entry2));
4047 EXPECT_NE(null, entry2);
4048 entry2_closer.reset(entry2);
4049
4050 scoped_refptr<disk_cache::SimpleEntryImpl>
4051 entry1_refptr = static_cast<disk_cache::SimpleEntryImpl*>(entry1);
4052
4053 // If crbug.com/317138 has regressed, this will remove |entry2| from
4054 // the backend's |active_entries_| while |entry2| is still alive and its
4055 // files are still on disk.
4056 entry1_closer.reset();
4057 entry1 = NULL;
4058
4059 // Close does not have a callback. However, we need to be sure the close is
4060 // finished before we continue the test. We can take advantage of how the ref
4061 // counting of a SimpleEntryImpl works to fake out a callback: When the
4062 // last Close() call is made to an entry, an IO operation is sent to the
4063 // synchronous entry to close the platform files. This IO operation holds a
4064 // ref pointer to the entry, which expires when the operation is done. So,
4065 // we take a refpointer, and watch the SimpleEntry object until it has only
4066 // one ref; this indicates the IO operation is complete.
4067 while (!entry1_refptr->HasOneRef()) {
4068 base::PlatformThread::YieldCurrentThread();
4069 base::MessageLoop::current()->RunUntilIdle();
4070 }
4071 entry1_refptr = NULL;
4072
4073 // In the bug case, this new entry ends up being a duplicate object pointing
4074 // at the same underlying files.
4075 disk_cache::Entry* entry3 = NULL;
4076 EXPECT_EQ(net::OK, OpenEntry(key, &entry3));
4077 ScopedEntryPtr entry3_closer(entry3);
4078 EXPECT_NE(null, entry3);
4079
4080 // The test passes if these two dooms do not crash.
4081 entry2->Doom();
4082 entry3->Doom();
4083 }
4084
4085 TEST_F(DiskCacheEntryTest, SimpleCacheBasicSparseIO) {
4086 SetSimpleCacheMode();
4087 InitCache();
4088 BasicSparseIO();
4089 }
4090
4091 TEST_F(DiskCacheEntryTest, SimpleCacheHugeSparseIO) {
4092 SetSimpleCacheMode();
4093 InitCache();
4094 HugeSparseIO();
4095 }
4096
4097 TEST_F(DiskCacheEntryTest, SimpleCacheGetAvailableRange) {
4098 SetSimpleCacheMode();
4099 InitCache();
4100 GetAvailableRange();
4101 }
4102
4103 TEST_F(DiskCacheEntryTest, DISABLED_SimpleCacheCouldBeSparse) {
4104 SetSimpleCacheMode();
4105 InitCache();
4106 CouldBeSparse();
4107 }
4108
4109 TEST_F(DiskCacheEntryTest, SimpleCacheUpdateSparseEntry) {
4110 SetSimpleCacheMode();
4111 InitCache();
4112 UpdateSparseEntry();
4113 }
4114
4115 TEST_F(DiskCacheEntryTest, SimpleCacheDoomSparseEntry) {
4116 SetSimpleCacheMode();
4117 InitCache();
4118 DoomSparseEntry();
4119 }
4120
4121 TEST_F(DiskCacheEntryTest, SimpleCachePartialSparseEntry) {
4122 SetSimpleCacheMode();
4123 InitCache();
4124 PartialSparseEntry();
4125 }
4126
4127 TEST_F(DiskCacheEntryTest, SimpleCacheTruncateLargeSparseFile) {
4128 const int kSize = 1024;
4129
4130 SetSimpleCacheMode();
4131 // An entry is allowed sparse data 1/10 the size of the cache, so this size
4132 // allows for one |kSize|-sized range plus overhead, but not two ranges.
4133 SetMaxSize(kSize * 15);
4134 InitCache();
4135
4136 const char key[] = "key";
4137 disk_cache::Entry* null = NULL;
4138 disk_cache::Entry* entry;
4139 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
4140 EXPECT_NE(null, entry);
4141
4142 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
4143 CacheTestFillBuffer(buffer->data(), kSize, false);
4144 net::TestCompletionCallback callback;
4145 int ret;
4146
4147 // Verify initial conditions.
4148 ret = entry->ReadSparseData(0, buffer.get(), kSize, callback.callback());
4149 EXPECT_EQ(0, callback.GetResult(ret));
4150
4151 ret = entry->ReadSparseData(kSize, buffer.get(), kSize, callback.callback());
4152 EXPECT_EQ(0, callback.GetResult(ret));
4153
4154 // Write a range and make sure it reads back.
4155 ret = entry->WriteSparseData(0, buffer.get(), kSize, callback.callback());
4156 EXPECT_EQ(kSize, callback.GetResult(ret));
4157
4158 ret = entry->ReadSparseData(0, buffer.get(), kSize, callback.callback());
4159 EXPECT_EQ(kSize, callback.GetResult(ret));
4160
4161 // Write another range and make sure it reads back.
4162 ret = entry->WriteSparseData(kSize, buffer.get(), kSize, callback.callback());
4163 EXPECT_EQ(kSize, callback.GetResult(ret));
4164
4165 ret = entry->ReadSparseData(kSize, buffer.get(), kSize, callback.callback());
4166 EXPECT_EQ(kSize, callback.GetResult(ret));
4167
4168 // Make sure the first range was removed when the second was written.
4169 ret = entry->ReadSparseData(0, buffer.get(), kSize, callback.callback());
4170 EXPECT_EQ(0, callback.GetResult(ret));
4171
4172 entry->Close();
4173 }