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

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: net/disk_cache/backend_unittest.cc

Issue 992733002: Remove //net (except for Android test stuff) and sdch (Closed) Base URL: git@github.com:domokit/mojo.git@master
Patch Set: Created 5 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « net/data/websocket/websocket_worker_simple.js ('k') | net/disk_cache/blockfile/addr.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
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/files/file_util.h"
7 #include "base/metrics/field_trial.h"
8 #include "base/port.h"
9 #include "base/run_loop.h"
10 #include "base/strings/string_util.h"
11 #include "base/strings/stringprintf.h"
12 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
13 #include "base/thread_task_runner_handle.h"
14 #include "base/threading/platform_thread.h"
15 #include "base/threading/thread_restrictions.h"
16 #include "net/base/cache_type.h"
17 #include "net/base/io_buffer.h"
18 #include "net/base/net_errors.h"
19 #include "net/base/test_completion_callback.h"
20 #include "net/disk_cache/blockfile/backend_impl.h"
21 #include "net/disk_cache/blockfile/entry_impl.h"
22 #include "net/disk_cache/blockfile/experiments.h"
23 #include "net/disk_cache/blockfile/histogram_macros.h"
24 #include "net/disk_cache/blockfile/mapped_file.h"
25 #include "net/disk_cache/cache_util.h"
26 #include "net/disk_cache/disk_cache_test_base.h"
27 #include "net/disk_cache/disk_cache_test_util.h"
28 #include "net/disk_cache/memory/mem_backend_impl.h"
29 #include "net/disk_cache/simple/simple_backend_impl.h"
30 #include "net/disk_cache/simple/simple_entry_format.h"
31 #include "net/disk_cache/simple/simple_test_util.h"
32 #include "net/disk_cache/simple/simple_util.h"
33 #include "testing/gtest/include/gtest/gtest.h"
34
35 #if defined(OS_WIN)
36 #include "base/win/scoped_handle.h"
37 #endif
38
39 // Provide a BackendImpl object to macros from histogram_macros.h.
40 #define CACHE_UMA_BACKEND_IMPL_OBJ backend_
41
42 using base::Time;
43
44 namespace {
45
46 const char kExistingEntryKey[] = "existing entry key";
47
48 scoped_ptr<disk_cache::BackendImpl> CreateExistingEntryCache(
49 const base::Thread& cache_thread,
50 base::FilePath& cache_path) {
51 net::TestCompletionCallback cb;
52
53 scoped_ptr<disk_cache::BackendImpl> cache(new disk_cache::BackendImpl(
54 cache_path, cache_thread.message_loop_proxy(), NULL));
55 int rv = cache->Init(cb.callback());
56 if (cb.GetResult(rv) != net::OK)
57 return scoped_ptr<disk_cache::BackendImpl>();
58
59 disk_cache::Entry* entry = NULL;
60 rv = cache->CreateEntry(kExistingEntryKey, &entry, cb.callback());
61 if (cb.GetResult(rv) != net::OK)
62 return scoped_ptr<disk_cache::BackendImpl>();
63 entry->Close();
64
65 return cache.Pass();
66 }
67
68 } // namespace
69
70 // Tests that can run with different types of caches.
71 class DiskCacheBackendTest : public DiskCacheTestWithCache {
72 protected:
73 // Some utility methods:
74
75 // Perform IO operations on the cache until there is pending IO.
76 int GeneratePendingIO(net::TestCompletionCallback* cb);
77
78 // Adds 5 sparse entries. |doomed_start| and |doomed_end| if not NULL,
79 // will be filled with times, used by DoomEntriesSince and DoomEntriesBetween.
80 // There are 4 entries after doomed_start and 2 after doomed_end.
81 void InitSparseCache(base::Time* doomed_start, base::Time* doomed_end);
82
83 bool CreateSetOfRandomEntries(std::set<std::string>* key_pool);
84 bool EnumerateAndMatchKeys(int max_to_open,
85 TestIterator* iter,
86 std::set<std::string>* keys_to_match,
87 size_t* count);
88
89 // Actual tests:
90 void BackendBasics();
91 void BackendKeying();
92 void BackendShutdownWithPendingFileIO(bool fast);
93 void BackendShutdownWithPendingIO(bool fast);
94 void BackendShutdownWithPendingCreate(bool fast);
95 void BackendSetSize();
96 void BackendLoad();
97 void BackendChain();
98 void BackendValidEntry();
99 void BackendInvalidEntry();
100 void BackendInvalidEntryRead();
101 void BackendInvalidEntryWithLoad();
102 void BackendTrimInvalidEntry();
103 void BackendTrimInvalidEntry2();
104 void BackendEnumerations();
105 void BackendEnumerations2();
106 void BackendInvalidEntryEnumeration();
107 void BackendFixEnumerators();
108 void BackendDoomRecent();
109 void BackendDoomBetween();
110 void BackendTransaction(const std::string& name, int num_entries, bool load);
111 void BackendRecoverInsert();
112 void BackendRecoverRemove();
113 void BackendRecoverWithEviction();
114 void BackendInvalidEntry2();
115 void BackendInvalidEntry3();
116 void BackendInvalidEntry7();
117 void BackendInvalidEntry8();
118 void BackendInvalidEntry9(bool eviction);
119 void BackendInvalidEntry10(bool eviction);
120 void BackendInvalidEntry11(bool eviction);
121 void BackendTrimInvalidEntry12();
122 void BackendDoomAll();
123 void BackendDoomAll2();
124 void BackendInvalidRankings();
125 void BackendInvalidRankings2();
126 void BackendDisable();
127 void BackendDisable2();
128 void BackendDisable3();
129 void BackendDisable4();
130 };
131
132 int DiskCacheBackendTest::GeneratePendingIO(net::TestCompletionCallback* cb) {
133 if (!use_current_thread_) {
134 ADD_FAILURE();
135 return net::ERR_FAILED;
136 }
137
138 disk_cache::Entry* entry;
139 int rv = cache_->CreateEntry("some key", &entry, cb->callback());
140 if (cb->GetResult(rv) != net::OK)
141 return net::ERR_CACHE_CREATE_FAILURE;
142
143 const int kSize = 25000;
144 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
145 CacheTestFillBuffer(buffer->data(), kSize, false);
146
147 for (int i = 0; i < 10 * 1024 * 1024; i += 64 * 1024) {
148 // We are using the current thread as the cache thread because we want to
149 // be able to call directly this method to make sure that the OS (instead
150 // of us switching thread) is returning IO pending.
151 if (!simple_cache_mode_) {
152 rv = static_cast<disk_cache::EntryImpl*>(entry)->WriteDataImpl(
153 0, i, buffer.get(), kSize, cb->callback(), false);
154 } else {
155 rv = entry->WriteData(0, i, buffer.get(), kSize, cb->callback(), false);
156 }
157
158 if (rv == net::ERR_IO_PENDING)
159 break;
160 if (rv != kSize)
161 rv = net::ERR_FAILED;
162 }
163
164 // Don't call Close() to avoid going through the queue or we'll deadlock
165 // waiting for the operation to finish.
166 if (!simple_cache_mode_)
167 static_cast<disk_cache::EntryImpl*>(entry)->Release();
168 else
169 entry->Close();
170
171 return rv;
172 }
173
174 void DiskCacheBackendTest::InitSparseCache(base::Time* doomed_start,
175 base::Time* doomed_end) {
176 InitCache();
177
178 const int kSize = 50;
179 // This must be greater then MemEntryImpl::kMaxSparseEntrySize.
180 const int kOffset = 10 + 1024 * 1024;
181
182 disk_cache::Entry* entry0 = NULL;
183 disk_cache::Entry* entry1 = NULL;
184 disk_cache::Entry* entry2 = NULL;
185
186 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
187 CacheTestFillBuffer(buffer->data(), kSize, false);
188
189 ASSERT_EQ(net::OK, CreateEntry("zeroth", &entry0));
190 ASSERT_EQ(kSize, WriteSparseData(entry0, 0, buffer.get(), kSize));
191 ASSERT_EQ(kSize,
192 WriteSparseData(entry0, kOffset + kSize, buffer.get(), kSize));
193 entry0->Close();
194
195 FlushQueueForTest();
196 AddDelay();
197 if (doomed_start)
198 *doomed_start = base::Time::Now();
199
200 // Order in rankings list:
201 // first_part1, first_part2, second_part1, second_part2
202 ASSERT_EQ(net::OK, CreateEntry("first", &entry1));
203 ASSERT_EQ(kSize, WriteSparseData(entry1, 0, buffer.get(), kSize));
204 ASSERT_EQ(kSize,
205 WriteSparseData(entry1, kOffset + kSize, buffer.get(), kSize));
206 entry1->Close();
207
208 ASSERT_EQ(net::OK, CreateEntry("second", &entry2));
209 ASSERT_EQ(kSize, WriteSparseData(entry2, 0, buffer.get(), kSize));
210 ASSERT_EQ(kSize,
211 WriteSparseData(entry2, kOffset + kSize, buffer.get(), kSize));
212 entry2->Close();
213
214 FlushQueueForTest();
215 AddDelay();
216 if (doomed_end)
217 *doomed_end = base::Time::Now();
218
219 // Order in rankings list:
220 // third_part1, fourth_part1, third_part2, fourth_part2
221 disk_cache::Entry* entry3 = NULL;
222 disk_cache::Entry* entry4 = NULL;
223 ASSERT_EQ(net::OK, CreateEntry("third", &entry3));
224 ASSERT_EQ(kSize, WriteSparseData(entry3, 0, buffer.get(), kSize));
225 ASSERT_EQ(net::OK, CreateEntry("fourth", &entry4));
226 ASSERT_EQ(kSize, WriteSparseData(entry4, 0, buffer.get(), kSize));
227 ASSERT_EQ(kSize,
228 WriteSparseData(entry3, kOffset + kSize, buffer.get(), kSize));
229 ASSERT_EQ(kSize,
230 WriteSparseData(entry4, kOffset + kSize, buffer.get(), kSize));
231 entry3->Close();
232 entry4->Close();
233
234 FlushQueueForTest();
235 AddDelay();
236 }
237
238 // Creates entries based on random keys. Stores these keys in |key_pool|.
239 bool DiskCacheBackendTest::CreateSetOfRandomEntries(
240 std::set<std::string>* key_pool) {
241 const int kNumEntries = 10;
242
243 for (int i = 0; i < kNumEntries; ++i) {
244 std::string key = GenerateKey(true);
245 disk_cache::Entry* entry;
246 if (CreateEntry(key, &entry) != net::OK)
247 return false;
248 key_pool->insert(key);
249 entry->Close();
250 }
251 return key_pool->size() == implicit_cast<size_t>(cache_->GetEntryCount());
252 }
253
254 // Performs iteration over the backend and checks that the keys of entries
255 // opened are in |keys_to_match|, then erases them. Up to |max_to_open| entries
256 // will be opened, if it is positive. Otherwise, iteration will continue until
257 // OpenNextEntry stops returning net::OK.
258 bool DiskCacheBackendTest::EnumerateAndMatchKeys(
259 int max_to_open,
260 TestIterator* iter,
261 std::set<std::string>* keys_to_match,
262 size_t* count) {
263 disk_cache::Entry* entry;
264
265 if (!iter)
266 return false;
267 while (iter->OpenNextEntry(&entry) == net::OK) {
268 if (!entry)
269 return false;
270 EXPECT_EQ(1U, keys_to_match->erase(entry->GetKey()));
271 entry->Close();
272 ++(*count);
273 if (max_to_open >= 0 && implicit_cast<int>(*count) >= max_to_open)
274 break;
275 };
276
277 return true;
278 }
279
280 void DiskCacheBackendTest::BackendBasics() {
281 InitCache();
282 disk_cache::Entry *entry1 = NULL, *entry2 = NULL;
283 EXPECT_NE(net::OK, OpenEntry("the first key", &entry1));
284 ASSERT_EQ(net::OK, CreateEntry("the first key", &entry1));
285 ASSERT_TRUE(NULL != entry1);
286 entry1->Close();
287 entry1 = NULL;
288
289 ASSERT_EQ(net::OK, OpenEntry("the first key", &entry1));
290 ASSERT_TRUE(NULL != entry1);
291 entry1->Close();
292 entry1 = NULL;
293
294 EXPECT_NE(net::OK, CreateEntry("the first key", &entry1));
295 ASSERT_EQ(net::OK, OpenEntry("the first key", &entry1));
296 EXPECT_NE(net::OK, OpenEntry("some other key", &entry2));
297 ASSERT_EQ(net::OK, CreateEntry("some other key", &entry2));
298 ASSERT_TRUE(NULL != entry1);
299 ASSERT_TRUE(NULL != entry2);
300 EXPECT_EQ(2, cache_->GetEntryCount());
301
302 disk_cache::Entry* entry3 = NULL;
303 ASSERT_EQ(net::OK, OpenEntry("some other key", &entry3));
304 ASSERT_TRUE(NULL != entry3);
305 EXPECT_TRUE(entry2 == entry3);
306 EXPECT_EQ(2, cache_->GetEntryCount());
307
308 EXPECT_EQ(net::OK, DoomEntry("some other key"));
309 EXPECT_EQ(1, cache_->GetEntryCount());
310 entry1->Close();
311 entry2->Close();
312 entry3->Close();
313
314 EXPECT_EQ(net::OK, DoomEntry("the first key"));
315 EXPECT_EQ(0, cache_->GetEntryCount());
316
317 ASSERT_EQ(net::OK, CreateEntry("the first key", &entry1));
318 ASSERT_EQ(net::OK, CreateEntry("some other key", &entry2));
319 entry1->Doom();
320 entry1->Close();
321 EXPECT_EQ(net::OK, DoomEntry("some other key"));
322 EXPECT_EQ(0, cache_->GetEntryCount());
323 entry2->Close();
324 }
325
326 TEST_F(DiskCacheBackendTest, Basics) {
327 BackendBasics();
328 }
329
330 TEST_F(DiskCacheBackendTest, NewEvictionBasics) {
331 SetNewEviction();
332 BackendBasics();
333 }
334
335 TEST_F(DiskCacheBackendTest, MemoryOnlyBasics) {
336 SetMemoryOnlyMode();
337 BackendBasics();
338 }
339
340 TEST_F(DiskCacheBackendTest, AppCacheBasics) {
341 SetCacheType(net::APP_CACHE);
342 BackendBasics();
343 }
344
345 TEST_F(DiskCacheBackendTest, ShaderCacheBasics) {
346 SetCacheType(net::SHADER_CACHE);
347 BackendBasics();
348 }
349
350 void DiskCacheBackendTest::BackendKeying() {
351 InitCache();
352 const char kName1[] = "the first key";
353 const char kName2[] = "the first Key";
354 disk_cache::Entry *entry1, *entry2;
355 ASSERT_EQ(net::OK, CreateEntry(kName1, &entry1));
356
357 ASSERT_EQ(net::OK, CreateEntry(kName2, &entry2));
358 EXPECT_TRUE(entry1 != entry2) << "Case sensitive";
359 entry2->Close();
360
361 char buffer[30];
362 base::strlcpy(buffer, kName1, arraysize(buffer));
363 ASSERT_EQ(net::OK, OpenEntry(buffer, &entry2));
364 EXPECT_TRUE(entry1 == entry2);
365 entry2->Close();
366
367 base::strlcpy(buffer + 1, kName1, arraysize(buffer) - 1);
368 ASSERT_EQ(net::OK, OpenEntry(buffer + 1, &entry2));
369 EXPECT_TRUE(entry1 == entry2);
370 entry2->Close();
371
372 base::strlcpy(buffer + 3, kName1, arraysize(buffer) - 3);
373 ASSERT_EQ(net::OK, OpenEntry(buffer + 3, &entry2));
374 EXPECT_TRUE(entry1 == entry2);
375 entry2->Close();
376
377 // Now verify long keys.
378 char buffer2[20000];
379 memset(buffer2, 's', sizeof(buffer2));
380 buffer2[1023] = '\0';
381 ASSERT_EQ(net::OK, CreateEntry(buffer2, &entry2)) << "key on block file";
382 entry2->Close();
383
384 buffer2[1023] = 'g';
385 buffer2[19999] = '\0';
386 ASSERT_EQ(net::OK, CreateEntry(buffer2, &entry2)) << "key on external file";
387 entry2->Close();
388 entry1->Close();
389 }
390
391 TEST_F(DiskCacheBackendTest, Keying) {
392 BackendKeying();
393 }
394
395 TEST_F(DiskCacheBackendTest, NewEvictionKeying) {
396 SetNewEviction();
397 BackendKeying();
398 }
399
400 TEST_F(DiskCacheBackendTest, MemoryOnlyKeying) {
401 SetMemoryOnlyMode();
402 BackendKeying();
403 }
404
405 TEST_F(DiskCacheBackendTest, AppCacheKeying) {
406 SetCacheType(net::APP_CACHE);
407 BackendKeying();
408 }
409
410 TEST_F(DiskCacheBackendTest, ShaderCacheKeying) {
411 SetCacheType(net::SHADER_CACHE);
412 BackendKeying();
413 }
414
415 TEST_F(DiskCacheTest, CreateBackend) {
416 net::TestCompletionCallback cb;
417
418 {
419 ASSERT_TRUE(CleanupCacheDir());
420 base::Thread cache_thread("CacheThread");
421 ASSERT_TRUE(cache_thread.StartWithOptions(
422 base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
423
424 // Test the private factory method(s).
425 scoped_ptr<disk_cache::Backend> cache;
426 cache = disk_cache::MemBackendImpl::CreateBackend(0, NULL);
427 ASSERT_TRUE(cache.get());
428 cache.reset();
429
430 // Now test the public API.
431 int rv = disk_cache::CreateCacheBackend(net::DISK_CACHE,
432 net::CACHE_BACKEND_DEFAULT,
433 cache_path_,
434 0,
435 false,
436 cache_thread.task_runner(),
437 NULL,
438 &cache,
439 cb.callback());
440 ASSERT_EQ(net::OK, cb.GetResult(rv));
441 ASSERT_TRUE(cache.get());
442 cache.reset();
443
444 rv = disk_cache::CreateCacheBackend(net::MEMORY_CACHE,
445 net::CACHE_BACKEND_DEFAULT,
446 base::FilePath(), 0,
447 false, NULL, NULL, &cache,
448 cb.callback());
449 ASSERT_EQ(net::OK, cb.GetResult(rv));
450 ASSERT_TRUE(cache.get());
451 cache.reset();
452 }
453
454 base::MessageLoop::current()->RunUntilIdle();
455 }
456
457 // Tests that |BackendImpl| fails to initialize with a missing file.
458 TEST_F(DiskCacheBackendTest, CreateBackend_MissingFile) {
459 ASSERT_TRUE(CopyTestCache("bad_entry"));
460 base::FilePath filename = cache_path_.AppendASCII("data_1");
461 base::DeleteFile(filename, false);
462 base::Thread cache_thread("CacheThread");
463 ASSERT_TRUE(cache_thread.StartWithOptions(
464 base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
465 net::TestCompletionCallback cb;
466
467 bool prev = base::ThreadRestrictions::SetIOAllowed(false);
468 scoped_ptr<disk_cache::BackendImpl> cache(new disk_cache::BackendImpl(
469 cache_path_, cache_thread.task_runner(), NULL));
470 int rv = cache->Init(cb.callback());
471 EXPECT_EQ(net::ERR_FAILED, cb.GetResult(rv));
472 base::ThreadRestrictions::SetIOAllowed(prev);
473
474 cache.reset();
475 DisableIntegrityCheck();
476 }
477
478 TEST_F(DiskCacheBackendTest, ExternalFiles) {
479 InitCache();
480 // First, let's create a file on the folder.
481 base::FilePath filename = cache_path_.AppendASCII("f_000001");
482
483 const int kSize = 50;
484 scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
485 CacheTestFillBuffer(buffer1->data(), kSize, false);
486 ASSERT_EQ(kSize, base::WriteFile(filename, buffer1->data(), kSize));
487
488 // Now let's create a file with the cache.
489 disk_cache::Entry* entry;
490 ASSERT_EQ(net::OK, CreateEntry("key", &entry));
491 ASSERT_EQ(0, WriteData(entry, 0, 20000, buffer1.get(), 0, false));
492 entry->Close();
493
494 // And verify that the first file is still there.
495 scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
496 ASSERT_EQ(kSize, base::ReadFile(filename, buffer2->data(), kSize));
497 EXPECT_EQ(0, memcmp(buffer1->data(), buffer2->data(), kSize));
498 }
499
500 // Tests that we deal with file-level pending operations at destruction time.
501 void DiskCacheBackendTest::BackendShutdownWithPendingFileIO(bool fast) {
502 ASSERT_TRUE(CleanupCacheDir());
503 uint32 flags = disk_cache::kNoBuffering;
504 if (!fast)
505 flags |= disk_cache::kNoRandom;
506
507 UseCurrentThread();
508 CreateBackend(flags, NULL);
509
510 net::TestCompletionCallback cb;
511 int rv = GeneratePendingIO(&cb);
512
513 // The cache destructor will see one pending operation here.
514 cache_.reset();
515
516 if (rv == net::ERR_IO_PENDING) {
517 if (fast || simple_cache_mode_)
518 EXPECT_FALSE(cb.have_result());
519 else
520 EXPECT_TRUE(cb.have_result());
521 }
522
523 base::MessageLoop::current()->RunUntilIdle();
524
525 #if !defined(OS_IOS)
526 // Wait for the actual operation to complete, or we'll keep a file handle that
527 // may cause issues later. Note that on iOS systems even though this test
528 // uses a single thread, the actual IO is posted to a worker thread and the
529 // cache destructor breaks the link to reach cb when the operation completes.
530 rv = cb.GetResult(rv);
531 #endif
532 }
533
534 TEST_F(DiskCacheBackendTest, ShutdownWithPendingFileIO) {
535 BackendShutdownWithPendingFileIO(false);
536 }
537
538 // Here and below, tests that simulate crashes are not compiled in LeakSanitizer
539 // builds because they contain a lot of intentional memory leaks.
540 // The wrapper scripts used to run tests under Valgrind Memcheck will also
541 // disable these tests. See:
542 // tools/valgrind/gtest_exclude/net_unittests.gtest-memcheck.txt
543 #if !defined(LEAK_SANITIZER)
544 // We'll be leaking from this test.
545 TEST_F(DiskCacheBackendTest, ShutdownWithPendingFileIO_Fast) {
546 // The integrity test sets kNoRandom so there's a version mismatch if we don't
547 // force new eviction.
548 SetNewEviction();
549 BackendShutdownWithPendingFileIO(true);
550 }
551 #endif
552
553 // See crbug.com/330074
554 #if !defined(OS_IOS)
555 // Tests that one cache instance is not affected by another one going away.
556 TEST_F(DiskCacheBackendTest, MultipleInstancesWithPendingFileIO) {
557 base::ScopedTempDir store;
558 ASSERT_TRUE(store.CreateUniqueTempDir());
559
560 net::TestCompletionCallback cb;
561 scoped_ptr<disk_cache::Backend> extra_cache;
562 int rv = disk_cache::CreateCacheBackend(net::DISK_CACHE,
563 net::CACHE_BACKEND_DEFAULT,
564 store.path(),
565 0,
566 false,
567 base::ThreadTaskRunnerHandle::Get(),
568 NULL,
569 &extra_cache,
570 cb.callback());
571 ASSERT_EQ(net::OK, cb.GetResult(rv));
572 ASSERT_TRUE(extra_cache.get() != NULL);
573
574 ASSERT_TRUE(CleanupCacheDir());
575 SetNewEviction(); // Match the expected behavior for integrity verification.
576 UseCurrentThread();
577
578 CreateBackend(disk_cache::kNoBuffering, NULL);
579 rv = GeneratePendingIO(&cb);
580
581 // cache_ has a pending operation, and extra_cache will go away.
582 extra_cache.reset();
583
584 if (rv == net::ERR_IO_PENDING)
585 EXPECT_FALSE(cb.have_result());
586
587 base::MessageLoop::current()->RunUntilIdle();
588
589 // Wait for the actual operation to complete, or we'll keep a file handle that
590 // may cause issues later.
591 rv = cb.GetResult(rv);
592 }
593 #endif
594
595 // Tests that we deal with background-thread pending operations.
596 void DiskCacheBackendTest::BackendShutdownWithPendingIO(bool fast) {
597 net::TestCompletionCallback cb;
598
599 {
600 ASSERT_TRUE(CleanupCacheDir());
601 base::Thread cache_thread("CacheThread");
602 ASSERT_TRUE(cache_thread.StartWithOptions(
603 base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
604
605 uint32 flags = disk_cache::kNoBuffering;
606 if (!fast)
607 flags |= disk_cache::kNoRandom;
608
609 CreateBackend(flags, &cache_thread);
610
611 disk_cache::Entry* entry;
612 int rv = cache_->CreateEntry("some key", &entry, cb.callback());
613 ASSERT_EQ(net::OK, cb.GetResult(rv));
614
615 entry->Close();
616
617 // The cache destructor will see one pending operation here.
618 cache_.reset();
619 }
620
621 base::MessageLoop::current()->RunUntilIdle();
622 }
623
624 TEST_F(DiskCacheBackendTest, ShutdownWithPendingIO) {
625 BackendShutdownWithPendingIO(false);
626 }
627
628 #if !defined(LEAK_SANITIZER)
629 // We'll be leaking from this test.
630 TEST_F(DiskCacheBackendTest, ShutdownWithPendingIO_Fast) {
631 // The integrity test sets kNoRandom so there's a version mismatch if we don't
632 // force new eviction.
633 SetNewEviction();
634 BackendShutdownWithPendingIO(true);
635 }
636 #endif
637
638 // Tests that we deal with create-type pending operations.
639 void DiskCacheBackendTest::BackendShutdownWithPendingCreate(bool fast) {
640 net::TestCompletionCallback cb;
641
642 {
643 ASSERT_TRUE(CleanupCacheDir());
644 base::Thread cache_thread("CacheThread");
645 ASSERT_TRUE(cache_thread.StartWithOptions(
646 base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
647
648 disk_cache::BackendFlags flags =
649 fast ? disk_cache::kNone : disk_cache::kNoRandom;
650 CreateBackend(flags, &cache_thread);
651
652 disk_cache::Entry* entry;
653 int rv = cache_->CreateEntry("some key", &entry, cb.callback());
654 ASSERT_EQ(net::ERR_IO_PENDING, rv);
655
656 cache_.reset();
657 EXPECT_FALSE(cb.have_result());
658 }
659
660 base::MessageLoop::current()->RunUntilIdle();
661 }
662
663 TEST_F(DiskCacheBackendTest, ShutdownWithPendingCreate) {
664 BackendShutdownWithPendingCreate(false);
665 }
666
667 #if !defined(LEAK_SANITIZER)
668 // We'll be leaking an entry from this test.
669 TEST_F(DiskCacheBackendTest, ShutdownWithPendingCreate_Fast) {
670 // The integrity test sets kNoRandom so there's a version mismatch if we don't
671 // force new eviction.
672 SetNewEviction();
673 BackendShutdownWithPendingCreate(true);
674 }
675 #endif
676
677 // Disabled on android since this test requires cache creator to create
678 // blockfile caches.
679 #if !defined(OS_ANDROID)
680 TEST_F(DiskCacheTest, TruncatedIndex) {
681 ASSERT_TRUE(CleanupCacheDir());
682 base::FilePath index = cache_path_.AppendASCII("index");
683 ASSERT_EQ(5, base::WriteFile(index, "hello", 5));
684
685 base::Thread cache_thread("CacheThread");
686 ASSERT_TRUE(cache_thread.StartWithOptions(
687 base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
688 net::TestCompletionCallback cb;
689
690 scoped_ptr<disk_cache::Backend> backend;
691 int rv = disk_cache::CreateCacheBackend(net::DISK_CACHE,
692 net::CACHE_BACKEND_BLOCKFILE,
693 cache_path_,
694 0,
695 false,
696 cache_thread.task_runner(),
697 NULL,
698 &backend,
699 cb.callback());
700 ASSERT_NE(net::OK, cb.GetResult(rv));
701
702 ASSERT_FALSE(backend);
703 }
704 #endif
705
706 void DiskCacheBackendTest::BackendSetSize() {
707 const int cache_size = 0x10000; // 64 kB
708 SetMaxSize(cache_size);
709 InitCache();
710
711 std::string first("some key");
712 std::string second("something else");
713 disk_cache::Entry* entry;
714 ASSERT_EQ(net::OK, CreateEntry(first, &entry));
715
716 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(cache_size));
717 memset(buffer->data(), 0, cache_size);
718 EXPECT_EQ(cache_size / 10,
719 WriteData(entry, 0, 0, buffer.get(), cache_size / 10, false))
720 << "normal file";
721
722 EXPECT_EQ(net::ERR_FAILED,
723 WriteData(entry, 1, 0, buffer.get(), cache_size / 5, false))
724 << "file size above the limit";
725
726 // By doubling the total size, we make this file cacheable.
727 SetMaxSize(cache_size * 2);
728 EXPECT_EQ(cache_size / 5,
729 WriteData(entry, 1, 0, buffer.get(), cache_size / 5, false));
730
731 // Let's fill up the cache!.
732 SetMaxSize(cache_size * 10);
733 EXPECT_EQ(cache_size * 3 / 4,
734 WriteData(entry, 0, 0, buffer.get(), cache_size * 3 / 4, false));
735 entry->Close();
736 FlushQueueForTest();
737
738 SetMaxSize(cache_size);
739
740 // The cache is 95% full.
741
742 ASSERT_EQ(net::OK, CreateEntry(second, &entry));
743 EXPECT_EQ(cache_size / 10,
744 WriteData(entry, 0, 0, buffer.get(), cache_size / 10, false));
745
746 disk_cache::Entry* entry2;
747 ASSERT_EQ(net::OK, CreateEntry("an extra key", &entry2));
748 EXPECT_EQ(cache_size / 10,
749 WriteData(entry2, 0, 0, buffer.get(), cache_size / 10, false));
750 entry2->Close(); // This will trigger the cache trim.
751
752 EXPECT_NE(net::OK, OpenEntry(first, &entry2));
753
754 FlushQueueForTest(); // Make sure that we are done trimming the cache.
755 FlushQueueForTest(); // We may have posted two tasks to evict stuff.
756
757 entry->Close();
758 ASSERT_EQ(net::OK, OpenEntry(second, &entry));
759 EXPECT_EQ(cache_size / 10, entry->GetDataSize(0));
760 entry->Close();
761 }
762
763 TEST_F(DiskCacheBackendTest, SetSize) {
764 BackendSetSize();
765 }
766
767 TEST_F(DiskCacheBackendTest, NewEvictionSetSize) {
768 SetNewEviction();
769 BackendSetSize();
770 }
771
772 TEST_F(DiskCacheBackendTest, MemoryOnlySetSize) {
773 SetMemoryOnlyMode();
774 BackendSetSize();
775 }
776
777 void DiskCacheBackendTest::BackendLoad() {
778 InitCache();
779 int seed = static_cast<int>(Time::Now().ToInternalValue());
780 srand(seed);
781
782 disk_cache::Entry* entries[100];
783 for (int i = 0; i < 100; i++) {
784 std::string key = GenerateKey(true);
785 ASSERT_EQ(net::OK, CreateEntry(key, &entries[i]));
786 }
787 EXPECT_EQ(100, cache_->GetEntryCount());
788
789 for (int i = 0; i < 100; i++) {
790 int source1 = rand() % 100;
791 int source2 = rand() % 100;
792 disk_cache::Entry* temp = entries[source1];
793 entries[source1] = entries[source2];
794 entries[source2] = temp;
795 }
796
797 for (int i = 0; i < 100; i++) {
798 disk_cache::Entry* entry;
799 ASSERT_EQ(net::OK, OpenEntry(entries[i]->GetKey(), &entry));
800 EXPECT_TRUE(entry == entries[i]);
801 entry->Close();
802 entries[i]->Doom();
803 entries[i]->Close();
804 }
805 FlushQueueForTest();
806 EXPECT_EQ(0, cache_->GetEntryCount());
807 }
808
809 TEST_F(DiskCacheBackendTest, Load) {
810 // Work with a tiny index table (16 entries)
811 SetMask(0xf);
812 SetMaxSize(0x100000);
813 BackendLoad();
814 }
815
816 TEST_F(DiskCacheBackendTest, NewEvictionLoad) {
817 SetNewEviction();
818 // Work with a tiny index table (16 entries)
819 SetMask(0xf);
820 SetMaxSize(0x100000);
821 BackendLoad();
822 }
823
824 TEST_F(DiskCacheBackendTest, MemoryOnlyLoad) {
825 SetMaxSize(0x100000);
826 SetMemoryOnlyMode();
827 BackendLoad();
828 }
829
830 TEST_F(DiskCacheBackendTest, AppCacheLoad) {
831 SetCacheType(net::APP_CACHE);
832 // Work with a tiny index table (16 entries)
833 SetMask(0xf);
834 SetMaxSize(0x100000);
835 BackendLoad();
836 }
837
838 TEST_F(DiskCacheBackendTest, ShaderCacheLoad) {
839 SetCacheType(net::SHADER_CACHE);
840 // Work with a tiny index table (16 entries)
841 SetMask(0xf);
842 SetMaxSize(0x100000);
843 BackendLoad();
844 }
845
846 // Tests the chaining of an entry to the current head.
847 void DiskCacheBackendTest::BackendChain() {
848 SetMask(0x1); // 2-entry table.
849 SetMaxSize(0x3000); // 12 kB.
850 InitCache();
851
852 disk_cache::Entry* entry;
853 ASSERT_EQ(net::OK, CreateEntry("The first key", &entry));
854 entry->Close();
855 ASSERT_EQ(net::OK, CreateEntry("The Second key", &entry));
856 entry->Close();
857 }
858
859 TEST_F(DiskCacheBackendTest, Chain) {
860 BackendChain();
861 }
862
863 TEST_F(DiskCacheBackendTest, NewEvictionChain) {
864 SetNewEviction();
865 BackendChain();
866 }
867
868 TEST_F(DiskCacheBackendTest, AppCacheChain) {
869 SetCacheType(net::APP_CACHE);
870 BackendChain();
871 }
872
873 TEST_F(DiskCacheBackendTest, ShaderCacheChain) {
874 SetCacheType(net::SHADER_CACHE);
875 BackendChain();
876 }
877
878 TEST_F(DiskCacheBackendTest, NewEvictionTrim) {
879 SetNewEviction();
880 InitCache();
881
882 disk_cache::Entry* entry;
883 for (int i = 0; i < 100; i++) {
884 std::string name(base::StringPrintf("Key %d", i));
885 ASSERT_EQ(net::OK, CreateEntry(name, &entry));
886 entry->Close();
887 if (i < 90) {
888 // Entries 0 to 89 are in list 1; 90 to 99 are in list 0.
889 ASSERT_EQ(net::OK, OpenEntry(name, &entry));
890 entry->Close();
891 }
892 }
893
894 // The first eviction must come from list 1 (10% limit), the second must come
895 // from list 0.
896 TrimForTest(false);
897 EXPECT_NE(net::OK, OpenEntry("Key 0", &entry));
898 TrimForTest(false);
899 EXPECT_NE(net::OK, OpenEntry("Key 90", &entry));
900
901 // Double check that we still have the list tails.
902 ASSERT_EQ(net::OK, OpenEntry("Key 1", &entry));
903 entry->Close();
904 ASSERT_EQ(net::OK, OpenEntry("Key 91", &entry));
905 entry->Close();
906 }
907
908 // Before looking for invalid entries, let's check a valid entry.
909 void DiskCacheBackendTest::BackendValidEntry() {
910 InitCache();
911
912 std::string key("Some key");
913 disk_cache::Entry* entry;
914 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
915
916 const int kSize = 50;
917 scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
918 memset(buffer1->data(), 0, kSize);
919 base::strlcpy(buffer1->data(), "And the data to save", kSize);
920 EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer1.get(), kSize, false));
921 entry->Close();
922 SimulateCrash();
923
924 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
925
926 scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
927 memset(buffer2->data(), 0, kSize);
928 EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer2.get(), kSize));
929 entry->Close();
930 EXPECT_STREQ(buffer1->data(), buffer2->data());
931 }
932
933 TEST_F(DiskCacheBackendTest, ValidEntry) {
934 BackendValidEntry();
935 }
936
937 TEST_F(DiskCacheBackendTest, NewEvictionValidEntry) {
938 SetNewEviction();
939 BackendValidEntry();
940 }
941
942 // The same logic of the previous test (ValidEntry), but this time force the
943 // entry to be invalid, simulating a crash in the middle.
944 // We'll be leaking memory from this test.
945 void DiskCacheBackendTest::BackendInvalidEntry() {
946 InitCache();
947
948 std::string key("Some key");
949 disk_cache::Entry* entry;
950 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
951
952 const int kSize = 50;
953 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
954 memset(buffer->data(), 0, kSize);
955 base::strlcpy(buffer->data(), "And the data to save", kSize);
956 EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
957 SimulateCrash();
958
959 EXPECT_NE(net::OK, OpenEntry(key, &entry));
960 EXPECT_EQ(0, cache_->GetEntryCount());
961 }
962
963 #if !defined(LEAK_SANITIZER)
964 // We'll be leaking memory from this test.
965 TEST_F(DiskCacheBackendTest, InvalidEntry) {
966 BackendInvalidEntry();
967 }
968
969 // We'll be leaking memory from this test.
970 TEST_F(DiskCacheBackendTest, NewEvictionInvalidEntry) {
971 SetNewEviction();
972 BackendInvalidEntry();
973 }
974
975 // We'll be leaking memory from this test.
976 TEST_F(DiskCacheBackendTest, AppCacheInvalidEntry) {
977 SetCacheType(net::APP_CACHE);
978 BackendInvalidEntry();
979 }
980
981 // We'll be leaking memory from this test.
982 TEST_F(DiskCacheBackendTest, ShaderCacheInvalidEntry) {
983 SetCacheType(net::SHADER_CACHE);
984 BackendInvalidEntry();
985 }
986
987 // Almost the same test, but this time crash the cache after reading an entry.
988 // We'll be leaking memory from this test.
989 void DiskCacheBackendTest::BackendInvalidEntryRead() {
990 InitCache();
991
992 std::string key("Some key");
993 disk_cache::Entry* entry;
994 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
995
996 const int kSize = 50;
997 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
998 memset(buffer->data(), 0, kSize);
999 base::strlcpy(buffer->data(), "And the data to save", kSize);
1000 EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
1001 entry->Close();
1002 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
1003 EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer.get(), kSize));
1004
1005 SimulateCrash();
1006
1007 if (type_ == net::APP_CACHE) {
1008 // Reading an entry and crashing should not make it dirty.
1009 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
1010 EXPECT_EQ(1, cache_->GetEntryCount());
1011 entry->Close();
1012 } else {
1013 EXPECT_NE(net::OK, OpenEntry(key, &entry));
1014 EXPECT_EQ(0, cache_->GetEntryCount());
1015 }
1016 }
1017
1018 // We'll be leaking memory from this test.
1019 TEST_F(DiskCacheBackendTest, InvalidEntryRead) {
1020 BackendInvalidEntryRead();
1021 }
1022
1023 // We'll be leaking memory from this test.
1024 TEST_F(DiskCacheBackendTest, NewEvictionInvalidEntryRead) {
1025 SetNewEviction();
1026 BackendInvalidEntryRead();
1027 }
1028
1029 // We'll be leaking memory from this test.
1030 TEST_F(DiskCacheBackendTest, AppCacheInvalidEntryRead) {
1031 SetCacheType(net::APP_CACHE);
1032 BackendInvalidEntryRead();
1033 }
1034
1035 // We'll be leaking memory from this test.
1036 TEST_F(DiskCacheBackendTest, ShaderCacheInvalidEntryRead) {
1037 SetCacheType(net::SHADER_CACHE);
1038 BackendInvalidEntryRead();
1039 }
1040
1041 // We'll be leaking memory from this test.
1042 void DiskCacheBackendTest::BackendInvalidEntryWithLoad() {
1043 // Work with a tiny index table (16 entries)
1044 SetMask(0xf);
1045 SetMaxSize(0x100000);
1046 InitCache();
1047
1048 int seed = static_cast<int>(Time::Now().ToInternalValue());
1049 srand(seed);
1050
1051 const int kNumEntries = 100;
1052 disk_cache::Entry* entries[kNumEntries];
1053 for (int i = 0; i < kNumEntries; i++) {
1054 std::string key = GenerateKey(true);
1055 ASSERT_EQ(net::OK, CreateEntry(key, &entries[i]));
1056 }
1057 EXPECT_EQ(kNumEntries, cache_->GetEntryCount());
1058
1059 for (int i = 0; i < kNumEntries; i++) {
1060 int source1 = rand() % kNumEntries;
1061 int source2 = rand() % kNumEntries;
1062 disk_cache::Entry* temp = entries[source1];
1063 entries[source1] = entries[source2];
1064 entries[source2] = temp;
1065 }
1066
1067 std::string keys[kNumEntries];
1068 for (int i = 0; i < kNumEntries; i++) {
1069 keys[i] = entries[i]->GetKey();
1070 if (i < kNumEntries / 2)
1071 entries[i]->Close();
1072 }
1073
1074 SimulateCrash();
1075
1076 for (int i = kNumEntries / 2; i < kNumEntries; i++) {
1077 disk_cache::Entry* entry;
1078 EXPECT_NE(net::OK, OpenEntry(keys[i], &entry));
1079 }
1080
1081 for (int i = 0; i < kNumEntries / 2; i++) {
1082 disk_cache::Entry* entry;
1083 ASSERT_EQ(net::OK, OpenEntry(keys[i], &entry));
1084 entry->Close();
1085 }
1086
1087 EXPECT_EQ(kNumEntries / 2, cache_->GetEntryCount());
1088 }
1089
1090 // We'll be leaking memory from this test.
1091 TEST_F(DiskCacheBackendTest, InvalidEntryWithLoad) {
1092 BackendInvalidEntryWithLoad();
1093 }
1094
1095 // We'll be leaking memory from this test.
1096 TEST_F(DiskCacheBackendTest, NewEvictionInvalidEntryWithLoad) {
1097 SetNewEviction();
1098 BackendInvalidEntryWithLoad();
1099 }
1100
1101 // We'll be leaking memory from this test.
1102 TEST_F(DiskCacheBackendTest, AppCacheInvalidEntryWithLoad) {
1103 SetCacheType(net::APP_CACHE);
1104 BackendInvalidEntryWithLoad();
1105 }
1106
1107 // We'll be leaking memory from this test.
1108 TEST_F(DiskCacheBackendTest, ShaderCacheInvalidEntryWithLoad) {
1109 SetCacheType(net::SHADER_CACHE);
1110 BackendInvalidEntryWithLoad();
1111 }
1112
1113 // We'll be leaking memory from this test.
1114 void DiskCacheBackendTest::BackendTrimInvalidEntry() {
1115 const int kSize = 0x3000; // 12 kB
1116 SetMaxSize(kSize * 10);
1117 InitCache();
1118
1119 std::string first("some key");
1120 std::string second("something else");
1121 disk_cache::Entry* entry;
1122 ASSERT_EQ(net::OK, CreateEntry(first, &entry));
1123
1124 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
1125 memset(buffer->data(), 0, kSize);
1126 EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
1127
1128 // Simulate a crash.
1129 SimulateCrash();
1130
1131 ASSERT_EQ(net::OK, CreateEntry(second, &entry));
1132 EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
1133
1134 EXPECT_EQ(2, cache_->GetEntryCount());
1135 SetMaxSize(kSize);
1136 entry->Close(); // Trim the cache.
1137 FlushQueueForTest();
1138
1139 // If we evicted the entry in less than 20mS, we have one entry in the cache;
1140 // if it took more than that, we posted a task and we'll delete the second
1141 // entry too.
1142 base::MessageLoop::current()->RunUntilIdle();
1143
1144 // This may be not thread-safe in general, but for now it's OK so add some
1145 // ThreadSanitizer annotations to ignore data races on cache_.
1146 // See http://crbug.com/55970
1147 ANNOTATE_IGNORE_READS_BEGIN();
1148 EXPECT_GE(1, cache_->GetEntryCount());
1149 ANNOTATE_IGNORE_READS_END();
1150
1151 EXPECT_NE(net::OK, OpenEntry(first, &entry));
1152 }
1153
1154 // We'll be leaking memory from this test.
1155 TEST_F(DiskCacheBackendTest, TrimInvalidEntry) {
1156 BackendTrimInvalidEntry();
1157 }
1158
1159 // We'll be leaking memory from this test.
1160 TEST_F(DiskCacheBackendTest, NewEvictionTrimInvalidEntry) {
1161 SetNewEviction();
1162 BackendTrimInvalidEntry();
1163 }
1164
1165 // We'll be leaking memory from this test.
1166 void DiskCacheBackendTest::BackendTrimInvalidEntry2() {
1167 SetMask(0xf); // 16-entry table.
1168
1169 const int kSize = 0x3000; // 12 kB
1170 SetMaxSize(kSize * 40);
1171 InitCache();
1172
1173 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
1174 memset(buffer->data(), 0, kSize);
1175 disk_cache::Entry* entry;
1176
1177 // Writing 32 entries to this cache chains most of them.
1178 for (int i = 0; i < 32; i++) {
1179 std::string key(base::StringPrintf("some key %d", i));
1180 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1181 EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
1182 entry->Close();
1183 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
1184 // Note that we are not closing the entries.
1185 }
1186
1187 // Simulate a crash.
1188 SimulateCrash();
1189
1190 ASSERT_EQ(net::OK, CreateEntry("Something else", &entry));
1191 EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
1192
1193 FlushQueueForTest();
1194 EXPECT_EQ(33, cache_->GetEntryCount());
1195 SetMaxSize(kSize);
1196
1197 // For the new eviction code, all corrupt entries are on the second list so
1198 // they are not going away that easy.
1199 if (new_eviction_) {
1200 EXPECT_EQ(net::OK, DoomAllEntries());
1201 }
1202
1203 entry->Close(); // Trim the cache.
1204 FlushQueueForTest();
1205
1206 // We may abort the eviction before cleaning up everything.
1207 base::MessageLoop::current()->RunUntilIdle();
1208 FlushQueueForTest();
1209 // If it's not clear enough: we may still have eviction tasks running at this
1210 // time, so the number of entries is changing while we read it.
1211 ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN();
1212 EXPECT_GE(30, cache_->GetEntryCount());
1213 ANNOTATE_IGNORE_READS_AND_WRITES_END();
1214 }
1215
1216 // We'll be leaking memory from this test.
1217 TEST_F(DiskCacheBackendTest, TrimInvalidEntry2) {
1218 BackendTrimInvalidEntry2();
1219 }
1220
1221 // We'll be leaking memory from this test.
1222 TEST_F(DiskCacheBackendTest, NewEvictionTrimInvalidEntry2) {
1223 SetNewEviction();
1224 BackendTrimInvalidEntry2();
1225 }
1226 #endif // !defined(LEAK_SANITIZER)
1227
1228 void DiskCacheBackendTest::BackendEnumerations() {
1229 InitCache();
1230 Time initial = Time::Now();
1231
1232 const int kNumEntries = 100;
1233 for (int i = 0; i < kNumEntries; i++) {
1234 std::string key = GenerateKey(true);
1235 disk_cache::Entry* entry;
1236 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1237 entry->Close();
1238 }
1239 EXPECT_EQ(kNumEntries, cache_->GetEntryCount());
1240 Time final = Time::Now();
1241
1242 disk_cache::Entry* entry;
1243 scoped_ptr<TestIterator> iter = CreateIterator();
1244 int count = 0;
1245 Time last_modified[kNumEntries];
1246 Time last_used[kNumEntries];
1247 while (iter->OpenNextEntry(&entry) == net::OK) {
1248 ASSERT_TRUE(NULL != entry);
1249 if (count < kNumEntries) {
1250 last_modified[count] = entry->GetLastModified();
1251 last_used[count] = entry->GetLastUsed();
1252 EXPECT_TRUE(initial <= last_modified[count]);
1253 EXPECT_TRUE(final >= last_modified[count]);
1254 }
1255
1256 entry->Close();
1257 count++;
1258 };
1259 EXPECT_EQ(kNumEntries, count);
1260
1261 iter = CreateIterator();
1262 count = 0;
1263 // The previous enumeration should not have changed the timestamps.
1264 while (iter->OpenNextEntry(&entry) == net::OK) {
1265 ASSERT_TRUE(NULL != entry);
1266 if (count < kNumEntries) {
1267 EXPECT_TRUE(last_modified[count] == entry->GetLastModified());
1268 EXPECT_TRUE(last_used[count] == entry->GetLastUsed());
1269 }
1270 entry->Close();
1271 count++;
1272 };
1273 EXPECT_EQ(kNumEntries, count);
1274 }
1275
1276 TEST_F(DiskCacheBackendTest, Enumerations) {
1277 BackendEnumerations();
1278 }
1279
1280 TEST_F(DiskCacheBackendTest, NewEvictionEnumerations) {
1281 SetNewEviction();
1282 BackendEnumerations();
1283 }
1284
1285 TEST_F(DiskCacheBackendTest, MemoryOnlyEnumerations) {
1286 SetMemoryOnlyMode();
1287 BackendEnumerations();
1288 }
1289
1290 TEST_F(DiskCacheBackendTest, ShaderCacheEnumerations) {
1291 SetCacheType(net::SHADER_CACHE);
1292 BackendEnumerations();
1293 }
1294
1295 TEST_F(DiskCacheBackendTest, AppCacheEnumerations) {
1296 SetCacheType(net::APP_CACHE);
1297 BackendEnumerations();
1298 }
1299
1300 // Verifies enumerations while entries are open.
1301 void DiskCacheBackendTest::BackendEnumerations2() {
1302 InitCache();
1303 const std::string first("first");
1304 const std::string second("second");
1305 disk_cache::Entry *entry1, *entry2;
1306 ASSERT_EQ(net::OK, CreateEntry(first, &entry1));
1307 entry1->Close();
1308 ASSERT_EQ(net::OK, CreateEntry(second, &entry2));
1309 entry2->Close();
1310 FlushQueueForTest();
1311
1312 // Make sure that the timestamp is not the same.
1313 AddDelay();
1314 ASSERT_EQ(net::OK, OpenEntry(second, &entry1));
1315 scoped_ptr<TestIterator> iter = CreateIterator();
1316 ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry2));
1317 EXPECT_EQ(entry2->GetKey(), second);
1318
1319 // Two entries and the iterator pointing at "first".
1320 entry1->Close();
1321 entry2->Close();
1322
1323 // The iterator should still be valid, so we should not crash.
1324 ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry2));
1325 EXPECT_EQ(entry2->GetKey(), first);
1326 entry2->Close();
1327 iter = CreateIterator();
1328
1329 // Modify the oldest entry and get the newest element.
1330 ASSERT_EQ(net::OK, OpenEntry(first, &entry1));
1331 EXPECT_EQ(0, WriteData(entry1, 0, 200, NULL, 0, false));
1332 ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry2));
1333 if (type_ == net::APP_CACHE) {
1334 // The list is not updated.
1335 EXPECT_EQ(entry2->GetKey(), second);
1336 } else {
1337 EXPECT_EQ(entry2->GetKey(), first);
1338 }
1339
1340 entry1->Close();
1341 entry2->Close();
1342 }
1343
1344 TEST_F(DiskCacheBackendTest, Enumerations2) {
1345 BackendEnumerations2();
1346 }
1347
1348 TEST_F(DiskCacheBackendTest, NewEvictionEnumerations2) {
1349 SetNewEviction();
1350 BackendEnumerations2();
1351 }
1352
1353 TEST_F(DiskCacheBackendTest, MemoryOnlyEnumerations2) {
1354 SetMemoryOnlyMode();
1355 BackendEnumerations2();
1356 }
1357
1358 TEST_F(DiskCacheBackendTest, AppCacheEnumerations2) {
1359 SetCacheType(net::APP_CACHE);
1360 BackendEnumerations2();
1361 }
1362
1363 TEST_F(DiskCacheBackendTest, ShaderCacheEnumerations2) {
1364 SetCacheType(net::SHADER_CACHE);
1365 BackendEnumerations2();
1366 }
1367
1368 // Verify that ReadData calls do not update the LRU cache
1369 // when using the SHADER_CACHE type.
1370 TEST_F(DiskCacheBackendTest, ShaderCacheEnumerationReadData) {
1371 SetCacheType(net::SHADER_CACHE);
1372 InitCache();
1373 const std::string first("first");
1374 const std::string second("second");
1375 disk_cache::Entry *entry1, *entry2;
1376 const int kSize = 50;
1377 scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
1378
1379 ASSERT_EQ(net::OK, CreateEntry(first, &entry1));
1380 memset(buffer1->data(), 0, kSize);
1381 base::strlcpy(buffer1->data(), "And the data to save", kSize);
1382 EXPECT_EQ(kSize, WriteData(entry1, 0, 0, buffer1.get(), kSize, false));
1383
1384 ASSERT_EQ(net::OK, CreateEntry(second, &entry2));
1385 entry2->Close();
1386
1387 FlushQueueForTest();
1388
1389 // Make sure that the timestamp is not the same.
1390 AddDelay();
1391
1392 // Read from the last item in the LRU.
1393 EXPECT_EQ(kSize, ReadData(entry1, 0, 0, buffer1.get(), kSize));
1394 entry1->Close();
1395
1396 scoped_ptr<TestIterator> iter = CreateIterator();
1397 ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry2));
1398 EXPECT_EQ(entry2->GetKey(), second);
1399 entry2->Close();
1400 }
1401
1402 #if !defined(LEAK_SANITIZER)
1403 // Verify handling of invalid entries while doing enumerations.
1404 // We'll be leaking memory from this test.
1405 void DiskCacheBackendTest::BackendInvalidEntryEnumeration() {
1406 InitCache();
1407
1408 std::string key("Some key");
1409 disk_cache::Entry *entry, *entry1, *entry2;
1410 ASSERT_EQ(net::OK, CreateEntry(key, &entry1));
1411
1412 const int kSize = 50;
1413 scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
1414 memset(buffer1->data(), 0, kSize);
1415 base::strlcpy(buffer1->data(), "And the data to save", kSize);
1416 EXPECT_EQ(kSize, WriteData(entry1, 0, 0, buffer1.get(), kSize, false));
1417 entry1->Close();
1418 ASSERT_EQ(net::OK, OpenEntry(key, &entry1));
1419 EXPECT_EQ(kSize, ReadData(entry1, 0, 0, buffer1.get(), kSize));
1420
1421 std::string key2("Another key");
1422 ASSERT_EQ(net::OK, CreateEntry(key2, &entry2));
1423 entry2->Close();
1424 ASSERT_EQ(2, cache_->GetEntryCount());
1425
1426 SimulateCrash();
1427
1428 scoped_ptr<TestIterator> iter = CreateIterator();
1429 int count = 0;
1430 while (iter->OpenNextEntry(&entry) == net::OK) {
1431 ASSERT_TRUE(NULL != entry);
1432 EXPECT_EQ(key2, entry->GetKey());
1433 entry->Close();
1434 count++;
1435 };
1436 EXPECT_EQ(1, count);
1437 EXPECT_EQ(1, cache_->GetEntryCount());
1438 }
1439
1440 // We'll be leaking memory from this test.
1441 TEST_F(DiskCacheBackendTest, InvalidEntryEnumeration) {
1442 BackendInvalidEntryEnumeration();
1443 }
1444
1445 // We'll be leaking memory from this test.
1446 TEST_F(DiskCacheBackendTest, NewEvictionInvalidEntryEnumeration) {
1447 SetNewEviction();
1448 BackendInvalidEntryEnumeration();
1449 }
1450 #endif // !defined(LEAK_SANITIZER)
1451
1452 // Tests that if for some reason entries are modified close to existing cache
1453 // iterators, we don't generate fatal errors or reset the cache.
1454 void DiskCacheBackendTest::BackendFixEnumerators() {
1455 InitCache();
1456
1457 int seed = static_cast<int>(Time::Now().ToInternalValue());
1458 srand(seed);
1459
1460 const int kNumEntries = 10;
1461 for (int i = 0; i < kNumEntries; i++) {
1462 std::string key = GenerateKey(true);
1463 disk_cache::Entry* entry;
1464 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1465 entry->Close();
1466 }
1467 EXPECT_EQ(kNumEntries, cache_->GetEntryCount());
1468
1469 disk_cache::Entry *entry1, *entry2;
1470 scoped_ptr<TestIterator> iter1 = CreateIterator(), iter2 = CreateIterator();
1471 ASSERT_EQ(net::OK, iter1->OpenNextEntry(&entry1));
1472 ASSERT_TRUE(NULL != entry1);
1473 entry1->Close();
1474 entry1 = NULL;
1475
1476 // Let's go to the middle of the list.
1477 for (int i = 0; i < kNumEntries / 2; i++) {
1478 if (entry1)
1479 entry1->Close();
1480 ASSERT_EQ(net::OK, iter1->OpenNextEntry(&entry1));
1481 ASSERT_TRUE(NULL != entry1);
1482
1483 ASSERT_EQ(net::OK, iter2->OpenNextEntry(&entry2));
1484 ASSERT_TRUE(NULL != entry2);
1485 entry2->Close();
1486 }
1487
1488 // Messing up with entry1 will modify entry2->next.
1489 entry1->Doom();
1490 ASSERT_EQ(net::OK, iter2->OpenNextEntry(&entry2));
1491 ASSERT_TRUE(NULL != entry2);
1492
1493 // The link entry2->entry1 should be broken.
1494 EXPECT_NE(entry2->GetKey(), entry1->GetKey());
1495 entry1->Close();
1496 entry2->Close();
1497
1498 // And the second iterator should keep working.
1499 ASSERT_EQ(net::OK, iter2->OpenNextEntry(&entry2));
1500 ASSERT_TRUE(NULL != entry2);
1501 entry2->Close();
1502 }
1503
1504 TEST_F(DiskCacheBackendTest, FixEnumerators) {
1505 BackendFixEnumerators();
1506 }
1507
1508 TEST_F(DiskCacheBackendTest, NewEvictionFixEnumerators) {
1509 SetNewEviction();
1510 BackendFixEnumerators();
1511 }
1512
1513 void DiskCacheBackendTest::BackendDoomRecent() {
1514 InitCache();
1515
1516 disk_cache::Entry *entry;
1517 ASSERT_EQ(net::OK, CreateEntry("first", &entry));
1518 entry->Close();
1519 ASSERT_EQ(net::OK, CreateEntry("second", &entry));
1520 entry->Close();
1521 FlushQueueForTest();
1522
1523 AddDelay();
1524 Time middle = Time::Now();
1525
1526 ASSERT_EQ(net::OK, CreateEntry("third", &entry));
1527 entry->Close();
1528 ASSERT_EQ(net::OK, CreateEntry("fourth", &entry));
1529 entry->Close();
1530 FlushQueueForTest();
1531
1532 AddDelay();
1533 Time final = Time::Now();
1534
1535 ASSERT_EQ(4, cache_->GetEntryCount());
1536 EXPECT_EQ(net::OK, DoomEntriesSince(final));
1537 ASSERT_EQ(4, cache_->GetEntryCount());
1538
1539 EXPECT_EQ(net::OK, DoomEntriesSince(middle));
1540 ASSERT_EQ(2, cache_->GetEntryCount());
1541
1542 ASSERT_EQ(net::OK, OpenEntry("second", &entry));
1543 entry->Close();
1544 }
1545
1546 TEST_F(DiskCacheBackendTest, DoomRecent) {
1547 BackendDoomRecent();
1548 }
1549
1550 TEST_F(DiskCacheBackendTest, NewEvictionDoomRecent) {
1551 SetNewEviction();
1552 BackendDoomRecent();
1553 }
1554
1555 TEST_F(DiskCacheBackendTest, MemoryOnlyDoomRecent) {
1556 SetMemoryOnlyMode();
1557 BackendDoomRecent();
1558 }
1559
1560 TEST_F(DiskCacheBackendTest, MemoryOnlyDoomEntriesSinceSparse) {
1561 SetMemoryOnlyMode();
1562 base::Time start;
1563 InitSparseCache(&start, NULL);
1564 DoomEntriesSince(start);
1565 EXPECT_EQ(1, cache_->GetEntryCount());
1566 }
1567
1568 TEST_F(DiskCacheBackendTest, DoomEntriesSinceSparse) {
1569 base::Time start;
1570 InitSparseCache(&start, NULL);
1571 DoomEntriesSince(start);
1572 // NOTE: BackendImpl counts child entries in its GetEntryCount(), while
1573 // MemBackendImpl does not. Thats why expected value differs here from
1574 // MemoryOnlyDoomEntriesSinceSparse.
1575 EXPECT_EQ(3, cache_->GetEntryCount());
1576 }
1577
1578 TEST_F(DiskCacheBackendTest, MemoryOnlyDoomAllSparse) {
1579 SetMemoryOnlyMode();
1580 InitSparseCache(NULL, NULL);
1581 EXPECT_EQ(net::OK, DoomAllEntries());
1582 EXPECT_EQ(0, cache_->GetEntryCount());
1583 }
1584
1585 TEST_F(DiskCacheBackendTest, DoomAllSparse) {
1586 InitSparseCache(NULL, NULL);
1587 EXPECT_EQ(net::OK, DoomAllEntries());
1588 EXPECT_EQ(0, cache_->GetEntryCount());
1589 }
1590
1591 void DiskCacheBackendTest::BackendDoomBetween() {
1592 InitCache();
1593
1594 disk_cache::Entry *entry;
1595 ASSERT_EQ(net::OK, CreateEntry("first", &entry));
1596 entry->Close();
1597 FlushQueueForTest();
1598
1599 AddDelay();
1600 Time middle_start = Time::Now();
1601
1602 ASSERT_EQ(net::OK, CreateEntry("second", &entry));
1603 entry->Close();
1604 ASSERT_EQ(net::OK, CreateEntry("third", &entry));
1605 entry->Close();
1606 FlushQueueForTest();
1607
1608 AddDelay();
1609 Time middle_end = Time::Now();
1610
1611 ASSERT_EQ(net::OK, CreateEntry("fourth", &entry));
1612 entry->Close();
1613 ASSERT_EQ(net::OK, OpenEntry("fourth", &entry));
1614 entry->Close();
1615 FlushQueueForTest();
1616
1617 AddDelay();
1618 Time final = Time::Now();
1619
1620 ASSERT_EQ(4, cache_->GetEntryCount());
1621 EXPECT_EQ(net::OK, DoomEntriesBetween(middle_start, middle_end));
1622 ASSERT_EQ(2, cache_->GetEntryCount());
1623
1624 ASSERT_EQ(net::OK, OpenEntry("fourth", &entry));
1625 entry->Close();
1626
1627 EXPECT_EQ(net::OK, DoomEntriesBetween(middle_start, final));
1628 ASSERT_EQ(1, cache_->GetEntryCount());
1629
1630 ASSERT_EQ(net::OK, OpenEntry("first", &entry));
1631 entry->Close();
1632 }
1633
1634 TEST_F(DiskCacheBackendTest, DoomBetween) {
1635 BackendDoomBetween();
1636 }
1637
1638 TEST_F(DiskCacheBackendTest, NewEvictionDoomBetween) {
1639 SetNewEviction();
1640 BackendDoomBetween();
1641 }
1642
1643 TEST_F(DiskCacheBackendTest, MemoryOnlyDoomBetween) {
1644 SetMemoryOnlyMode();
1645 BackendDoomBetween();
1646 }
1647
1648 TEST_F(DiskCacheBackendTest, MemoryOnlyDoomEntriesBetweenSparse) {
1649 SetMemoryOnlyMode();
1650 base::Time start, end;
1651 InitSparseCache(&start, &end);
1652 DoomEntriesBetween(start, end);
1653 EXPECT_EQ(3, cache_->GetEntryCount());
1654
1655 start = end;
1656 end = base::Time::Now();
1657 DoomEntriesBetween(start, end);
1658 EXPECT_EQ(1, cache_->GetEntryCount());
1659 }
1660
1661 TEST_F(DiskCacheBackendTest, DoomEntriesBetweenSparse) {
1662 base::Time start, end;
1663 InitSparseCache(&start, &end);
1664 DoomEntriesBetween(start, end);
1665 EXPECT_EQ(9, cache_->GetEntryCount());
1666
1667 start = end;
1668 end = base::Time::Now();
1669 DoomEntriesBetween(start, end);
1670 EXPECT_EQ(3, cache_->GetEntryCount());
1671 }
1672
1673 void DiskCacheBackendTest::BackendTransaction(const std::string& name,
1674 int num_entries, bool load) {
1675 success_ = false;
1676 ASSERT_TRUE(CopyTestCache(name));
1677 DisableFirstCleanup();
1678
1679 uint32 mask;
1680 if (load) {
1681 mask = 0xf;
1682 SetMaxSize(0x100000);
1683 } else {
1684 // Clear the settings from the previous run.
1685 mask = 0;
1686 SetMaxSize(0);
1687 }
1688 SetMask(mask);
1689
1690 InitCache();
1691 ASSERT_EQ(num_entries + 1, cache_->GetEntryCount());
1692
1693 std::string key("the first key");
1694 disk_cache::Entry* entry1;
1695 ASSERT_NE(net::OK, OpenEntry(key, &entry1));
1696
1697 int actual = cache_->GetEntryCount();
1698 if (num_entries != actual) {
1699 ASSERT_TRUE(load);
1700 // If there is a heavy load, inserting an entry will make another entry
1701 // dirty (on the hash bucket) so two entries are removed.
1702 ASSERT_EQ(num_entries - 1, actual);
1703 }
1704
1705 cache_.reset();
1706 cache_impl_ = NULL;
1707
1708 ASSERT_TRUE(CheckCacheIntegrity(cache_path_, new_eviction_, mask));
1709 success_ = true;
1710 }
1711
1712 void DiskCacheBackendTest::BackendRecoverInsert() {
1713 // Tests with an empty cache.
1714 BackendTransaction("insert_empty1", 0, false);
1715 ASSERT_TRUE(success_) << "insert_empty1";
1716 BackendTransaction("insert_empty2", 0, false);
1717 ASSERT_TRUE(success_) << "insert_empty2";
1718 BackendTransaction("insert_empty3", 0, false);
1719 ASSERT_TRUE(success_) << "insert_empty3";
1720
1721 // Tests with one entry on the cache.
1722 BackendTransaction("insert_one1", 1, false);
1723 ASSERT_TRUE(success_) << "insert_one1";
1724 BackendTransaction("insert_one2", 1, false);
1725 ASSERT_TRUE(success_) << "insert_one2";
1726 BackendTransaction("insert_one3", 1, false);
1727 ASSERT_TRUE(success_) << "insert_one3";
1728
1729 // Tests with one hundred entries on the cache, tiny index.
1730 BackendTransaction("insert_load1", 100, true);
1731 ASSERT_TRUE(success_) << "insert_load1";
1732 BackendTransaction("insert_load2", 100, true);
1733 ASSERT_TRUE(success_) << "insert_load2";
1734 }
1735
1736 TEST_F(DiskCacheBackendTest, RecoverInsert) {
1737 BackendRecoverInsert();
1738 }
1739
1740 TEST_F(DiskCacheBackendTest, NewEvictionRecoverInsert) {
1741 SetNewEviction();
1742 BackendRecoverInsert();
1743 }
1744
1745 void DiskCacheBackendTest::BackendRecoverRemove() {
1746 // Removing the only element.
1747 BackendTransaction("remove_one1", 0, false);
1748 ASSERT_TRUE(success_) << "remove_one1";
1749 BackendTransaction("remove_one2", 0, false);
1750 ASSERT_TRUE(success_) << "remove_one2";
1751 BackendTransaction("remove_one3", 0, false);
1752 ASSERT_TRUE(success_) << "remove_one3";
1753
1754 // Removing the head.
1755 BackendTransaction("remove_head1", 1, false);
1756 ASSERT_TRUE(success_) << "remove_head1";
1757 BackendTransaction("remove_head2", 1, false);
1758 ASSERT_TRUE(success_) << "remove_head2";
1759 BackendTransaction("remove_head3", 1, false);
1760 ASSERT_TRUE(success_) << "remove_head3";
1761
1762 // Removing the tail.
1763 BackendTransaction("remove_tail1", 1, false);
1764 ASSERT_TRUE(success_) << "remove_tail1";
1765 BackendTransaction("remove_tail2", 1, false);
1766 ASSERT_TRUE(success_) << "remove_tail2";
1767 BackendTransaction("remove_tail3", 1, false);
1768 ASSERT_TRUE(success_) << "remove_tail3";
1769
1770 // Removing with one hundred entries on the cache, tiny index.
1771 BackendTransaction("remove_load1", 100, true);
1772 ASSERT_TRUE(success_) << "remove_load1";
1773 BackendTransaction("remove_load2", 100, true);
1774 ASSERT_TRUE(success_) << "remove_load2";
1775 BackendTransaction("remove_load3", 100, true);
1776 ASSERT_TRUE(success_) << "remove_load3";
1777
1778 // This case cannot be reverted.
1779 BackendTransaction("remove_one4", 0, false);
1780 ASSERT_TRUE(success_) << "remove_one4";
1781 BackendTransaction("remove_head4", 1, false);
1782 ASSERT_TRUE(success_) << "remove_head4";
1783 }
1784
1785 #if defined(OS_WIN)
1786 // http://crbug.com/396392
1787 #define MAYBE_RecoverRemove DISABLED_RecoverRemove
1788 #else
1789 #define MAYBE_RecoverRemove RecoverRemove
1790 #endif
1791 TEST_F(DiskCacheBackendTest, MAYBE_RecoverRemove) {
1792 BackendRecoverRemove();
1793 }
1794
1795 #if defined(OS_WIN)
1796 // http://crbug.com/396392
1797 #define MAYBE_NewEvictionRecoverRemove DISABLED_NewEvictionRecoverRemove
1798 #else
1799 #define MAYBE_NewEvictionRecoverRemove NewEvictionRecoverRemove
1800 #endif
1801 TEST_F(DiskCacheBackendTest, MAYBE_NewEvictionRecoverRemove) {
1802 SetNewEviction();
1803 BackendRecoverRemove();
1804 }
1805
1806 void DiskCacheBackendTest::BackendRecoverWithEviction() {
1807 success_ = false;
1808 ASSERT_TRUE(CopyTestCache("insert_load1"));
1809 DisableFirstCleanup();
1810
1811 SetMask(0xf);
1812 SetMaxSize(0x1000);
1813
1814 // We should not crash here.
1815 InitCache();
1816 DisableIntegrityCheck();
1817 }
1818
1819 TEST_F(DiskCacheBackendTest, RecoverWithEviction) {
1820 BackendRecoverWithEviction();
1821 }
1822
1823 TEST_F(DiskCacheBackendTest, NewEvictionRecoverWithEviction) {
1824 SetNewEviction();
1825 BackendRecoverWithEviction();
1826 }
1827
1828 // Tests that the |BackendImpl| fails to start with the wrong cache version.
1829 TEST_F(DiskCacheTest, WrongVersion) {
1830 ASSERT_TRUE(CopyTestCache("wrong_version"));
1831 base::Thread cache_thread("CacheThread");
1832 ASSERT_TRUE(cache_thread.StartWithOptions(
1833 base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
1834 net::TestCompletionCallback cb;
1835
1836 scoped_ptr<disk_cache::BackendImpl> cache(new disk_cache::BackendImpl(
1837 cache_path_, cache_thread.task_runner(), NULL));
1838 int rv = cache->Init(cb.callback());
1839 ASSERT_EQ(net::ERR_FAILED, cb.GetResult(rv));
1840 }
1841
1842 class BadEntropyProvider : public base::FieldTrial::EntropyProvider {
1843 public:
1844 ~BadEntropyProvider() override {}
1845
1846 double GetEntropyForTrial(const std::string& trial_name,
1847 uint32 randomization_seed) const override {
1848 return 0.5;
1849 }
1850 };
1851
1852 // Tests that the disk cache successfully joins the control group, dropping the
1853 // existing cache in favour of a new empty cache.
1854 // Disabled on android since this test requires cache creator to create
1855 // blockfile caches.
1856 #if !defined(OS_ANDROID)
1857 TEST_F(DiskCacheTest, SimpleCacheControlJoin) {
1858 base::Thread cache_thread("CacheThread");
1859 ASSERT_TRUE(cache_thread.StartWithOptions(
1860 base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
1861
1862 scoped_ptr<disk_cache::BackendImpl> cache =
1863 CreateExistingEntryCache(cache_thread, cache_path_);
1864 ASSERT_TRUE(cache.get());
1865 cache.reset();
1866
1867 // Instantiate the SimpleCacheTrial, forcing this run into the
1868 // ExperimentControl group.
1869 base::FieldTrialList field_trial_list(new BadEntropyProvider());
1870 base::FieldTrialList::CreateFieldTrial("SimpleCacheTrial",
1871 "ExperimentControl");
1872 net::TestCompletionCallback cb;
1873 scoped_ptr<disk_cache::Backend> base_cache;
1874 int rv = disk_cache::CreateCacheBackend(net::DISK_CACHE,
1875 net::CACHE_BACKEND_BLOCKFILE,
1876 cache_path_,
1877 0,
1878 true,
1879 cache_thread.task_runner(),
1880 NULL,
1881 &base_cache,
1882 cb.callback());
1883 ASSERT_EQ(net::OK, cb.GetResult(rv));
1884 EXPECT_EQ(0, base_cache->GetEntryCount());
1885 }
1886 #endif
1887
1888 // Tests that the disk cache can restart in the control group preserving
1889 // existing entries.
1890 TEST_F(DiskCacheTest, SimpleCacheControlRestart) {
1891 // Instantiate the SimpleCacheTrial, forcing this run into the
1892 // ExperimentControl group.
1893 base::FieldTrialList field_trial_list(new BadEntropyProvider());
1894 base::FieldTrialList::CreateFieldTrial("SimpleCacheTrial",
1895 "ExperimentControl");
1896
1897 base::Thread cache_thread("CacheThread");
1898 ASSERT_TRUE(cache_thread.StartWithOptions(
1899 base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
1900
1901 scoped_ptr<disk_cache::BackendImpl> cache =
1902 CreateExistingEntryCache(cache_thread, cache_path_);
1903 ASSERT_TRUE(cache.get());
1904
1905 net::TestCompletionCallback cb;
1906
1907 const int kRestartCount = 5;
1908 for (int i = 0; i < kRestartCount; ++i) {
1909 cache.reset(new disk_cache::BackendImpl(
1910 cache_path_, cache_thread.message_loop_proxy(), NULL));
1911 int rv = cache->Init(cb.callback());
1912 ASSERT_EQ(net::OK, cb.GetResult(rv));
1913 EXPECT_EQ(1, cache->GetEntryCount());
1914
1915 disk_cache::Entry* entry = NULL;
1916 rv = cache->OpenEntry(kExistingEntryKey, &entry, cb.callback());
1917 EXPECT_EQ(net::OK, cb.GetResult(rv));
1918 EXPECT_TRUE(entry);
1919 entry->Close();
1920 }
1921 }
1922
1923 // Tests that the disk cache can leave the control group preserving existing
1924 // entries.
1925 TEST_F(DiskCacheTest, SimpleCacheControlLeave) {
1926 base::Thread cache_thread("CacheThread");
1927 ASSERT_TRUE(cache_thread.StartWithOptions(
1928 base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
1929
1930 {
1931 // Instantiate the SimpleCacheTrial, forcing this run into the
1932 // ExperimentControl group.
1933 base::FieldTrialList field_trial_list(new BadEntropyProvider());
1934 base::FieldTrialList::CreateFieldTrial("SimpleCacheTrial",
1935 "ExperimentControl");
1936
1937 scoped_ptr<disk_cache::BackendImpl> cache =
1938 CreateExistingEntryCache(cache_thread, cache_path_);
1939 ASSERT_TRUE(cache.get());
1940 }
1941
1942 // Instantiate the SimpleCacheTrial, forcing this run into the
1943 // ExperimentNo group.
1944 base::FieldTrialList field_trial_list(new BadEntropyProvider());
1945 base::FieldTrialList::CreateFieldTrial("SimpleCacheTrial", "ExperimentNo");
1946 net::TestCompletionCallback cb;
1947
1948 const int kRestartCount = 5;
1949 for (int i = 0; i < kRestartCount; ++i) {
1950 scoped_ptr<disk_cache::BackendImpl> cache(new disk_cache::BackendImpl(
1951 cache_path_, cache_thread.message_loop_proxy(), NULL));
1952 int rv = cache->Init(cb.callback());
1953 ASSERT_EQ(net::OK, cb.GetResult(rv));
1954 EXPECT_EQ(1, cache->GetEntryCount());
1955
1956 disk_cache::Entry* entry = NULL;
1957 rv = cache->OpenEntry(kExistingEntryKey, &entry, cb.callback());
1958 EXPECT_EQ(net::OK, cb.GetResult(rv));
1959 EXPECT_TRUE(entry);
1960 entry->Close();
1961 }
1962 }
1963
1964 // Tests that the cache is properly restarted on recovery error.
1965 // Disabled on android since this test requires cache creator to create
1966 // blockfile caches.
1967 #if !defined(OS_ANDROID)
1968 TEST_F(DiskCacheBackendTest, DeleteOld) {
1969 ASSERT_TRUE(CopyTestCache("wrong_version"));
1970 SetNewEviction();
1971 base::Thread cache_thread("CacheThread");
1972 ASSERT_TRUE(cache_thread.StartWithOptions(
1973 base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
1974
1975 net::TestCompletionCallback cb;
1976 bool prev = base::ThreadRestrictions::SetIOAllowed(false);
1977 base::FilePath path(cache_path_);
1978 int rv = disk_cache::CreateCacheBackend(net::DISK_CACHE,
1979 net::CACHE_BACKEND_BLOCKFILE,
1980 path,
1981 0,
1982 true,
1983 cache_thread.task_runner(),
1984 NULL,
1985 &cache_,
1986 cb.callback());
1987 path.clear(); // Make sure path was captured by the previous call.
1988 ASSERT_EQ(net::OK, cb.GetResult(rv));
1989 base::ThreadRestrictions::SetIOAllowed(prev);
1990 cache_.reset();
1991 EXPECT_TRUE(CheckCacheIntegrity(cache_path_, new_eviction_, mask_));
1992 }
1993 #endif
1994
1995 // We want to be able to deal with messed up entries on disk.
1996 void DiskCacheBackendTest::BackendInvalidEntry2() {
1997 ASSERT_TRUE(CopyTestCache("bad_entry"));
1998 DisableFirstCleanup();
1999 InitCache();
2000
2001 disk_cache::Entry *entry1, *entry2;
2002 ASSERT_EQ(net::OK, OpenEntry("the first key", &entry1));
2003 EXPECT_NE(net::OK, OpenEntry("some other key", &entry2));
2004 entry1->Close();
2005
2006 // CheckCacheIntegrity will fail at this point.
2007 DisableIntegrityCheck();
2008 }
2009
2010 TEST_F(DiskCacheBackendTest, InvalidEntry2) {
2011 BackendInvalidEntry2();
2012 }
2013
2014 TEST_F(DiskCacheBackendTest, NewEvictionInvalidEntry2) {
2015 SetNewEviction();
2016 BackendInvalidEntry2();
2017 }
2018
2019 // Tests that we don't crash or hang when enumerating this cache.
2020 void DiskCacheBackendTest::BackendInvalidEntry3() {
2021 SetMask(0x1); // 2-entry table.
2022 SetMaxSize(0x3000); // 12 kB.
2023 DisableFirstCleanup();
2024 InitCache();
2025
2026 disk_cache::Entry* entry;
2027 scoped_ptr<TestIterator> iter = CreateIterator();
2028 while (iter->OpenNextEntry(&entry) == net::OK) {
2029 entry->Close();
2030 }
2031 }
2032
2033 TEST_F(DiskCacheBackendTest, InvalidEntry3) {
2034 ASSERT_TRUE(CopyTestCache("dirty_entry3"));
2035 BackendInvalidEntry3();
2036 }
2037
2038 TEST_F(DiskCacheBackendTest, NewEvictionInvalidEntry3) {
2039 ASSERT_TRUE(CopyTestCache("dirty_entry4"));
2040 SetNewEviction();
2041 BackendInvalidEntry3();
2042 DisableIntegrityCheck();
2043 }
2044
2045 // Test that we handle a dirty entry on the LRU list, already replaced with
2046 // the same key, and with hash collisions.
2047 TEST_F(DiskCacheBackendTest, InvalidEntry4) {
2048 ASSERT_TRUE(CopyTestCache("dirty_entry3"));
2049 SetMask(0x1); // 2-entry table.
2050 SetMaxSize(0x3000); // 12 kB.
2051 DisableFirstCleanup();
2052 InitCache();
2053
2054 TrimForTest(false);
2055 }
2056
2057 // Test that we handle a dirty entry on the deleted list, already replaced with
2058 // the same key, and with hash collisions.
2059 TEST_F(DiskCacheBackendTest, InvalidEntry5) {
2060 ASSERT_TRUE(CopyTestCache("dirty_entry4"));
2061 SetNewEviction();
2062 SetMask(0x1); // 2-entry table.
2063 SetMaxSize(0x3000); // 12 kB.
2064 DisableFirstCleanup();
2065 InitCache();
2066
2067 TrimDeletedListForTest(false);
2068 }
2069
2070 TEST_F(DiskCacheBackendTest, InvalidEntry6) {
2071 ASSERT_TRUE(CopyTestCache("dirty_entry5"));
2072 SetMask(0x1); // 2-entry table.
2073 SetMaxSize(0x3000); // 12 kB.
2074 DisableFirstCleanup();
2075 InitCache();
2076
2077 // There is a dirty entry (but marked as clean) at the end, pointing to a
2078 // deleted entry through the hash collision list. We should not re-insert the
2079 // deleted entry into the index table.
2080
2081 TrimForTest(false);
2082 // The cache should be clean (as detected by CheckCacheIntegrity).
2083 }
2084
2085 // Tests that we don't hang when there is a loop on the hash collision list.
2086 // The test cache could be a result of bug 69135.
2087 TEST_F(DiskCacheBackendTest, BadNextEntry1) {
2088 ASSERT_TRUE(CopyTestCache("list_loop2"));
2089 SetMask(0x1); // 2-entry table.
2090 SetMaxSize(0x3000); // 12 kB.
2091 DisableFirstCleanup();
2092 InitCache();
2093
2094 // The second entry points at itselft, and the first entry is not accessible
2095 // though the index, but it is at the head of the LRU.
2096
2097 disk_cache::Entry* entry;
2098 ASSERT_EQ(net::OK, CreateEntry("The first key", &entry));
2099 entry->Close();
2100
2101 TrimForTest(false);
2102 TrimForTest(false);
2103 ASSERT_EQ(net::OK, OpenEntry("The first key", &entry));
2104 entry->Close();
2105 EXPECT_EQ(1, cache_->GetEntryCount());
2106 }
2107
2108 // Tests that we don't hang when there is a loop on the hash collision list.
2109 // The test cache could be a result of bug 69135.
2110 TEST_F(DiskCacheBackendTest, BadNextEntry2) {
2111 ASSERT_TRUE(CopyTestCache("list_loop3"));
2112 SetMask(0x1); // 2-entry table.
2113 SetMaxSize(0x3000); // 12 kB.
2114 DisableFirstCleanup();
2115 InitCache();
2116
2117 // There is a wide loop of 5 entries.
2118
2119 disk_cache::Entry* entry;
2120 ASSERT_NE(net::OK, OpenEntry("Not present key", &entry));
2121 }
2122
2123 TEST_F(DiskCacheBackendTest, NewEvictionInvalidEntry6) {
2124 ASSERT_TRUE(CopyTestCache("bad_rankings3"));
2125 DisableFirstCleanup();
2126 SetNewEviction();
2127 InitCache();
2128
2129 // The second entry is dirty, but removing it should not corrupt the list.
2130 disk_cache::Entry* entry;
2131 ASSERT_NE(net::OK, OpenEntry("the second key", &entry));
2132 ASSERT_EQ(net::OK, OpenEntry("the first key", &entry));
2133
2134 // This should not delete the cache.
2135 entry->Doom();
2136 FlushQueueForTest();
2137 entry->Close();
2138
2139 ASSERT_EQ(net::OK, OpenEntry("some other key", &entry));
2140 entry->Close();
2141 }
2142
2143 // Tests handling of corrupt entries by keeping the rankings node around, with
2144 // a fatal failure.
2145 void DiskCacheBackendTest::BackendInvalidEntry7() {
2146 const int kSize = 0x3000; // 12 kB.
2147 SetMaxSize(kSize * 10);
2148 InitCache();
2149
2150 std::string first("some key");
2151 std::string second("something else");
2152 disk_cache::Entry* entry;
2153 ASSERT_EQ(net::OK, CreateEntry(first, &entry));
2154 entry->Close();
2155 ASSERT_EQ(net::OK, CreateEntry(second, &entry));
2156
2157 // Corrupt this entry.
2158 disk_cache::EntryImpl* entry_impl =
2159 static_cast<disk_cache::EntryImpl*>(entry);
2160
2161 entry_impl->rankings()->Data()->next = 0;
2162 entry_impl->rankings()->Store();
2163 entry->Close();
2164 FlushQueueForTest();
2165 EXPECT_EQ(2, cache_->GetEntryCount());
2166
2167 // This should detect the bad entry.
2168 EXPECT_NE(net::OK, OpenEntry(second, &entry));
2169 EXPECT_EQ(1, cache_->GetEntryCount());
2170
2171 // We should delete the cache. The list still has a corrupt node.
2172 scoped_ptr<TestIterator> iter = CreateIterator();
2173 EXPECT_NE(net::OK, iter->OpenNextEntry(&entry));
2174 FlushQueueForTest();
2175 EXPECT_EQ(0, cache_->GetEntryCount());
2176 }
2177
2178 TEST_F(DiskCacheBackendTest, InvalidEntry7) {
2179 BackendInvalidEntry7();
2180 }
2181
2182 TEST_F(DiskCacheBackendTest, NewEvictionInvalidEntry7) {
2183 SetNewEviction();
2184 BackendInvalidEntry7();
2185 }
2186
2187 // Tests handling of corrupt entries by keeping the rankings node around, with
2188 // a non fatal failure.
2189 void DiskCacheBackendTest::BackendInvalidEntry8() {
2190 const int kSize = 0x3000; // 12 kB
2191 SetMaxSize(kSize * 10);
2192 InitCache();
2193
2194 std::string first("some key");
2195 std::string second("something else");
2196 disk_cache::Entry* entry;
2197 ASSERT_EQ(net::OK, CreateEntry(first, &entry));
2198 entry->Close();
2199 ASSERT_EQ(net::OK, CreateEntry(second, &entry));
2200
2201 // Corrupt this entry.
2202 disk_cache::EntryImpl* entry_impl =
2203 static_cast<disk_cache::EntryImpl*>(entry);
2204
2205 entry_impl->rankings()->Data()->contents = 0;
2206 entry_impl->rankings()->Store();
2207 entry->Close();
2208 FlushQueueForTest();
2209 EXPECT_EQ(2, cache_->GetEntryCount());
2210
2211 // This should detect the bad entry.
2212 EXPECT_NE(net::OK, OpenEntry(second, &entry));
2213 EXPECT_EQ(1, cache_->GetEntryCount());
2214
2215 // We should not delete the cache.
2216 scoped_ptr<TestIterator> iter = CreateIterator();
2217 ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry));
2218 entry->Close();
2219 EXPECT_NE(net::OK, iter->OpenNextEntry(&entry));
2220 EXPECT_EQ(1, cache_->GetEntryCount());
2221 }
2222
2223 TEST_F(DiskCacheBackendTest, InvalidEntry8) {
2224 BackendInvalidEntry8();
2225 }
2226
2227 TEST_F(DiskCacheBackendTest, NewEvictionInvalidEntry8) {
2228 SetNewEviction();
2229 BackendInvalidEntry8();
2230 }
2231
2232 // Tests handling of corrupt entries detected by enumerations. Note that these
2233 // tests (xx9 to xx11) are basically just going though slightly different
2234 // codepaths so they are tighlty coupled with the code, but that is better than
2235 // not testing error handling code.
2236 void DiskCacheBackendTest::BackendInvalidEntry9(bool eviction) {
2237 const int kSize = 0x3000; // 12 kB.
2238 SetMaxSize(kSize * 10);
2239 InitCache();
2240
2241 std::string first("some key");
2242 std::string second("something else");
2243 disk_cache::Entry* entry;
2244 ASSERT_EQ(net::OK, CreateEntry(first, &entry));
2245 entry->Close();
2246 ASSERT_EQ(net::OK, CreateEntry(second, &entry));
2247
2248 // Corrupt this entry.
2249 disk_cache::EntryImpl* entry_impl =
2250 static_cast<disk_cache::EntryImpl*>(entry);
2251
2252 entry_impl->entry()->Data()->state = 0xbad;
2253 entry_impl->entry()->Store();
2254 entry->Close();
2255 FlushQueueForTest();
2256 EXPECT_EQ(2, cache_->GetEntryCount());
2257
2258 if (eviction) {
2259 TrimForTest(false);
2260 EXPECT_EQ(1, cache_->GetEntryCount());
2261 TrimForTest(false);
2262 EXPECT_EQ(1, cache_->GetEntryCount());
2263 } else {
2264 // We should detect the problem through the list, but we should not delete
2265 // the entry, just fail the iteration.
2266 scoped_ptr<TestIterator> iter = CreateIterator();
2267 EXPECT_NE(net::OK, iter->OpenNextEntry(&entry));
2268
2269 // Now a full iteration will work, and return one entry.
2270 ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry));
2271 entry->Close();
2272 EXPECT_NE(net::OK, iter->OpenNextEntry(&entry));
2273
2274 // This should detect what's left of the bad entry.
2275 EXPECT_NE(net::OK, OpenEntry(second, &entry));
2276 EXPECT_EQ(2, cache_->GetEntryCount());
2277 }
2278 DisableIntegrityCheck();
2279 }
2280
2281 TEST_F(DiskCacheBackendTest, InvalidEntry9) {
2282 BackendInvalidEntry9(false);
2283 }
2284
2285 TEST_F(DiskCacheBackendTest, NewEvictionInvalidEntry9) {
2286 SetNewEviction();
2287 BackendInvalidEntry9(false);
2288 }
2289
2290 TEST_F(DiskCacheBackendTest, TrimInvalidEntry9) {
2291 BackendInvalidEntry9(true);
2292 }
2293
2294 TEST_F(DiskCacheBackendTest, NewEvictionTrimInvalidEntry9) {
2295 SetNewEviction();
2296 BackendInvalidEntry9(true);
2297 }
2298
2299 // Tests handling of corrupt entries detected by enumerations.
2300 void DiskCacheBackendTest::BackendInvalidEntry10(bool eviction) {
2301 const int kSize = 0x3000; // 12 kB.
2302 SetMaxSize(kSize * 10);
2303 SetNewEviction();
2304 InitCache();
2305
2306 std::string first("some key");
2307 std::string second("something else");
2308 disk_cache::Entry* entry;
2309 ASSERT_EQ(net::OK, CreateEntry(first, &entry));
2310 entry->Close();
2311 ASSERT_EQ(net::OK, OpenEntry(first, &entry));
2312 EXPECT_EQ(0, WriteData(entry, 0, 200, NULL, 0, false));
2313 entry->Close();
2314 ASSERT_EQ(net::OK, CreateEntry(second, &entry));
2315
2316 // Corrupt this entry.
2317 disk_cache::EntryImpl* entry_impl =
2318 static_cast<disk_cache::EntryImpl*>(entry);
2319
2320 entry_impl->entry()->Data()->state = 0xbad;
2321 entry_impl->entry()->Store();
2322 entry->Close();
2323 ASSERT_EQ(net::OK, CreateEntry("third", &entry));
2324 entry->Close();
2325 EXPECT_EQ(3, cache_->GetEntryCount());
2326
2327 // We have:
2328 // List 0: third -> second (bad).
2329 // List 1: first.
2330
2331 if (eviction) {
2332 // Detection order: second -> first -> third.
2333 TrimForTest(false);
2334 EXPECT_EQ(3, cache_->GetEntryCount());
2335 TrimForTest(false);
2336 EXPECT_EQ(2, cache_->GetEntryCount());
2337 TrimForTest(false);
2338 EXPECT_EQ(1, cache_->GetEntryCount());
2339 } else {
2340 // Detection order: third -> second -> first.
2341 // We should detect the problem through the list, but we should not delete
2342 // the entry.
2343 scoped_ptr<TestIterator> iter = CreateIterator();
2344 ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry));
2345 entry->Close();
2346 ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry));
2347 EXPECT_EQ(first, entry->GetKey());
2348 entry->Close();
2349 EXPECT_NE(net::OK, iter->OpenNextEntry(&entry));
2350 }
2351 DisableIntegrityCheck();
2352 }
2353
2354 TEST_F(DiskCacheBackendTest, InvalidEntry10) {
2355 BackendInvalidEntry10(false);
2356 }
2357
2358 TEST_F(DiskCacheBackendTest, TrimInvalidEntry10) {
2359 BackendInvalidEntry10(true);
2360 }
2361
2362 // Tests handling of corrupt entries detected by enumerations.
2363 void DiskCacheBackendTest::BackendInvalidEntry11(bool eviction) {
2364 const int kSize = 0x3000; // 12 kB.
2365 SetMaxSize(kSize * 10);
2366 SetNewEviction();
2367 InitCache();
2368
2369 std::string first("some key");
2370 std::string second("something else");
2371 disk_cache::Entry* entry;
2372 ASSERT_EQ(net::OK, CreateEntry(first, &entry));
2373 entry->Close();
2374 ASSERT_EQ(net::OK, OpenEntry(first, &entry));
2375 EXPECT_EQ(0, WriteData(entry, 0, 200, NULL, 0, false));
2376 entry->Close();
2377 ASSERT_EQ(net::OK, CreateEntry(second, &entry));
2378 entry->Close();
2379 ASSERT_EQ(net::OK, OpenEntry(second, &entry));
2380 EXPECT_EQ(0, WriteData(entry, 0, 200, NULL, 0, false));
2381
2382 // Corrupt this entry.
2383 disk_cache::EntryImpl* entry_impl =
2384 static_cast<disk_cache::EntryImpl*>(entry);
2385
2386 entry_impl->entry()->Data()->state = 0xbad;
2387 entry_impl->entry()->Store();
2388 entry->Close();
2389 ASSERT_EQ(net::OK, CreateEntry("third", &entry));
2390 entry->Close();
2391 FlushQueueForTest();
2392 EXPECT_EQ(3, cache_->GetEntryCount());
2393
2394 // We have:
2395 // List 0: third.
2396 // List 1: second (bad) -> first.
2397
2398 if (eviction) {
2399 // Detection order: third -> first -> second.
2400 TrimForTest(false);
2401 EXPECT_EQ(2, cache_->GetEntryCount());
2402 TrimForTest(false);
2403 EXPECT_EQ(1, cache_->GetEntryCount());
2404 TrimForTest(false);
2405 EXPECT_EQ(1, cache_->GetEntryCount());
2406 } else {
2407 // Detection order: third -> second.
2408 // We should detect the problem through the list, but we should not delete
2409 // the entry, just fail the iteration.
2410 scoped_ptr<TestIterator> iter = CreateIterator();
2411 ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry));
2412 entry->Close();
2413 EXPECT_NE(net::OK, iter->OpenNextEntry(&entry));
2414
2415 // Now a full iteration will work, and return two entries.
2416 ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry));
2417 entry->Close();
2418 ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry));
2419 entry->Close();
2420 EXPECT_NE(net::OK, iter->OpenNextEntry(&entry));
2421 }
2422 DisableIntegrityCheck();
2423 }
2424
2425 TEST_F(DiskCacheBackendTest, InvalidEntry11) {
2426 BackendInvalidEntry11(false);
2427 }
2428
2429 TEST_F(DiskCacheBackendTest, TrimInvalidEntry11) {
2430 BackendInvalidEntry11(true);
2431 }
2432
2433 // Tests handling of corrupt entries in the middle of a long eviction run.
2434 void DiskCacheBackendTest::BackendTrimInvalidEntry12() {
2435 const int kSize = 0x3000; // 12 kB
2436 SetMaxSize(kSize * 10);
2437 InitCache();
2438
2439 std::string first("some key");
2440 std::string second("something else");
2441 disk_cache::Entry* entry;
2442 ASSERT_EQ(net::OK, CreateEntry(first, &entry));
2443 entry->Close();
2444 ASSERT_EQ(net::OK, CreateEntry(second, &entry));
2445
2446 // Corrupt this entry.
2447 disk_cache::EntryImpl* entry_impl =
2448 static_cast<disk_cache::EntryImpl*>(entry);
2449
2450 entry_impl->entry()->Data()->state = 0xbad;
2451 entry_impl->entry()->Store();
2452 entry->Close();
2453 ASSERT_EQ(net::OK, CreateEntry("third", &entry));
2454 entry->Close();
2455 ASSERT_EQ(net::OK, CreateEntry("fourth", &entry));
2456 TrimForTest(true);
2457 EXPECT_EQ(1, cache_->GetEntryCount());
2458 entry->Close();
2459 DisableIntegrityCheck();
2460 }
2461
2462 TEST_F(DiskCacheBackendTest, TrimInvalidEntry12) {
2463 BackendTrimInvalidEntry12();
2464 }
2465
2466 TEST_F(DiskCacheBackendTest, NewEvictionTrimInvalidEntry12) {
2467 SetNewEviction();
2468 BackendTrimInvalidEntry12();
2469 }
2470
2471 // We want to be able to deal with messed up entries on disk.
2472 void DiskCacheBackendTest::BackendInvalidRankings2() {
2473 ASSERT_TRUE(CopyTestCache("bad_rankings"));
2474 DisableFirstCleanup();
2475 InitCache();
2476
2477 disk_cache::Entry *entry1, *entry2;
2478 EXPECT_NE(net::OK, OpenEntry("the first key", &entry1));
2479 ASSERT_EQ(net::OK, OpenEntry("some other key", &entry2));
2480 entry2->Close();
2481
2482 // CheckCacheIntegrity will fail at this point.
2483 DisableIntegrityCheck();
2484 }
2485
2486 TEST_F(DiskCacheBackendTest, InvalidRankings2) {
2487 BackendInvalidRankings2();
2488 }
2489
2490 TEST_F(DiskCacheBackendTest, NewEvictionInvalidRankings2) {
2491 SetNewEviction();
2492 BackendInvalidRankings2();
2493 }
2494
2495 // If the LRU is corrupt, we delete the cache.
2496 void DiskCacheBackendTest::BackendInvalidRankings() {
2497 disk_cache::Entry* entry;
2498 scoped_ptr<TestIterator> iter = CreateIterator();
2499 ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry));
2500 entry->Close();
2501 EXPECT_EQ(2, cache_->GetEntryCount());
2502
2503 EXPECT_NE(net::OK, iter->OpenNextEntry(&entry));
2504 FlushQueueForTest(); // Allow the restart to finish.
2505 EXPECT_EQ(0, cache_->GetEntryCount());
2506 }
2507
2508 TEST_F(DiskCacheBackendTest, InvalidRankingsSuccess) {
2509 ASSERT_TRUE(CopyTestCache("bad_rankings"));
2510 DisableFirstCleanup();
2511 InitCache();
2512 BackendInvalidRankings();
2513 }
2514
2515 TEST_F(DiskCacheBackendTest, NewEvictionInvalidRankingsSuccess) {
2516 ASSERT_TRUE(CopyTestCache("bad_rankings"));
2517 DisableFirstCleanup();
2518 SetNewEviction();
2519 InitCache();
2520 BackendInvalidRankings();
2521 }
2522
2523 TEST_F(DiskCacheBackendTest, InvalidRankingsFailure) {
2524 ASSERT_TRUE(CopyTestCache("bad_rankings"));
2525 DisableFirstCleanup();
2526 InitCache();
2527 SetTestMode(); // Fail cache reinitialization.
2528 BackendInvalidRankings();
2529 }
2530
2531 TEST_F(DiskCacheBackendTest, NewEvictionInvalidRankingsFailure) {
2532 ASSERT_TRUE(CopyTestCache("bad_rankings"));
2533 DisableFirstCleanup();
2534 SetNewEviction();
2535 InitCache();
2536 SetTestMode(); // Fail cache reinitialization.
2537 BackendInvalidRankings();
2538 }
2539
2540 // If the LRU is corrupt and we have open entries, we disable the cache.
2541 void DiskCacheBackendTest::BackendDisable() {
2542 disk_cache::Entry *entry1, *entry2;
2543 scoped_ptr<TestIterator> iter = CreateIterator();
2544 ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry1));
2545
2546 EXPECT_NE(net::OK, iter->OpenNextEntry(&entry2));
2547 EXPECT_EQ(0, cache_->GetEntryCount());
2548 EXPECT_NE(net::OK, CreateEntry("Something new", &entry2));
2549
2550 entry1->Close();
2551 FlushQueueForTest(); // Flushing the Close posts a task to restart the cache.
2552 FlushQueueForTest(); // This one actually allows that task to complete.
2553
2554 EXPECT_EQ(0, cache_->GetEntryCount());
2555 }
2556
2557 TEST_F(DiskCacheBackendTest, DisableSuccess) {
2558 ASSERT_TRUE(CopyTestCache("bad_rankings"));
2559 DisableFirstCleanup();
2560 InitCache();
2561 BackendDisable();
2562 }
2563
2564 TEST_F(DiskCacheBackendTest, NewEvictionDisableSuccess) {
2565 ASSERT_TRUE(CopyTestCache("bad_rankings"));
2566 DisableFirstCleanup();
2567 SetNewEviction();
2568 InitCache();
2569 BackendDisable();
2570 }
2571
2572 TEST_F(DiskCacheBackendTest, DisableFailure) {
2573 ASSERT_TRUE(CopyTestCache("bad_rankings"));
2574 DisableFirstCleanup();
2575 InitCache();
2576 SetTestMode(); // Fail cache reinitialization.
2577 BackendDisable();
2578 }
2579
2580 TEST_F(DiskCacheBackendTest, NewEvictionDisableFailure) {
2581 ASSERT_TRUE(CopyTestCache("bad_rankings"));
2582 DisableFirstCleanup();
2583 SetNewEviction();
2584 InitCache();
2585 SetTestMode(); // Fail cache reinitialization.
2586 BackendDisable();
2587 }
2588
2589 // This is another type of corruption on the LRU; disable the cache.
2590 void DiskCacheBackendTest::BackendDisable2() {
2591 EXPECT_EQ(8, cache_->GetEntryCount());
2592
2593 disk_cache::Entry* entry;
2594 scoped_ptr<TestIterator> iter = CreateIterator();
2595 int count = 0;
2596 while (iter->OpenNextEntry(&entry) == net::OK) {
2597 ASSERT_TRUE(NULL != entry);
2598 entry->Close();
2599 count++;
2600 ASSERT_LT(count, 9);
2601 };
2602
2603 FlushQueueForTest();
2604 EXPECT_EQ(0, cache_->GetEntryCount());
2605 }
2606
2607 TEST_F(DiskCacheBackendTest, DisableSuccess2) {
2608 ASSERT_TRUE(CopyTestCache("list_loop"));
2609 DisableFirstCleanup();
2610 InitCache();
2611 BackendDisable2();
2612 }
2613
2614 TEST_F(DiskCacheBackendTest, NewEvictionDisableSuccess2) {
2615 ASSERT_TRUE(CopyTestCache("list_loop"));
2616 DisableFirstCleanup();
2617 SetNewEviction();
2618 InitCache();
2619 BackendDisable2();
2620 }
2621
2622 TEST_F(DiskCacheBackendTest, DisableFailure2) {
2623 ASSERT_TRUE(CopyTestCache("list_loop"));
2624 DisableFirstCleanup();
2625 InitCache();
2626 SetTestMode(); // Fail cache reinitialization.
2627 BackendDisable2();
2628 }
2629
2630 TEST_F(DiskCacheBackendTest, NewEvictionDisableFailure2) {
2631 ASSERT_TRUE(CopyTestCache("list_loop"));
2632 DisableFirstCleanup();
2633 SetNewEviction();
2634 InitCache();
2635 SetTestMode(); // Fail cache reinitialization.
2636 BackendDisable2();
2637 }
2638
2639 // If the index size changes when we disable the cache, we should not crash.
2640 void DiskCacheBackendTest::BackendDisable3() {
2641 disk_cache::Entry *entry1, *entry2;
2642 scoped_ptr<TestIterator> iter = CreateIterator();
2643 EXPECT_EQ(2, cache_->GetEntryCount());
2644 ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry1));
2645 entry1->Close();
2646
2647 EXPECT_NE(net::OK, iter->OpenNextEntry(&entry2));
2648 FlushQueueForTest();
2649
2650 ASSERT_EQ(net::OK, CreateEntry("Something new", &entry2));
2651 entry2->Close();
2652
2653 EXPECT_EQ(1, cache_->GetEntryCount());
2654 }
2655
2656 TEST_F(DiskCacheBackendTest, DisableSuccess3) {
2657 ASSERT_TRUE(CopyTestCache("bad_rankings2"));
2658 DisableFirstCleanup();
2659 SetMaxSize(20 * 1024 * 1024);
2660 InitCache();
2661 BackendDisable3();
2662 }
2663
2664 TEST_F(DiskCacheBackendTest, NewEvictionDisableSuccess3) {
2665 ASSERT_TRUE(CopyTestCache("bad_rankings2"));
2666 DisableFirstCleanup();
2667 SetMaxSize(20 * 1024 * 1024);
2668 SetNewEviction();
2669 InitCache();
2670 BackendDisable3();
2671 }
2672
2673 // If we disable the cache, already open entries should work as far as possible.
2674 void DiskCacheBackendTest::BackendDisable4() {
2675 disk_cache::Entry *entry1, *entry2, *entry3, *entry4;
2676 scoped_ptr<TestIterator> iter = CreateIterator();
2677 ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry1));
2678
2679 char key2[2000];
2680 char key3[20000];
2681 CacheTestFillBuffer(key2, sizeof(key2), true);
2682 CacheTestFillBuffer(key3, sizeof(key3), true);
2683 key2[sizeof(key2) - 1] = '\0';
2684 key3[sizeof(key3) - 1] = '\0';
2685 ASSERT_EQ(net::OK, CreateEntry(key2, &entry2));
2686 ASSERT_EQ(net::OK, CreateEntry(key3, &entry3));
2687
2688 const int kBufSize = 20000;
2689 scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kBufSize));
2690 memset(buf->data(), 0, kBufSize);
2691 EXPECT_EQ(100, WriteData(entry2, 0, 0, buf.get(), 100, false));
2692 EXPECT_EQ(kBufSize, WriteData(entry3, 0, 0, buf.get(), kBufSize, false));
2693
2694 // This line should disable the cache but not delete it.
2695 EXPECT_NE(net::OK, iter->OpenNextEntry(&entry4));
2696 EXPECT_EQ(0, cache_->GetEntryCount());
2697
2698 EXPECT_NE(net::OK, CreateEntry("cache is disabled", &entry4));
2699
2700 EXPECT_EQ(100, ReadData(entry2, 0, 0, buf.get(), 100));
2701 EXPECT_EQ(100, WriteData(entry2, 0, 0, buf.get(), 100, false));
2702 EXPECT_EQ(100, WriteData(entry2, 1, 0, buf.get(), 100, false));
2703
2704 EXPECT_EQ(kBufSize, ReadData(entry3, 0, 0, buf.get(), kBufSize));
2705 EXPECT_EQ(kBufSize, WriteData(entry3, 0, 0, buf.get(), kBufSize, false));
2706 EXPECT_EQ(kBufSize, WriteData(entry3, 1, 0, buf.get(), kBufSize, false));
2707
2708 std::string key = entry2->GetKey();
2709 EXPECT_EQ(sizeof(key2) - 1, key.size());
2710 key = entry3->GetKey();
2711 EXPECT_EQ(sizeof(key3) - 1, key.size());
2712
2713 entry1->Close();
2714 entry2->Close();
2715 entry3->Close();
2716 FlushQueueForTest(); // Flushing the Close posts a task to restart the cache.
2717 FlushQueueForTest(); // This one actually allows that task to complete.
2718
2719 EXPECT_EQ(0, cache_->GetEntryCount());
2720 }
2721
2722 TEST_F(DiskCacheBackendTest, DisableSuccess4) {
2723 ASSERT_TRUE(CopyTestCache("bad_rankings"));
2724 DisableFirstCleanup();
2725 InitCache();
2726 BackendDisable4();
2727 }
2728
2729 TEST_F(DiskCacheBackendTest, NewEvictionDisableSuccess4) {
2730 ASSERT_TRUE(CopyTestCache("bad_rankings"));
2731 DisableFirstCleanup();
2732 SetNewEviction();
2733 InitCache();
2734 BackendDisable4();
2735 }
2736
2737 TEST_F(DiskCacheTest, Backend_UsageStatsTimer) {
2738 MessageLoopHelper helper;
2739
2740 ASSERT_TRUE(CleanupCacheDir());
2741 scoped_ptr<disk_cache::BackendImpl> cache;
2742 cache.reset(new disk_cache::BackendImpl(
2743 cache_path_, base::ThreadTaskRunnerHandle::Get(), NULL));
2744 ASSERT_TRUE(NULL != cache.get());
2745 cache->SetUnitTestMode();
2746 ASSERT_EQ(net::OK, cache->SyncInit());
2747
2748 // Wait for a callback that never comes... about 2 secs :). The message loop
2749 // has to run to allow invocation of the usage timer.
2750 helper.WaitUntilCacheIoFinished(1);
2751 }
2752
2753 TEST_F(DiskCacheBackendTest, TimerNotCreated) {
2754 ASSERT_TRUE(CopyTestCache("wrong_version"));
2755
2756 scoped_ptr<disk_cache::BackendImpl> cache;
2757 cache.reset(new disk_cache::BackendImpl(
2758 cache_path_, base::ThreadTaskRunnerHandle::Get(), NULL));
2759 ASSERT_TRUE(NULL != cache.get());
2760 cache->SetUnitTestMode();
2761 ASSERT_NE(net::OK, cache->SyncInit());
2762
2763 ASSERT_TRUE(NULL == cache->GetTimerForTest());
2764
2765 DisableIntegrityCheck();
2766 }
2767
2768 TEST_F(DiskCacheBackendTest, Backend_UsageStats) {
2769 InitCache();
2770 disk_cache::Entry* entry;
2771 ASSERT_EQ(net::OK, CreateEntry("key", &entry));
2772 entry->Close();
2773 FlushQueueForTest();
2774
2775 disk_cache::StatsItems stats;
2776 cache_->GetStats(&stats);
2777 EXPECT_FALSE(stats.empty());
2778
2779 disk_cache::StatsItems::value_type hits("Create hit", "0x1");
2780 EXPECT_EQ(1, std::count(stats.begin(), stats.end(), hits));
2781
2782 cache_.reset();
2783
2784 // Now open the cache and verify that the stats are still there.
2785 DisableFirstCleanup();
2786 InitCache();
2787 EXPECT_EQ(1, cache_->GetEntryCount());
2788
2789 stats.clear();
2790 cache_->GetStats(&stats);
2791 EXPECT_FALSE(stats.empty());
2792
2793 EXPECT_EQ(1, std::count(stats.begin(), stats.end(), hits));
2794 }
2795
2796 void DiskCacheBackendTest::BackendDoomAll() {
2797 InitCache();
2798
2799 disk_cache::Entry *entry1, *entry2;
2800 ASSERT_EQ(net::OK, CreateEntry("first", &entry1));
2801 ASSERT_EQ(net::OK, CreateEntry("second", &entry2));
2802 entry1->Close();
2803 entry2->Close();
2804
2805 ASSERT_EQ(net::OK, CreateEntry("third", &entry1));
2806 ASSERT_EQ(net::OK, CreateEntry("fourth", &entry2));
2807
2808 ASSERT_EQ(4, cache_->GetEntryCount());
2809 EXPECT_EQ(net::OK, DoomAllEntries());
2810 ASSERT_EQ(0, cache_->GetEntryCount());
2811
2812 // We should stop posting tasks at some point (if we post any).
2813 base::MessageLoop::current()->RunUntilIdle();
2814
2815 disk_cache::Entry *entry3, *entry4;
2816 EXPECT_NE(net::OK, OpenEntry("third", &entry3));
2817 ASSERT_EQ(net::OK, CreateEntry("third", &entry3));
2818 ASSERT_EQ(net::OK, CreateEntry("fourth", &entry4));
2819
2820 EXPECT_EQ(net::OK, DoomAllEntries());
2821 ASSERT_EQ(0, cache_->GetEntryCount());
2822
2823 entry1->Close();
2824 entry2->Close();
2825 entry3->Doom(); // The entry should be already doomed, but this must work.
2826 entry3->Close();
2827 entry4->Close();
2828
2829 // Now try with all references released.
2830 ASSERT_EQ(net::OK, CreateEntry("third", &entry1));
2831 ASSERT_EQ(net::OK, CreateEntry("fourth", &entry2));
2832 entry1->Close();
2833 entry2->Close();
2834
2835 ASSERT_EQ(2, cache_->GetEntryCount());
2836 EXPECT_EQ(net::OK, DoomAllEntries());
2837 ASSERT_EQ(0, cache_->GetEntryCount());
2838
2839 EXPECT_EQ(net::OK, DoomAllEntries());
2840 }
2841
2842 TEST_F(DiskCacheBackendTest, DoomAll) {
2843 BackendDoomAll();
2844 }
2845
2846 TEST_F(DiskCacheBackendTest, NewEvictionDoomAll) {
2847 SetNewEviction();
2848 BackendDoomAll();
2849 }
2850
2851 TEST_F(DiskCacheBackendTest, MemoryOnlyDoomAll) {
2852 SetMemoryOnlyMode();
2853 BackendDoomAll();
2854 }
2855
2856 TEST_F(DiskCacheBackendTest, AppCacheOnlyDoomAll) {
2857 SetCacheType(net::APP_CACHE);
2858 BackendDoomAll();
2859 }
2860
2861 TEST_F(DiskCacheBackendTest, ShaderCacheOnlyDoomAll) {
2862 SetCacheType(net::SHADER_CACHE);
2863 BackendDoomAll();
2864 }
2865
2866 // If the index size changes when we doom the cache, we should not crash.
2867 void DiskCacheBackendTest::BackendDoomAll2() {
2868 EXPECT_EQ(2, cache_->GetEntryCount());
2869 EXPECT_EQ(net::OK, DoomAllEntries());
2870
2871 disk_cache::Entry* entry;
2872 ASSERT_EQ(net::OK, CreateEntry("Something new", &entry));
2873 entry->Close();
2874
2875 EXPECT_EQ(1, cache_->GetEntryCount());
2876 }
2877
2878 TEST_F(DiskCacheBackendTest, DoomAll2) {
2879 ASSERT_TRUE(CopyTestCache("bad_rankings2"));
2880 DisableFirstCleanup();
2881 SetMaxSize(20 * 1024 * 1024);
2882 InitCache();
2883 BackendDoomAll2();
2884 }
2885
2886 TEST_F(DiskCacheBackendTest, NewEvictionDoomAll2) {
2887 ASSERT_TRUE(CopyTestCache("bad_rankings2"));
2888 DisableFirstCleanup();
2889 SetMaxSize(20 * 1024 * 1024);
2890 SetNewEviction();
2891 InitCache();
2892 BackendDoomAll2();
2893 }
2894
2895 // We should be able to create the same entry on multiple simultaneous instances
2896 // of the cache.
2897 TEST_F(DiskCacheTest, MultipleInstances) {
2898 base::ScopedTempDir store1, store2;
2899 ASSERT_TRUE(store1.CreateUniqueTempDir());
2900 ASSERT_TRUE(store2.CreateUniqueTempDir());
2901
2902 base::Thread cache_thread("CacheThread");
2903 ASSERT_TRUE(cache_thread.StartWithOptions(
2904 base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
2905 net::TestCompletionCallback cb;
2906
2907 const int kNumberOfCaches = 2;
2908 scoped_ptr<disk_cache::Backend> cache[kNumberOfCaches];
2909
2910 int rv = disk_cache::CreateCacheBackend(net::DISK_CACHE,
2911 net::CACHE_BACKEND_DEFAULT,
2912 store1.path(),
2913 0,
2914 false,
2915 cache_thread.task_runner(),
2916 NULL,
2917 &cache[0],
2918 cb.callback());
2919 ASSERT_EQ(net::OK, cb.GetResult(rv));
2920 rv = disk_cache::CreateCacheBackend(net::MEDIA_CACHE,
2921 net::CACHE_BACKEND_DEFAULT,
2922 store2.path(),
2923 0,
2924 false,
2925 cache_thread.task_runner(),
2926 NULL,
2927 &cache[1],
2928 cb.callback());
2929 ASSERT_EQ(net::OK, cb.GetResult(rv));
2930
2931 ASSERT_TRUE(cache[0].get() != NULL && cache[1].get() != NULL);
2932
2933 std::string key("the first key");
2934 disk_cache::Entry* entry;
2935 for (int i = 0; i < kNumberOfCaches; i++) {
2936 rv = cache[i]->CreateEntry(key, &entry, cb.callback());
2937 ASSERT_EQ(net::OK, cb.GetResult(rv));
2938 entry->Close();
2939 }
2940 }
2941
2942 // Test the six regions of the curve that determines the max cache size.
2943 TEST_F(DiskCacheTest, AutomaticMaxSize) {
2944 using disk_cache::kDefaultCacheSize;
2945 int64 large_size = kDefaultCacheSize;
2946
2947 // Region 1: expected = available * 0.8
2948 EXPECT_EQ((kDefaultCacheSize - 1) * 8 / 10,
2949 disk_cache::PreferredCacheSize(large_size - 1));
2950 EXPECT_EQ(kDefaultCacheSize * 8 / 10,
2951 disk_cache::PreferredCacheSize(large_size));
2952 EXPECT_EQ(kDefaultCacheSize - 1,
2953 disk_cache::PreferredCacheSize(large_size * 10 / 8 - 1));
2954
2955 // Region 2: expected = default_size
2956 EXPECT_EQ(kDefaultCacheSize,
2957 disk_cache::PreferredCacheSize(large_size * 10 / 8));
2958 EXPECT_EQ(kDefaultCacheSize,
2959 disk_cache::PreferredCacheSize(large_size * 10 - 1));
2960
2961 // Region 3: expected = available * 0.1
2962 EXPECT_EQ(kDefaultCacheSize,
2963 disk_cache::PreferredCacheSize(large_size * 10));
2964 EXPECT_EQ((kDefaultCacheSize * 25 - 1) / 10,
2965 disk_cache::PreferredCacheSize(large_size * 25 - 1));
2966
2967 // Region 4: expected = default_size * 2.5
2968 EXPECT_EQ(kDefaultCacheSize * 25 / 10,
2969 disk_cache::PreferredCacheSize(large_size * 25));
2970 EXPECT_EQ(kDefaultCacheSize * 25 / 10,
2971 disk_cache::PreferredCacheSize(large_size * 100 - 1));
2972 EXPECT_EQ(kDefaultCacheSize * 25 / 10,
2973 disk_cache::PreferredCacheSize(large_size * 100));
2974 EXPECT_EQ(kDefaultCacheSize * 25 / 10,
2975 disk_cache::PreferredCacheSize(large_size * 250 - 1));
2976
2977 // Region 5: expected = available * 0.1
2978 int64 largest_size = kDefaultCacheSize * 4;
2979 EXPECT_EQ(kDefaultCacheSize * 25 / 10,
2980 disk_cache::PreferredCacheSize(large_size * 250));
2981 EXPECT_EQ(largest_size - 1,
2982 disk_cache::PreferredCacheSize(largest_size * 100 - 1));
2983
2984 // Region 6: expected = largest possible size
2985 EXPECT_EQ(largest_size,
2986 disk_cache::PreferredCacheSize(largest_size * 100));
2987 EXPECT_EQ(largest_size,
2988 disk_cache::PreferredCacheSize(largest_size * 10000));
2989 }
2990
2991 // Tests that we can "migrate" a running instance from one experiment group to
2992 // another.
2993 TEST_F(DiskCacheBackendTest, Histograms) {
2994 InitCache();
2995 disk_cache::BackendImpl* backend_ = cache_impl_; // Needed be the macro.
2996
2997 for (int i = 1; i < 3; i++) {
2998 CACHE_UMA(HOURS, "FillupTime", i, 28);
2999 }
3000 }
3001
3002 // Make sure that we keep the total memory used by the internal buffers under
3003 // control.
3004 TEST_F(DiskCacheBackendTest, TotalBuffersSize1) {
3005 InitCache();
3006 std::string key("the first key");
3007 disk_cache::Entry* entry;
3008 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
3009
3010 const int kSize = 200;
3011 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
3012 CacheTestFillBuffer(buffer->data(), kSize, true);
3013
3014 for (int i = 0; i < 10; i++) {
3015 SCOPED_TRACE(i);
3016 // Allocate 2MB for this entry.
3017 EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, true));
3018 EXPECT_EQ(kSize, WriteData(entry, 1, 0, buffer.get(), kSize, true));
3019 EXPECT_EQ(kSize,
3020 WriteData(entry, 0, 1024 * 1024, buffer.get(), kSize, false));
3021 EXPECT_EQ(kSize,
3022 WriteData(entry, 1, 1024 * 1024, buffer.get(), kSize, false));
3023
3024 // Delete one of the buffers and truncate the other.
3025 EXPECT_EQ(0, WriteData(entry, 0, 0, buffer.get(), 0, true));
3026 EXPECT_EQ(0, WriteData(entry, 1, 10, buffer.get(), 0, true));
3027
3028 // Delete the second buffer, writing 10 bytes to disk.
3029 entry->Close();
3030 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
3031 }
3032
3033 entry->Close();
3034 EXPECT_EQ(0, cache_impl_->GetTotalBuffersSize());
3035 }
3036
3037 // This test assumes at least 150MB of system memory.
3038 TEST_F(DiskCacheBackendTest, TotalBuffersSize2) {
3039 InitCache();
3040
3041 const int kOneMB = 1024 * 1024;
3042 EXPECT_TRUE(cache_impl_->IsAllocAllowed(0, kOneMB));
3043 EXPECT_EQ(kOneMB, cache_impl_->GetTotalBuffersSize());
3044
3045 EXPECT_TRUE(cache_impl_->IsAllocAllowed(0, kOneMB));
3046 EXPECT_EQ(kOneMB * 2, cache_impl_->GetTotalBuffersSize());
3047
3048 EXPECT_TRUE(cache_impl_->IsAllocAllowed(0, kOneMB));
3049 EXPECT_EQ(kOneMB * 3, cache_impl_->GetTotalBuffersSize());
3050
3051 cache_impl_->BufferDeleted(kOneMB);
3052 EXPECT_EQ(kOneMB * 2, cache_impl_->GetTotalBuffersSize());
3053
3054 // Check the upper limit.
3055 EXPECT_FALSE(cache_impl_->IsAllocAllowed(0, 30 * kOneMB));
3056
3057 for (int i = 0; i < 30; i++)
3058 cache_impl_->IsAllocAllowed(0, kOneMB); // Ignore the result.
3059
3060 EXPECT_FALSE(cache_impl_->IsAllocAllowed(0, kOneMB));
3061 }
3062
3063 // Tests that sharing of external files works and we are able to delete the
3064 // files when we need to.
3065 TEST_F(DiskCacheBackendTest, FileSharing) {
3066 InitCache();
3067
3068 disk_cache::Addr address(0x80000001);
3069 ASSERT_TRUE(cache_impl_->CreateExternalFile(&address));
3070 base::FilePath name = cache_impl_->GetFileName(address);
3071
3072 scoped_refptr<disk_cache::File> file(new disk_cache::File(false));
3073 file->Init(name);
3074
3075 #if defined(OS_WIN)
3076 DWORD sharing = FILE_SHARE_READ | FILE_SHARE_WRITE;
3077 DWORD access = GENERIC_READ | GENERIC_WRITE;
3078 base::win::ScopedHandle file2(CreateFile(
3079 name.value().c_str(), access, sharing, NULL, OPEN_EXISTING, 0, NULL));
3080 EXPECT_FALSE(file2.IsValid());
3081
3082 sharing |= FILE_SHARE_DELETE;
3083 file2.Set(CreateFile(name.value().c_str(), access, sharing, NULL,
3084 OPEN_EXISTING, 0, NULL));
3085 EXPECT_TRUE(file2.IsValid());
3086 #endif
3087
3088 EXPECT_TRUE(base::DeleteFile(name, false));
3089
3090 // We should be able to use the file.
3091 const int kSize = 200;
3092 char buffer1[kSize];
3093 char buffer2[kSize];
3094 memset(buffer1, 't', kSize);
3095 memset(buffer2, 0, kSize);
3096 EXPECT_TRUE(file->Write(buffer1, kSize, 0));
3097 EXPECT_TRUE(file->Read(buffer2, kSize, 0));
3098 EXPECT_EQ(0, memcmp(buffer1, buffer2, kSize));
3099
3100 EXPECT_TRUE(disk_cache::DeleteCacheFile(name));
3101 }
3102
3103 TEST_F(DiskCacheBackendTest, UpdateRankForExternalCacheHit) {
3104 InitCache();
3105
3106 disk_cache::Entry* entry;
3107
3108 for (int i = 0; i < 2; ++i) {
3109 std::string key = base::StringPrintf("key%d", i);
3110 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
3111 entry->Close();
3112 }
3113
3114 // Ping the oldest entry.
3115 cache_->OnExternalCacheHit("key0");
3116
3117 TrimForTest(false);
3118
3119 // Make sure the older key remains.
3120 EXPECT_EQ(1, cache_->GetEntryCount());
3121 ASSERT_EQ(net::OK, OpenEntry("key0", &entry));
3122 entry->Close();
3123 }
3124
3125 TEST_F(DiskCacheBackendTest, ShaderCacheUpdateRankForExternalCacheHit) {
3126 SetCacheType(net::SHADER_CACHE);
3127 InitCache();
3128
3129 disk_cache::Entry* entry;
3130
3131 for (int i = 0; i < 2; ++i) {
3132 std::string key = base::StringPrintf("key%d", i);
3133 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
3134 entry->Close();
3135 }
3136
3137 // Ping the oldest entry.
3138 cache_->OnExternalCacheHit("key0");
3139
3140 TrimForTest(false);
3141
3142 // Make sure the older key remains.
3143 EXPECT_EQ(1, cache_->GetEntryCount());
3144 ASSERT_EQ(net::OK, OpenEntry("key0", &entry));
3145 entry->Close();
3146 }
3147
3148 TEST_F(DiskCacheBackendTest, SimpleCacheShutdownWithPendingCreate) {
3149 SetCacheType(net::APP_CACHE);
3150 SetSimpleCacheMode();
3151 BackendShutdownWithPendingCreate(false);
3152 }
3153
3154 TEST_F(DiskCacheBackendTest, SimpleCacheShutdownWithPendingFileIO) {
3155 SetCacheType(net::APP_CACHE);
3156 SetSimpleCacheMode();
3157 BackendShutdownWithPendingFileIO(false);
3158 }
3159
3160 TEST_F(DiskCacheBackendTest, SimpleCacheBasics) {
3161 SetSimpleCacheMode();
3162 BackendBasics();
3163 }
3164
3165 TEST_F(DiskCacheBackendTest, SimpleCacheAppCacheBasics) {
3166 SetCacheType(net::APP_CACHE);
3167 SetSimpleCacheMode();
3168 BackendBasics();
3169 }
3170
3171 TEST_F(DiskCacheBackendTest, SimpleCacheKeying) {
3172 SetSimpleCacheMode();
3173 BackendKeying();
3174 }
3175
3176 TEST_F(DiskCacheBackendTest, SimpleCacheAppCacheKeying) {
3177 SetSimpleCacheMode();
3178 SetCacheType(net::APP_CACHE);
3179 BackendKeying();
3180 }
3181
3182 TEST_F(DiskCacheBackendTest, DISABLED_SimpleCacheSetSize) {
3183 SetSimpleCacheMode();
3184 BackendSetSize();
3185 }
3186
3187 // MacOS has a default open file limit of 256 files, which is incompatible with
3188 // this simple cache test.
3189 #if defined(OS_MACOSX)
3190 #define SIMPLE_MAYBE_MACOS(TestName) DISABLED_ ## TestName
3191 #else
3192 #define SIMPLE_MAYBE_MACOS(TestName) TestName
3193 #endif
3194
3195 TEST_F(DiskCacheBackendTest, SIMPLE_MAYBE_MACOS(SimpleCacheLoad)) {
3196 SetMaxSize(0x100000);
3197 SetSimpleCacheMode();
3198 BackendLoad();
3199 }
3200
3201 TEST_F(DiskCacheBackendTest, SIMPLE_MAYBE_MACOS(SimpleCacheAppCacheLoad)) {
3202 SetCacheType(net::APP_CACHE);
3203 SetSimpleCacheMode();
3204 SetMaxSize(0x100000);
3205 BackendLoad();
3206 }
3207
3208 TEST_F(DiskCacheBackendTest, SimpleDoomRecent) {
3209 SetSimpleCacheMode();
3210 BackendDoomRecent();
3211 }
3212
3213 // crbug.com/330926, crbug.com/370677
3214 TEST_F(DiskCacheBackendTest, DISABLED_SimpleDoomBetween) {
3215 SetSimpleCacheMode();
3216 BackendDoomBetween();
3217 }
3218
3219 TEST_F(DiskCacheBackendTest, SimpleCacheDoomAll) {
3220 SetSimpleCacheMode();
3221 BackendDoomAll();
3222 }
3223
3224 TEST_F(DiskCacheBackendTest, SimpleCacheAppCacheOnlyDoomAll) {
3225 SetCacheType(net::APP_CACHE);
3226 SetSimpleCacheMode();
3227 BackendDoomAll();
3228 }
3229
3230 TEST_F(DiskCacheBackendTest, SimpleCacheOpenMissingFile) {
3231 SetSimpleCacheMode();
3232 InitCache();
3233
3234 const char key[] = "the first key";
3235 disk_cache::Entry* entry = NULL;
3236
3237 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
3238 ASSERT_TRUE(entry != NULL);
3239 entry->Close();
3240 entry = NULL;
3241
3242 // To make sure the file creation completed we need to call open again so that
3243 // we block until it actually created the files.
3244 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
3245 ASSERT_TRUE(entry != NULL);
3246 entry->Close();
3247 entry = NULL;
3248
3249 // Delete one of the files in the entry.
3250 base::FilePath to_delete_file = cache_path_.AppendASCII(
3251 disk_cache::simple_util::GetFilenameFromKeyAndFileIndex(key, 0));
3252 EXPECT_TRUE(base::PathExists(to_delete_file));
3253 EXPECT_TRUE(disk_cache::DeleteCacheFile(to_delete_file));
3254
3255 // Failing to open the entry should delete the rest of these files.
3256 ASSERT_EQ(net::ERR_FAILED, OpenEntry(key, &entry));
3257
3258 // Confirm the rest of the files are gone.
3259 for (int i = 1; i < disk_cache::kSimpleEntryFileCount; ++i) {
3260 base::FilePath should_be_gone_file(cache_path_.AppendASCII(
3261 disk_cache::simple_util::GetFilenameFromKeyAndFileIndex(key, i)));
3262 EXPECT_FALSE(base::PathExists(should_be_gone_file));
3263 }
3264 }
3265
3266 TEST_F(DiskCacheBackendTest, SimpleCacheOpenBadFile) {
3267 SetSimpleCacheMode();
3268 InitCache();
3269
3270 const char key[] = "the first key";
3271 disk_cache::Entry* entry = NULL;
3272
3273 ASSERT_EQ(net::OK, CreateEntry(key, &entry));
3274 disk_cache::Entry* null = NULL;
3275 ASSERT_NE(null, entry);
3276 entry->Close();
3277 entry = NULL;
3278
3279 // To make sure the file creation completed we need to call open again so that
3280 // we block until it actually created the files.
3281 ASSERT_EQ(net::OK, OpenEntry(key, &entry));
3282 ASSERT_NE(null, entry);
3283 entry->Close();
3284 entry = NULL;
3285
3286 // The entry is being closed on the Simple Cache worker pool
3287 disk_cache::SimpleBackendImpl::FlushWorkerPoolForTesting();
3288 base::RunLoop().RunUntilIdle();
3289
3290 // Write an invalid header for stream 0 and stream 1.
3291 base::FilePath entry_file1_path = cache_path_.AppendASCII(
3292 disk_cache::simple_util::GetFilenameFromKeyAndFileIndex(key, 0));
3293
3294 disk_cache::SimpleFileHeader header;
3295 header.initial_magic_number = GG_UINT64_C(0xbadf00d);
3296 EXPECT_EQ(
3297 implicit_cast<int>(sizeof(header)),
3298 base::WriteFile(entry_file1_path, reinterpret_cast<char*>(&header),
3299 sizeof(header)));
3300 ASSERT_EQ(net::ERR_FAILED, OpenEntry(key, &entry));
3301 }
3302
3303 // Tests that the Simple Cache Backend fails to initialize with non-matching
3304 // file structure on disk.
3305 TEST_F(DiskCacheBackendTest, SimpleCacheOverBlockfileCache) {
3306 // Create a cache structure with the |BackendImpl|.
3307 InitCache();
3308 disk_cache::Entry* entry;
3309 const int kSize = 50;
3310 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
3311 CacheTestFillBuffer(buffer->data(), kSize, false);
3312 ASSERT_EQ(net::OK, CreateEntry("key", &entry));
3313 ASSERT_EQ(0, WriteData(entry, 0, 0, buffer.get(), 0, false));
3314 entry->Close();
3315 cache_.reset();
3316
3317 // Check that the |SimpleBackendImpl| does not favor this structure.
3318 base::Thread cache_thread("CacheThread");
3319 ASSERT_TRUE(cache_thread.StartWithOptions(
3320 base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
3321 disk_cache::SimpleBackendImpl* simple_cache =
3322 new disk_cache::SimpleBackendImpl(
3323 cache_path_, 0, net::DISK_CACHE, cache_thread.task_runner(), NULL);
3324 net::TestCompletionCallback cb;
3325 int rv = simple_cache->Init(cb.callback());
3326 EXPECT_NE(net::OK, cb.GetResult(rv));
3327 delete simple_cache;
3328 DisableIntegrityCheck();
3329 }
3330
3331 // Tests that the |BackendImpl| refuses to initialize on top of the files
3332 // generated by the Simple Cache Backend.
3333 TEST_F(DiskCacheBackendTest, BlockfileCacheOverSimpleCache) {
3334 // Create a cache structure with the |SimpleBackendImpl|.
3335 SetSimpleCacheMode();
3336 InitCache();
3337 disk_cache::Entry* entry;
3338 const int kSize = 50;
3339 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
3340 CacheTestFillBuffer(buffer->data(), kSize, false);
3341 ASSERT_EQ(net::OK, CreateEntry("key", &entry));
3342 ASSERT_EQ(0, WriteData(entry, 0, 0, buffer.get(), 0, false));
3343 entry->Close();
3344 cache_.reset();
3345
3346 // Check that the |BackendImpl| does not favor this structure.
3347 base::Thread cache_thread("CacheThread");
3348 ASSERT_TRUE(cache_thread.StartWithOptions(
3349 base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
3350 disk_cache::BackendImpl* cache = new disk_cache::BackendImpl(
3351 cache_path_, base::ThreadTaskRunnerHandle::Get(), NULL);
3352 cache->SetUnitTestMode();
3353 net::TestCompletionCallback cb;
3354 int rv = cache->Init(cb.callback());
3355 EXPECT_NE(net::OK, cb.GetResult(rv));
3356 delete cache;
3357 DisableIntegrityCheck();
3358 }
3359
3360 TEST_F(DiskCacheBackendTest, SimpleCacheFixEnumerators) {
3361 SetSimpleCacheMode();
3362 BackendFixEnumerators();
3363 }
3364
3365 // Tests basic functionality of the SimpleBackend implementation of the
3366 // enumeration API.
3367 TEST_F(DiskCacheBackendTest, SimpleCacheEnumerationBasics) {
3368 SetSimpleCacheMode();
3369 InitCache();
3370 std::set<std::string> key_pool;
3371 ASSERT_TRUE(CreateSetOfRandomEntries(&key_pool));
3372
3373 // Check that enumeration returns all entries.
3374 std::set<std::string> keys_to_match(key_pool);
3375 scoped_ptr<TestIterator> iter = CreateIterator();
3376 size_t count = 0;
3377 ASSERT_TRUE(EnumerateAndMatchKeys(-1, iter.get(), &keys_to_match, &count));
3378 iter.reset();
3379 EXPECT_EQ(key_pool.size(), count);
3380 EXPECT_TRUE(keys_to_match.empty());
3381
3382 // Check that opening entries does not affect enumeration.
3383 keys_to_match = key_pool;
3384 iter = CreateIterator();
3385 count = 0;
3386 disk_cache::Entry* entry_opened_before;
3387 ASSERT_EQ(net::OK, OpenEntry(*(key_pool.begin()), &entry_opened_before));
3388 ASSERT_TRUE(EnumerateAndMatchKeys(key_pool.size()/2,
3389 iter.get(),
3390 &keys_to_match,
3391 &count));
3392
3393 disk_cache::Entry* entry_opened_middle;
3394 ASSERT_EQ(net::OK,
3395 OpenEntry(*(keys_to_match.begin()), &entry_opened_middle));
3396 ASSERT_TRUE(EnumerateAndMatchKeys(-1, iter.get(), &keys_to_match, &count));
3397 iter.reset();
3398 entry_opened_before->Close();
3399 entry_opened_middle->Close();
3400
3401 EXPECT_EQ(key_pool.size(), count);
3402 EXPECT_TRUE(keys_to_match.empty());
3403 }
3404
3405 // Tests that the enumerations are not affected by dooming an entry in the
3406 // middle.
3407 TEST_F(DiskCacheBackendTest, SimpleCacheEnumerationWhileDoomed) {
3408 SetSimpleCacheMode();
3409 InitCache();
3410 std::set<std::string> key_pool;
3411 ASSERT_TRUE(CreateSetOfRandomEntries(&key_pool));
3412
3413 // Check that enumeration returns all entries but the doomed one.
3414 std::set<std::string> keys_to_match(key_pool);
3415 scoped_ptr<TestIterator> iter = CreateIterator();
3416 size_t count = 0;
3417 ASSERT_TRUE(EnumerateAndMatchKeys(key_pool.size()/2,
3418 iter.get(),
3419 &keys_to_match,
3420 &count));
3421
3422 std::string key_to_delete = *(keys_to_match.begin());
3423 DoomEntry(key_to_delete);
3424 keys_to_match.erase(key_to_delete);
3425 key_pool.erase(key_to_delete);
3426 ASSERT_TRUE(EnumerateAndMatchKeys(-1, iter.get(), &keys_to_match, &count));
3427 iter.reset();
3428
3429 EXPECT_EQ(key_pool.size(), count);
3430 EXPECT_TRUE(keys_to_match.empty());
3431 }
3432
3433 // Tests that enumerations are not affected by corrupt files.
3434 TEST_F(DiskCacheBackendTest, SimpleCacheEnumerationCorruption) {
3435 SetSimpleCacheMode();
3436 InitCache();
3437 std::set<std::string> key_pool;
3438 ASSERT_TRUE(CreateSetOfRandomEntries(&key_pool));
3439
3440 // Create a corrupt entry. The write/read sequence ensures that the entry will
3441 // have been created before corrupting the platform files, in the case of
3442 // optimistic operations.
3443 const std::string key = "the key";
3444 disk_cache::Entry* corrupted_entry;
3445
3446 ASSERT_EQ(net::OK, CreateEntry(key, &corrupted_entry));
3447 ASSERT_TRUE(corrupted_entry);
3448 const int kSize = 50;
3449 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
3450 CacheTestFillBuffer(buffer->data(), kSize, false);
3451 ASSERT_EQ(kSize,
3452 WriteData(corrupted_entry, 0, 0, buffer.get(), kSize, false));
3453 ASSERT_EQ(kSize, ReadData(corrupted_entry, 0, 0, buffer.get(), kSize));
3454 corrupted_entry->Close();
3455
3456 EXPECT_TRUE(disk_cache::simple_util::CreateCorruptFileForTests(
3457 key, cache_path_));
3458 EXPECT_EQ(key_pool.size() + 1,
3459 implicit_cast<size_t>(cache_->GetEntryCount()));
3460
3461 // Check that enumeration returns all entries but the corrupt one.
3462 std::set<std::string> keys_to_match(key_pool);
3463 scoped_ptr<TestIterator> iter = CreateIterator();
3464 size_t count = 0;
3465 ASSERT_TRUE(EnumerateAndMatchKeys(-1, iter.get(), &keys_to_match, &count));
3466 iter.reset();
3467
3468 EXPECT_EQ(key_pool.size(), count);
3469 EXPECT_TRUE(keys_to_match.empty());
3470 }
3471
3472 // Tests that enumerations don't leak memory when the backend is destructed
3473 // mid-enumeration.
3474 TEST_F(DiskCacheBackendTest, SimpleCacheEnumerationDestruction) {
3475 SetSimpleCacheMode();
3476 InitCache();
3477 std::set<std::string> key_pool;
3478 ASSERT_TRUE(CreateSetOfRandomEntries(&key_pool));
3479
3480 scoped_ptr<TestIterator> iter = CreateIterator();
3481 disk_cache::Entry* entry = NULL;
3482 ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry));
3483 EXPECT_TRUE(entry);
3484 disk_cache::ScopedEntryPtr entry_closer(entry);
3485
3486 cache_.reset();
3487 // This test passes if we don't leak memory.
3488 }
3489
3490 // Tests that a SimpleCache doesn't crash when files are deleted very quickly
3491 // after closing.
3492 // NOTE: IF THIS TEST IS FLAKY THEN IT IS FAILING. See https://crbug.com/416940
3493 TEST_F(DiskCacheBackendTest, SimpleCacheDeleteQuickly) {
3494 SetSimpleCacheMode();
3495 for (int i = 0; i < 100; ++i) {
3496 InitCache();
3497 cache_.reset();
3498 EXPECT_TRUE(CleanupCacheDir());
3499 }
3500 }
OLDNEW
« no previous file with comments | « net/data/websocket/websocket_worker_simple.js ('k') | net/disk_cache/blockfile/addr.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698