Add LPM disk cache fuzzer

Adding an LPM-based disk cache fuzzer so we can more comprehensively
test disk cache implementations, including any new ones that might
come around.

Bug: 939131
Change-Id: Iede24aff96776c99d53d74a07f8b8324a0e58979
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1507113
Commit-Queue: Matthew Denton <mpdenton@chromium.org>
Reviewed-by: Maks Orlovich <morlovich@chromium.org>
Cr-Commit-Position: refs/heads/master@{#644610}

net/BUILD.gn

@@ -5931,6 +5931,25 @@ source_set("net_fuzzer_test_support") {
   allow_circular_includes_from = [ "//net/dns:fuzzer_test_support" ]
 }
 
+proto_library("disk_cache_lpm_fuzzer_proto") {
+  sources = [
+    "disk_cache/disk_cache_fuzzer.proto",
+  ]
+}
+
+fuzzer_test("disk_cache_lpm_fuzzer") {
+  sources = [
+    "disk_cache/disk_cache_fuzzer.cc",
+  ]
+  deps = [
+    ":disk_cache_lpm_fuzzer_proto",
+    ":test_support",
+    "//base",
+    "//net",
+    "//third_party/libprotobuf-mutator",
+  ]
+}
+
 fuzzer_test("net_data_job_fuzzer") {
   sources = [
     "url_request/url_request_data_job_fuzzer.cc",

net/disk_cache/backend_unittest.cc

@@ -3375,7 +3375,7 @@ void DiskCacheBackendTest::BackendDisabledAPI() {
   base::StringPairs stats;
   cache_->GetStats(&stats);
   EXPECT_TRUE(stats.empty());
-  cache_->OnExternalCacheHit("First");
+  OnExternalCacheHit("First");
 }
 
 TEST_F(DiskCacheBackendTest, DisabledAPI) {
@@ -3886,7 +3886,7 @@ TEST_F(DiskCacheBackendTest, UpdateRankForExternalCacheHit) {
   }
 
   // Ping the oldest entry.
-  cache_->OnExternalCacheHit("key0");
+  OnExternalCacheHit("key0");
 
   TrimForTest(false);
 
@@ -3909,7 +3909,7 @@ TEST_F(DiskCacheBackendTest, ShaderCacheUpdateRankForExternalCacheHit) {
   }
 
   // Ping the oldest entry.
-  cache_->OnExternalCacheHit("key0");
+  OnExternalCacheHit("key0");
 
   TrimForTest(false);
 

net/disk_cache/disk_cache_fuzzer.proto

+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+syntax = "proto2";
+
+package disk_cache_fuzzer;
+
+enum RequestPriority {
+  THROTTLED = 0;
+  IDLE = 1;
+  LOWEST = 2;
+  LOW = 3;
+  MEDIUM = 4;
+  HIGHEST = 5;
+}
+
+message FuzzCommands {
+  enum CacheBackend {
+    SIMPLE = 0;
+    IN_MEMORY = 1;
+    BLOCK = 2;
+  }
+  required CacheBackend cache_backend = 5;
+
+  enum CacheType {
+    APP_CACHE = 1;
+    MEDIA_CACHE = 2;
+    SHADER_CACHE = 3;
+    PNACL_CACHE = 4;
+    GENERATED_CODE_CACHE = 5;
+    DISK_CACHE = 6;
+  }
+  required CacheType cache_type = 4;
+
+  optional bool set_mask = 2;
+  optional SetMaxSize set_max_size = 3;
+  repeated FuzzCommand fuzz_commands = 1;
+  required bool simple_cache_wait_for_index = 6;
+}
+
+message FuzzCommand {
+  oneof fuzz_command_oneof {
+    SetMaxSize set_max_size = 87;
+    CreateEntry create_entry = 1;
+    OpenEntry open_entry = 2;
+    OpenOrCreateEntry open_or_create_entry = 345;
+    CloseEntry close_entry = 3;
+    DoomEntry doom_entry = 4;
+    WriteData write_data = 5;
+    WriteSparseData write_sparse_data = 6;
+    DoomAllEntries doom_all_entries = 7;
+    FlushQueueForTest flush_queue_for_test = 8;
+    CreateIterator create_iterator = 10;
+    IteratorOpenNextEntry iterator_open_next_entry = 63;
+    FastForwardBy fast_forward_by = 11;
+
+    ReadData read_data = 12;
+    ReadSparseData read_sparse_data = 456;
+
+    DoomEntriesSince doom_entries_since = 13;
+    DoomEntriesBetween doom_entries_between = 14;
+
+    OnExternalCacheHit on_external_cache_hit = 16;
+
+    TrimForTest trim_for_test = 17;
+    TrimDeletedListForTest trim_deleted_list_for_test = 18;
+    GetAvailableRange get_available_range = 19;
+    CancelSparseIO cancel_sparse_io = 20;
+    DoomKey doom_key = 21;
+    DestructBackend destruct_backend = 22;
+
+    AddRealDelay add_real_delay = 23;
+
+    // Not included: GetStats, CalculateSizesOf, GetEntryInMemoryData,
+    // SetEntryInMemoryData, CouldBeSparse, ReadyForSparseIO
+
+    // TODO(mpdenton) enable kPrioritizedSimpleCacheTasks?
+    // TODO(mpdenton) FlushWorkerPoolForTesting
+  }
+}
+
+message SetMaxSize {
+  required uint32 size = 1;
+}
+
+message CreateEntry {
+  required uint64 key_id = 1;
+  required uint64 entry_id = 2;
+  required RequestPriority pri = 3;
+  required bool async = 4;
+  required bool is_sparse = 5;
+}
+
+message OpenEntry {
+  required uint64 key_id = 1;
+  required uint64 entry_id = 2;
+  required RequestPriority pri = 3;
+  required bool async = 4;
+}
+
+message OpenOrCreateEntry {
+  required uint64 key_id = 1;
+  required uint64 entry_id = 2;
+  required bool create_new = 3;
+  required RequestPriority pri = 4;
+  required bool async = 5;
+  required bool is_sparse = 6;
+}
+
+message CloseEntry {
+  required uint64 entry_id = 1;
+}
+
+message DoomEntry {
+  required uint64 entry_id = 1;
+}
+
+message WriteData {
+  required uint64 entry_id = 1;
+  required uint32 size = 2;
+  required uint32 index = 3;
+  required uint32 offset = 4;
+  required bool truncate = 5;
+  required bool async = 6;
+}
+
+message WriteSparseData {
+  required uint64 entry_id = 1;
+  required uint32 size = 2;
+  required uint64 offset = 4;
+  required bool async = 5;
+  required bool cap_offset = 6;
+}
+
+message ReadSparseData {
+  required uint64 entry_id = 1;
+  required uint32 size = 2;
+  required uint64 offset = 4;
+  required bool async = 5;
+  required bool cap_offset = 6;
+}
+
+message ReadData {
+  required uint64 entry_id = 1;
+  required uint32 size = 2;
+  required uint32 index = 3;
+  required uint32 offset = 4;
+  required bool async = 5;
+}
+
+message DoomAllEntries {
+  required bool async = 1;
+}
+
+message FlushQueueForTest {}
+
+message CreateIterator {
+  required uint64 it_id = 1;
+}
+
+message IteratorOpenNextEntry {
+  required uint64 it_id = 1;
+  required uint64 entry_id = 2;
+  required bool async = 3;
+}
+
+message FastForwardBy {
+  required uint32 capped_num_millis = 1;
+  required uint64 time_id = 2;
+}
+
+message DoomEntriesBetween {
+  required uint64 time_id1 = 1;
+  required uint64 time_id2 = 2;
+  required bool async = 3;
+}
+
+message DoomEntriesSince {
+  required uint64 time_id = 1;
+  required bool async = 2;
+}
+
+message OnExternalCacheHit {
+  required uint64 key_id = 1;
+}
+
+message TrimForTest {
+  required bool empty = 1;
+}
+
+message TrimDeletedListForTest {
+  required bool empty = 1;
+}
+
+message GetAvailableRange {
+  required uint64 entry_id = 1;
+  required uint32 offset = 2;
+  required uint32 len = 3;
+  required bool async = 4;
+}
+
+message CancelSparseIO {
+  required uint64 entry_id = 1;
+}
+
+message DoomKey {
+  required uint64 key_id = 1;
+  required RequestPriority pri = 2;
+  required bool async = 3;
+}
+
+message DestructBackend {
+  // I want this to be uncommon, so if either of these booleans are false, we
+  // won't actually destruct the backend.
+  required bool actually_destruct1 = 1;
+  required bool actually_destruct2 = 2;
+}
+
+message AddRealDelay {
+  required bool actually_delay = 1;
+}

net/disk_cache/disk_cache_test_base.cc

@@ -243,15 +243,21 @@ void DiskCacheTestWithCache::RunTaskForTest(const base::Closure& closure) {
   EXPECT_THAT(cb.GetResult(rv), IsOk());
 }
 
-int DiskCacheTestWithCache::ReadData(disk_cache::Entry* entry, int index,
-                                     int offset, net::IOBuffer* buf, int len) {
+int DiskCacheTestWithCache::ReadData(disk_cache::Entry* entry,
+                                     int index,
+                                     int offset,
+                                     net::IOBuffer* buf,
+                                     int len) {
   net::TestCompletionCallback cb;
   int rv = entry->ReadData(index, offset, buf, len, cb.callback());
   return cb.GetResult(rv);
 }
 
-int DiskCacheTestWithCache::WriteData(disk_cache::Entry* entry, int index,
-                                      int offset, net::IOBuffer* buf, int len,
+int DiskCacheTestWithCache::WriteData(disk_cache::Entry* entry,
+                                      int index,
+                                      int offset,
+                                      net::IOBuffer* buf,
+                                      int len,
                                       bool truncate) {
   net::TestCompletionCallback cb;
   int rv = entry->WriteData(index, offset, buf, len, cb.callback(), truncate);
@@ -276,16 +282,29 @@ int DiskCacheTestWithCache::WriteSparseData(disk_cache::Entry* entry,
   return cb.GetResult(rv);
 }
 
+int DiskCacheTestWithCache::GetAvailableRange(disk_cache::Entry* entry,
+                                              int64_t offset,
+                                              int len,
+                                              int64_t* start) {
+  net::TestCompletionCallback cb;
+  int rv = entry->GetAvailableRange(offset, len, start, cb.callback());
+  return cb.GetResult(rv);
+}
+
 void DiskCacheTestWithCache::TrimForTest(bool empty) {
+  if (memory_only_ || !cache_impl_)
+    return;
+
   RunTaskForTest(base::Bind(&disk_cache::BackendImpl::TrimForTest,
-                            base::Unretained(cache_impl_),
-                            empty));
+                            base::Unretained(cache_impl_), empty));
 }
 
 void DiskCacheTestWithCache::TrimDeletedListForTest(bool empty) {
+  if (memory_only_ || !cache_impl_)
+    return;
+
   RunTaskForTest(base::Bind(&disk_cache::BackendImpl::TrimDeletedListForTest,
-                            base::Unretained(cache_impl_),
-                            empty));
+                            base::Unretained(cache_impl_), empty));
 }
 
 void DiskCacheTestWithCache::AddDelay() {
@@ -296,8 +315,8 @@ void DiskCacheTestWithCache::AddDelay() {
     const base::Time initial_time = base::Time::Now();
     do {
       base::PlatformThread::YieldCurrentThread();
-    } while (base::Time::Now() -
-             initial_time < base::TimeDelta::FromSeconds(1));
+    } while (base::Time::Now() - initial_time <
+             base::TimeDelta::FromSeconds(1));
   }
 
   base::Time initial = base::Time::Now();
@@ -306,6 +325,10 @@ void DiskCacheTestWithCache::AddDelay() {
   };
 }
 
+void DiskCacheTestWithCache::OnExternalCacheHit(const std::string& key) {
+  cache_->OnExternalCacheHit(key);
+}
+
 void DiskCacheTestWithCache::TearDown() {
   RunUntilIdle();
   cache_.reset();

net/disk_cache/disk_cache_test_base.h

@@ -168,6 +168,10 @@ class DiskCacheTestWithCache : public DiskCacheTest {
                       int64_t offset,
                       net::IOBuffer* buf,
                       int len);
+  int GetAvailableRange(disk_cache::Entry* entry,
+                        int64_t offset,
+                        int len,
+                        int64_t* start);
 
   // Asks the cache to trim an entry. If |empty| is true, the whole cache is
   // deleted.
@@ -181,6 +185,8 @@ class DiskCacheTestWithCache : public DiskCacheTest {
   // before and after this method will not be the same.
   void AddDelay();
 
+  void OnExternalCacheHit(const std::string& key);
+
   void TearDown() override;
 
   // cache_ will always have a valid object, regardless of how the cache was