Exposing CacheEntryStatus (former TransactionPattern) via UrlRequest

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 40 matching lines @@
 #include "net/ssl/ssl_connection_status_flags.h"
 #include "net/test/cert_test_util.h"
 #include "net/test/test_data_directory.h"
 #include "net/websockets/websocket_handshake_stream_base.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::Time;
 
 namespace net {
 
+using CacheEntryStatus = HttpResponseInfo::CacheEntryStatus;
+
 namespace {
 
 // Tests the load timing values of a request that goes through a
 // MockNetworkTransaction.
 void TestLoadTimingNetworkRequest(const LoadTimingInfo& load_timing_info) {
   EXPECT_FALSE(load_timing_info.socket_reused);
   EXPECT_NE(NetLog::Source::kInvalidId, load_timing_info.socket_log_id);
 
   EXPECT_TRUE(load_timing_info.proxy_resolve_start.is_null());
   EXPECT_TRUE(load_timing_info.proxy_resolve_end.is_null());
@@ skipping 977 matching lines @@
 
   // write to the cache
   HttpResponseInfo response_info;
   RunTransactionTestWithResponseInfo(cache.http_cache(), kSimpleGET_Transaction,
                                      &response_info);
 
   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_TRUE(response_info.network_accessed);
+  EXPECT_EQ(CacheEntryStatus::NOT_IN_CACHE, response_info.cache_entry_status);
 }
 
 // Confirm if we have a fresh entry in cache, it isn't marked as
 // network verified.
 TEST(HttpCache, SimpleGET_NetworkAccessed_Cache) {
   MockHttpCache cache;
 
   // Prime cache.
   MockTransaction transaction(kSimpleGET_Transaction);
 
   RunTransactionTest(cache.http_cache(), transaction);
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Re-run transaction; make sure we don't mark the network as accessed.
   HttpResponseInfo response_info;
   RunTransactionTestWithResponseInfo(cache.http_cache(), transaction,
                                      &response_info);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_FALSE(response_info.server_data_unavailable);
   EXPECT_FALSE(response_info.network_accessed);
+  EXPECT_EQ(CacheEntryStatus::USED, response_info.cache_entry_status);
 }
 
 TEST(HttpCache, SimpleGET_LoadBypassCache) {
   MockHttpCache cache;
 
   // Write to the cache.
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   // Force this transaction to write to the cache again.
   MockTransaction transaction(kSimpleGET_Transaction);
@@ skipping 6908 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());
   EXPECT_TRUE(response_info.was_cached);
 
   // The new SSL state is reported.
   EXPECT_EQ(status2, response_info.ssl_info.connection_status);
   EXPECT_TRUE(cert2->Equals(response_info.ssl_info.cert.get()));
 }
 
+TEST(HttpCache, CacheEntryStatusOther) {
+  MockHttpCache cache;
+
+  HttpResponseInfo response_info;
+  RunTransactionTestWithResponseInfo(cache.http_cache(), kRangeGET_Transaction,
+                                     &response_info);
+
+  EXPECT_FALSE(response_info.was_cached);
+  EXPECT_TRUE(response_info.network_accessed);
+  EXPECT_EQ(CacheEntryStatus::OTHER, response_info.cache_entry_status);
+}
+
+TEST(HttpCache, CacheEntryStatusNotInCache) {
+  MockHttpCache cache;
+
+  HttpResponseInfo response_info;
+  RunTransactionTestWithResponseInfo(cache.http_cache(), kSimpleGET_Transaction,
+                                     &response_info);
+
+  EXPECT_FALSE(response_info.was_cached);
+  EXPECT_TRUE(response_info.network_accessed);
+  EXPECT_EQ(CacheEntryStatus::NOT_IN_CACHE, response_info.cache_entry_status);
+}
+
+TEST(HttpCache, CacheEntryStatusUsed) {
+  MockHttpCache cache;
+  RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
+
+  HttpResponseInfo response_info;
+  RunTransactionTestWithResponseInfo(cache.http_cache(), kSimpleGET_Transaction,
+                                     &response_info);
+
+  EXPECT_TRUE(response_info.was_cached);
+  EXPECT_FALSE(response_info.network_accessed);
+  EXPECT_EQ(CacheEntryStatus::USED, response_info.cache_entry_status);
+}
+
+TEST(HttpCache, CacheEntryStatusValidated) {
+  MockHttpCache cache;
+  RunTransactionTest(cache.http_cache(), kETagGET_Transaction);
+
+  ScopedMockTransaction still_valid(kETagGET_Transaction);
+  still_valid.load_flags = LOAD_VALIDATE_CACHE;  // Force a validation.
+  still_valid.handler = ETagGet_ConditionalRequest_Handler;
+
+  HttpResponseInfo response_info;
+  RunTransactionTestWithResponseInfo(cache.http_cache(), still_valid,
+                                     &response_info);
+
+  EXPECT_TRUE(response_info.was_cached);
+  EXPECT_TRUE(response_info.network_accessed);
+  EXPECT_EQ(CacheEntryStatus::VALIDATED, response_info.cache_entry_status);
+}
+
+TEST(HttpCache, CacheEntryStatusUpdated) {
+  MockHttpCache cache;
+  RunTransactionTest(cache.http_cache(), kETagGET_Transaction);
+
+  ScopedMockTransaction update(kETagGET_Transaction);
+  update.load_flags = LOAD_VALIDATE_CACHE;  // Force a validation.
+
+  HttpResponseInfo response_info;
+  RunTransactionTestWithResponseInfo(cache.http_cache(), update,
+                                     &response_info);
+
+  EXPECT_FALSE(response_info.was_cached);
+  EXPECT_TRUE(response_info.network_accessed);
+  EXPECT_EQ(CacheEntryStatus::UPDATED, response_info.cache_entry_status);
+}
+
+TEST(HttpCache, CacheEntryStatusCantConditionalize) {
+  MockHttpCache cache;
+  cache.FailConditionalizations();
+  RunTransactionTest(cache.http_cache(), kTypicalGET_Transaction);
+
+  HttpResponseInfo response_info;
+  RunTransactionTestWithResponseInfo(cache.http_cache(),
+                                     kTypicalGET_Transaction, &response_info);
+
+  EXPECT_FALSE(response_info.was_cached);
+  EXPECT_TRUE(response_info.network_accessed);
+  EXPECT_EQ(CacheEntryStatus::CANT_CONDITIONALIZE,
+            response_info.cache_entry_status);
+}
+

[jkarlin, 2016/07/06 17:09:41]

Also add a test for an authentication request that winds up reading the
authentication response info to make sure that we get the right status.

[jamartin, 2016/07/07 21:36:38]

I need your help with this. Currently (see the new test) the cache_entry_status
is being set to ENTRY_OTHER in the Read function. However, that function is
being called by RunTransactionTestBase AFTER the response_info is retrieved, and
thus it shows as ENTRY_UNDEFINED.

What do we want here? (see the TODO for alternatives)

If you want me to add or change any of the existing calls to
UpdateCacheEntryStatus, please advise on its location. I don't have a sound
understanding of the state machine in http_cache_transaction so I'm hesitant to
alter the logic in non-isolated ways.

[jkarlin, 2016/07/18 17:24:46]

That's the correct behavior for each case.
Let's test both cases. In one case use the RunTransactionTestBase and in the
other you'll have to modify that code a bit to call Read first.

[jamartin, 2016/07/19 16:02:46]

Done.

[jkarlin, 2016/07/21 17:25:54]

I was wrong, my apologies, the auth request can come up for various reasons and
not just OTHER. Given that, please remove the DCHECK and these two unittests.

[jamartin, 2016/07/25 13:39:16]

No worries. I was getting concerned by the failures in "git cl try", so this
explains it. Done.

 }  // namespace net