Start work on splitting off the usage piece of in-memory index. This revision is just from the prev…

net/http/http_cache_unittest.cc

 // Copyright (c) 2012 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.
 
 #include "net/http/http_cache.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 1045 matching lines @@
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
   TestLoadTimingNetworkRequest(load_timing_info);
   RemoveMockTransaction(&transaction);
 }
 
 // Tests that was_cached was set properly on a failure, even if the cached
 // response wasn't returned.
 TEST(HttpCache, SimpleGET_CacheSignal_Failure) {
-  MockHttpCache cache;
+  for (bool use_memory_entry_data : {false, true}) {
+    MockHttpCache cache;
+    cache.disk_cache()->set_support_in_memory_entry_data(use_memory_entry_data);
 
-  // Prime cache.
-  MockTransaction transaction(kSimpleGET_Transaction);
-  transaction.response_headers = "Cache-Control: no-cache\n";
+    // Prime cache.
+    MockTransaction transaction(kSimpleGET_Transaction);
+    transaction.response_headers = "Cache-Control: no-cache\n";
 
-  AddMockTransaction(&transaction);
-  RunTransactionTest(cache.http_cache(), transaction);
-  EXPECT_EQ(1, cache.network_layer()->transaction_count());
-  EXPECT_EQ(1, cache.disk_cache()->create_count());
-  RemoveMockTransaction(&transaction);
+    AddMockTransaction(&transaction);
+    RunTransactionTest(cache.http_cache(), transaction);
+    EXPECT_EQ(1, cache.network_layer()->transaction_count());
+    EXPECT_EQ(1, cache.disk_cache()->create_count());
+    RemoveMockTransaction(&transaction);
 
-  // Network failure with error; should fail but have was_cached set.
-  transaction.start_return_code = ERR_FAILED;
-  AddMockTransaction(&transaction);
+    // Network failure with error; should fail but have was_cached set.
+    transaction.start_return_code = ERR_FAILED;
+    AddMockTransaction(&transaction);
 
-  MockHttpRequest request(transaction);
-  TestCompletionCallback callback;
-  std::unique_ptr<HttpTransaction> trans;
-  int rv = cache.http_cache()->CreateTransaction(DEFAULT_PRIORITY, &trans);
-  EXPECT_THAT(rv, IsOk());
-  ASSERT_TRUE(trans.get());
-  rv = trans->Start(&request, callback.callback(), NetLogWithSource());
-  EXPECT_THAT(callback.GetResult(rv), IsError(ERR_FAILED));
+    MockHttpRequest request(transaction);
+    TestCompletionCallback callback;
+    std::unique_ptr<HttpTransaction> trans;
+    int rv = cache.http_cache()->CreateTransaction(DEFAULT_PRIORITY, &trans);
+    EXPECT_THAT(rv, IsOk());
+    ASSERT_TRUE(trans.get());
+    rv = trans->Start(&request, callback.callback(), NetLogWithSource());
+    EXPECT_THAT(callback.GetResult(rv), IsError(ERR_FAILED));
 
-  const HttpResponseInfo* response_info = trans->GetResponseInfo();
-  ASSERT_TRUE(response_info);
-  EXPECT_TRUE(response_info->was_cached);
-  EXPECT_EQ(2, cache.network_layer()->transaction_count());
+    const HttpResponseInfo* response_info = trans->GetResponseInfo();
+    ASSERT_TRUE(response_info);
+    // If use_memory_entry_data is true, we will not bother opening the entry,
+    // and just kick it out, so was_cached will end up false.
+    EXPECT_EQ(!use_memory_entry_data, response_info->was_cached);
+    EXPECT_EQ(2, cache.network_layer()->transaction_count());
 
-  RemoveMockTransaction(&transaction);
+    RemoveMockTransaction(&transaction);
+  }
 }
 
 // Confirm if we have an empty cache, a read is marked as network verified.
 TEST(HttpCache, SimpleGET_NetworkAccessed_Network) {
   MockHttpCache cache;
 
   // write to the cache
   HttpResponseInfo response_info;
   RunTransactionTestWithResponseInfo(cache.http_cache(), kSimpleGET_Transaction,
                                      &response_info);
@@ skipping 202 matching lines @@
 
 static void PreserveRequestHeaders_Handler(const HttpRequestInfo* request,
                                            std::string* response_status,
                                            std::string* response_headers,
                                            std::string* response_data) {
   EXPECT_TRUE(request->extra_headers.HasHeader(kExtraHeaderKey));
 }
 
 // Tests that we don't remove extra headers for simple requests.
 TEST(HttpCache, SimpleGET_PreserveRequestHeaders) {
-  MockHttpCache cache;
+  for (bool use_memory_entry_data : {false, true}) {
+    MockHttpCache cache;
+    cache.disk_cache()->set_support_in_memory_entry_data(use_memory_entry_data);
 
-  MockTransaction transaction(kSimpleGET_Transaction);
-  transaction.handler = PreserveRequestHeaders_Handler;
-  transaction.request_headers = EXTRA_HEADER;
-  transaction.response_headers = "Cache-Control: max-age=0\n";
-  AddMockTransaction(&transaction);
+    MockTransaction transaction(kSimpleGET_Transaction);
+    transaction.handler = PreserveRequestHeaders_Handler;
+    transaction.request_headers = EXTRA_HEADER;
+    transaction.response_headers = "Cache-Control: max-age=0\n";
+    AddMockTransaction(&transaction);
 
-  // Write, then revalidate the entry.
-  RunTransactionTest(cache.http_cache(), transaction);
-  RunTransactionTest(cache.http_cache(), transaction);
+    // Write, then revalidate the entry.
+    RunTransactionTest(cache.http_cache(), transaction);
+    RunTransactionTest(cache.http_cache(), transaction);
 
-  EXPECT_EQ(2, cache.network_layer()->transaction_count());
-  EXPECT_EQ(1, cache.disk_cache()->open_count());
-  EXPECT_EQ(1, cache.disk_cache()->create_count());
-  RemoveMockTransaction(&transaction);
+    EXPECT_EQ(2, cache.network_layer()->transaction_count());
+
+    // If the backend supports memory entry data, we can figure out that the
+    // entry has caching-hostile headers w/o opening it.
+    if (use_memory_entry_data) {
+      EXPECT_EQ(0, cache.disk_cache()->open_count());
+      EXPECT_EQ(2, cache.disk_cache()->create_count());
+    } else {
+      EXPECT_EQ(1, cache.disk_cache()->open_count());
+      EXPECT_EQ(1, cache.disk_cache()->create_count());
+    }
+    RemoveMockTransaction(&transaction);
+  }
 }
 
 // Tests that we don't remove extra headers for conditionalized requests.
 TEST(HttpCache, ConditionalizedGET_PreserveRequestHeaders) {
-  MockHttpCache cache;
+  for (bool use_memory_entry_data : {false, true}) {
+    MockHttpCache cache;
+    // Unlike in SimpleGET_PreserveRequestHeaders, this entry can be
+    // conditionalized, so memory hints don't affect behavior.
+    cache.disk_cache()->set_support_in_memory_entry_data(use_memory_entry_data);
 
-  // Write to the cache.
-  RunTransactionTest(cache.http_cache(), kETagGET_Transaction);
+    // Write to the cache.
+    RunTransactionTest(cache.http_cache(), kETagGET_Transaction);
 
-  MockTransaction transaction(kETagGET_Transaction);
-  transaction.handler = PreserveRequestHeaders_Handler;
-  transaction.request_headers = "If-None-Match: \"foopy\"\r\n" EXTRA_HEADER;
-  AddMockTransaction(&transaction);
+    MockTransaction transaction(kETagGET_Transaction);
+    transaction.handler = PreserveRequestHeaders_Handler;
+    transaction.request_headers = "If-None-Match: \"foopy\"\r\n" EXTRA_HEADER;
+    AddMockTransaction(&transaction);
 
-  RunTransactionTest(cache.http_cache(), transaction);
+    RunTransactionTest(cache.http_cache(), transaction);
 
-  EXPECT_EQ(2, cache.network_layer()->transaction_count());
-  EXPECT_EQ(1, cache.disk_cache()->open_count());
-  EXPECT_EQ(1, cache.disk_cache()->create_count());
-  RemoveMockTransaction(&transaction);
+    EXPECT_EQ(2, cache.network_layer()->transaction_count());
+    EXPECT_EQ(1, cache.disk_cache()->open_count());
+    EXPECT_EQ(1, cache.disk_cache()->create_count());
+    RemoveMockTransaction(&transaction);
+  }
 }
 
 TEST(HttpCache, SimpleGET_ManyReaders) {
   MockHttpCache cache;
 
   MockHttpRequest request(kSimpleGET_Transaction);
 
   std::vector<std::unique_ptr<Context>> context_list;
   const int kNumTransactions = 5;
 
@@ skipping 4010 matching lines @@
   RunTransactionTestWithLog(cache.http_cache(), kRangeGET_TransactionOK,
                             log.bound());
 
   EXPECT_TRUE(LogContainsEventType(
       log, NetLogEventType::HTTP_CACHE_RESTART_PARTIAL_REQUEST));
 }
 
 // Tests that a failure to conditionalize a regular request (no range) with a
 // sparse entry results in a full response.
 TEST(HttpCache, GET_NoConditionalization) {
-  MockHttpCache cache;
-  cache.FailConditionalizations();
-  std::string headers;
+  for (bool use_memory_entry_data : {false, true}) {
+    MockHttpCache cache;
+    cache.disk_cache()->set_support_in_memory_entry_data(use_memory_entry_data);
+    cache.FailConditionalizations();
+    std::string headers;
 
-  // Write to the cache (40-49).
-  ScopedMockTransaction transaction(kRangeGET_TransactionOK);
-  transaction.response_headers = "Content-Length: 10\n"
-                                 "ETag: \"foo\"\n";
-  RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
+    // Write to the cache (40-49).
+    ScopedMockTransaction transaction(kRangeGET_TransactionOK);
+    transaction.response_headers =
+        "Content-Length: 10\n"
+        "ETag: \"foo\"\n";
+    RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
 
-  Verify206Response(headers, 40, 49);
-  EXPECT_EQ(1, cache.network_layer()->transaction_count());
-  EXPECT_EQ(0, cache.disk_cache()->open_count());
-  EXPECT_EQ(1, cache.disk_cache()->create_count());
+    Verify206Response(headers, 40, 49);
+    EXPECT_EQ(1, cache.network_layer()->transaction_count());
+    EXPECT_EQ(0, cache.disk_cache()->open_count());
+    EXPECT_EQ(1, cache.disk_cache()->create_count());
 
-  // Now verify that the cached data is not used.
-  // Don't ask for a range. The cache will attempt to use the cached data but
-  // should discard it as it cannot be validated. A regular request should go
-  // to the server and a new entry should be created.
-  transaction.request_headers = EXTRA_HEADER;
-  transaction.data = "Not a range";
-  RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
+    // Now verify that the cached data is not used.
+    // Don't ask for a range. The cache will attempt to use the cached data but
+    // should discard it as it cannot be validated. A regular request should go
+    // to the server and a new entry should be created.
+    transaction.request_headers = EXTRA_HEADER;
+    transaction.data = "Not a range";
+    RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
 
-  EXPECT_EQ(0U, headers.find("HTTP/1.1 200 OK\n"));
-  EXPECT_EQ(2, cache.network_layer()->transaction_count());
-  EXPECT_EQ(1, cache.disk_cache()->open_count());
-  EXPECT_EQ(2, cache.disk_cache()->create_count());
+    EXPECT_EQ(0U, headers.find("HTTP/1.1 200 OK\n"));
+    EXPECT_EQ(2, cache.network_layer()->transaction_count());
+    EXPECT_EQ(1, cache.disk_cache()->open_count());
+    EXPECT_EQ(2, cache.disk_cache()->create_count());
 
-  // The last response was saved.
-  RunTransactionTest(cache.http_cache(), transaction);
-  EXPECT_EQ(3, cache.network_layer()->transaction_count());
-  EXPECT_EQ(2, cache.disk_cache()->open_count());
-  EXPECT_EQ(2, cache.disk_cache()->create_count());
+    // The last response was saved.
+    // ### before commit: figure out the way to actually test that.
+    // The open results in a useless entry since
+    // &RangeTransactionServer::RangeHandler returns headers without an ETag
+    // or a non-range request (not the things we set above).
+    RunTransactionTest(cache.http_cache(), transaction);
+    EXPECT_EQ(3, cache.network_layer()->transaction_count());
+    if (use_memory_entry_data) {
+      EXPECT_EQ(1, cache.disk_cache()->open_count());
+      EXPECT_EQ(3, cache.disk_cache()->create_count());
+    } else {
+      EXPECT_EQ(2, cache.disk_cache()->open_count());
+      EXPECT_EQ(2, cache.disk_cache()->create_count());
+    }
+  }
 }
 
 // Verifies that conditionalization failures when asking for a range that would
 // require the cache to modify the range to ask, result in a network request
 // that matches the user's one.
 TEST(HttpCache, RangeGET_NoConditionalization2) {
   MockHttpCache cache;
   cache.FailConditionalizations();
   std::string headers;
 
@@ skipping 2451 matching lines @@
     // read the response body -- want to test that it is still getting cached.
   }
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }
 
 // Verify that no-cache resources are stored in cache, but are not fetched from
 // cache during normal loads.
 TEST(HttpCache, CacheControlNoCacheNormalLoad) {
-  MockHttpCache cache;
+  for (bool use_memory_entry_data : {false, true}) {
+    MockHttpCache cache;
+    cache.disk_cache()->set_support_in_memory_entry_data(use_memory_entry_data);
 
-  ScopedMockTransaction transaction(kSimpleGET_Transaction);
-  transaction.response_headers = "cache-control: no-cache\n";
+    ScopedMockTransaction transaction(kSimpleGET_Transaction);
+    transaction.response_headers = "cache-control: no-cache\n";
 
-  // Initial load.
-  RunTransactionTest(cache.http_cache(), transaction);
+    // Initial load.
+    RunTransactionTest(cache.http_cache(), transaction);
 
-  EXPECT_EQ(1, cache.network_layer()->transaction_count());
-  EXPECT_EQ(0, cache.disk_cache()->open_count());
-  EXPECT_EQ(1, cache.disk_cache()->create_count());
+    EXPECT_EQ(1, cache.network_layer()->transaction_count());
+    EXPECT_EQ(0, cache.disk_cache()->open_count());
+    EXPECT_EQ(1, cache.disk_cache()->create_count());
 
-  // Try loading again; it should result in a network fetch.
-  RunTransactionTest(cache.http_cache(), transaction);
+    // Try loading again; it should result in a network fetch.
+    RunTransactionTest(cache.http_cache(), transaction);
 
-  EXPECT_EQ(2, cache.network_layer()->transaction_count());
-  EXPECT_EQ(1, cache.disk_cache()->open_count());
-  EXPECT_EQ(1, cache.disk_cache()->create_count());
+    EXPECT_EQ(2, cache.network_layer()->transaction_count());
+    if (use_memory_entry_data) {
+      EXPECT_EQ(0, cache.disk_cache()->open_count());
+      EXPECT_EQ(2, cache.disk_cache()->create_count());
+    } else {
+      EXPECT_EQ(1, cache.disk_cache()->open_count());
+      EXPECT_EQ(1, cache.disk_cache()->create_count());
+    }
 
-  disk_cache::Entry* entry;
-  EXPECT_TRUE(cache.OpenBackendEntry(transaction.url, &entry));
-  entry->Close();
+    disk_cache::Entry* entry;
+    EXPECT_TRUE(cache.OpenBackendEntry(transaction.url, &entry));
+    entry->Close();
+  }
 }
 
 // Verify that no-cache resources are stored in cache and fetched from cache
 // when the LOAD_SKIP_CACHE_VALIDATION flag is set.
 TEST(HttpCache, CacheControlNoCacheHistoryLoad) {
   MockHttpCache cache;
 
   ScopedMockTransaction transaction(kSimpleGET_Transaction);
   transaction.response_headers = "cache-control: no-cache\n";
 
@@ skipping 1671 matching lines @@
   ASSERT_TRUE(attrs->GetDictionary(
       base::trace_event::MemoryAllocatorDump::kNameSize, &size_attrs));
   std::string size;
   ASSERT_TRUE(size_attrs->GetString("value", &size));
   int actual_size = 0;
   ASSERT_TRUE(base::HexStringToInt(size, &actual_size));
   ASSERT_LT(0, actual_size);
 }
 
 }  // namespace net