Cache failover to LOAD_PREFERRING_CACHE if network response suggests offline.

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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop.h"
@@ skipping 137 matching lines @@
                                         num_network_delegate_actions));
   }
   scoped_ptr<net::HttpTransaction> trans;
   int rv = cache->CreateTransaction(&trans, delegate.get());
   EXPECT_EQ(net::OK, rv);
   ASSERT_TRUE(trans.get());
 
   rv = trans->Start(&request, callback.callback(), net_log);
   if (rv == net::ERR_IO_PENDING)
     rv = callback.WaitForResult();
-  ASSERT_EQ(net::OK, rv);
+  ASSERT_EQ(trans_info.return_code, rv);
+
+  if (net::OK != rv)
+    return;
 
   const net::HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response);
 
   if (response_info)
     *response_info = *response;
 
   ReadAndVerifyTransaction(trans.get(), trans_info);
 }
 
@@ skipping 665 matching lines @@
   transaction.load_flags |= net::LOAD_PREFERRING_CACHE;
   transaction.request_headers = "Foo: none\n";
   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);
 }
 
+// Tests that LOAD_FROM_CACHE_IF_OFFLINE returns proper response on
+// network success
+TEST(HttpCache, SimpleGET_CacheOverride_Network) {
+  MockHttpCache cache;
+
+  MockTransaction transaction(kSimpleGET_Transaction);
+  transaction.load_flags |= net::LOAD_FROM_CACHE_IF_OFFLINE;
+  transaction.response_headers = "Cache-Control: no-cache\n";
+
+  AddMockTransaction(&transaction);
+  net::HttpResponseInfo response_info;
+  RunTransactionTestWithResponseInfo(cache.http_cache(), transaction,
+                                     &response_info);
+
+  EXPECT_EQ(1, cache.network_layer()->transaction_count());
+  EXPECT_FALSE(response_info.was_cache_override);

[rvargas (doing something else), 2013/03/06 03:11:48]

It would be better to prime the cache so that at least there is a chance for the
code to pick the wrong one.

[Randy Smith (Not in Mondays), 2013/03/06 22:55:55]

Good point.  Done.

+
+  RemoveMockTransaction(&transaction);
+}
+
+// Tests that LOAD_FROM_CACHE_IF_OFFLINE returns proper response on
+// offline failure
+TEST(HttpCache, SimpleGET_CacheOverride_Offline) {
+  MockHttpCache cache;
+
+  // Prime cache

[rvargas (doing something else), 2013/03/06 03:11:48]

nit: period at the end

[Randy Smith (Not in Mondays), 2013/03/06 22:55:55]

Done.

+  MockTransaction transaction(kSimpleGET_Transaction);
+  transaction.load_flags |= net::LOAD_FROM_CACHE_IF_OFFLINE;
+  transaction.response_headers = "Cache-Control: no-cache\n";
+
+  AddMockTransaction(&transaction);
+  RunTransactionTest(cache.http_cache(), transaction);
+  EXPECT_EQ(1, cache.network_layer()->transaction_count());
+

[rvargas (doing something else), 2013/03/06 03:11:48]

EXPECT_EQ(1, cache.disk_cache()->create_count());

[Randy Smith (Not in Mondays), 2013/03/06 22:55:55]

Done.

+  // Network failure with offline error; should return cache entry above +
+  // flag signalling stale data.
+  transaction.return_code = net::ERR_NAME_NOT_RESOLVED;
+  AddMockTransaction(&transaction);

[rvargas (doing something else), 2013/03/06 03:11:48]

We should be removing the previous mock before adding another one.

[Randy Smith (Not in Mondays), 2013/03/06 22:55:55]

Done.

+
+  MockHttpRequest request(transaction);
+  net::TestCompletionCallback callback;
+  scoped_ptr<net::HttpTransaction> trans;
+  int rv = cache.http_cache()->CreateTransaction(&trans, NULL);
+  EXPECT_EQ(net::OK, rv);
+  ASSERT_TRUE(trans.get());
+  rv = trans->Start(&request, callback.callback(), net::BoundNetLog());
+  rv = callback.GetResult(rv);
+  EXPECT_EQ(net::OK, rv);

[rvargas (doing something else), 2013/03/06 03:11:48]

nit: merge this line with the previous one.

[Randy Smith (Not in Mondays), 2013/03/06 22:55:55]

Done.

+
+  const net::HttpResponseInfo* response_info1 = trans->GetResponseInfo();
+  ASSERT_TRUE(response_info1);
+  EXPECT_TRUE(response_info1->was_cache_override);

[rvargas (doing something else), 2013/03/06 03:11:48]

+ EXPECT_TRUE(response_info1->was_cached);

[Randy Smith (Not in Mondays), 2013/03/06 22:55:55]

Done.

+  ReadAndVerifyTransaction(trans.get(), transaction);
+  EXPECT_EQ(2, cache.network_layer()->transaction_count());
+
+  RemoveMockTransaction(&transaction);
+}
+
+// Tests that LOAD_FROM_CACHE_IF_OFFLINE returns proper response on
+// non-offline failure failure
+TEST(HttpCache, SimpleGET_CacheOverride_NonOffline) {
+  MockHttpCache cache;
+
+  // Prime cache
+  MockTransaction transaction(kSimpleGET_Transaction);
+  transaction.load_flags |= net::LOAD_FROM_CACHE_IF_OFFLINE;
+  transaction.response_headers = "Cache-Control: no-cache\n";
+
+  AddMockTransaction(&transaction);
+  RunTransactionTest(cache.http_cache(), transaction);
+  EXPECT_EQ(1, cache.network_layer()->transaction_count());
+
+  // Network failure with non-offline error; should fail with that error.
+  transaction.return_code = net::ERR_PROXY_CONNECTION_FAILED;
+  AddMockTransaction(&transaction);
+
+  net::HttpResponseInfo response_info2;
+  RunTransactionTestWithResponseInfo(cache.http_cache(), transaction,
+                                     &response_info2);
+
+  EXPECT_EQ(2, cache.network_layer()->transaction_count());
+  EXPECT_FALSE(response_info2.was_cache_override);
+
+  RemoveMockTransaction(&transaction);
+}
+
 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);
   transaction.load_flags |= net::LOAD_BYPASS_CACHE;
 
@@ skipping 4659 matching lines @@
 
   // Force this transaction to read from the cache.
   MockTransaction transaction(kSimpleGET_Transaction);
   transaction.load_flags |= net::LOAD_ONLY_FROM_CACHE;
 
   RunTransactionTestWithDelegate(cache.http_cache(),
                                  kSimpleGET_Transaction,
                                  5,
                                  0);
 }