Http cache: Fix the code that handles 206s when revalidating...

net/http/http_cache_unittest.cc

 // Copyright (c) 2006-2009 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/hash_tables.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "net/base/net_errors.h"
@@ skipping 447 matching lines @@
   &FastTransactionServer::FastNoStoreHandler,
   0
 };
 
 // This class provides a handler for kRangeGET_TransactionOK so that the range
 // request can be served on demand.
 class RangeTransactionServer {
  public:
   RangeTransactionServer() {
     not_modified_ = false;
+    modified_ = false;
   }
   ~RangeTransactionServer() {
     not_modified_ = false;
+    modified_ = false;
   }
 
+  // Returns only 416 or 304 when set.
   void set_not_modified(bool value) { not_modified_ = value; }
 
+  // Returns 206 when revalidating a range (instead of 304).
+  void set_modified(bool value) { modified_ = value; }
+
   static void RangeHandler(const net::HttpRequestInfo* request,
                            std::string* response_status,
                            std::string* response_headers,
                            std::string* response_data);
 
  private:
   static bool not_modified_;
+  static bool modified_;
   DISALLOW_COPY_AND_ASSIGN(RangeTransactionServer);
 };
 bool RangeTransactionServer::not_modified_ = false;
+bool RangeTransactionServer::modified_ = false;
 
 // Static.
 void RangeTransactionServer::RangeHandler(const net::HttpRequestInfo* request,
                                           std::string* response_status,
                                           std::string* response_headers,
                                           std::string* response_data) {
   if (request->extra_headers.empty()) {
     response_status->assign("HTTP/1.1 416 Requested Range Not Satisfiable");
     return;
   }
@@ skipping 17 matching lines @@
   EXPECT_TRUE(byte_range.ComputeBounds(80));
   int start = static_cast<int>(byte_range.first_byte_position());
   int end = static_cast<int>(byte_range.last_byte_position());
 
   EXPECT_LT(end, 80);
 
   std::string content_range = StringPrintf("Content-Range: bytes %d-%d/80\n",
                                            start, end);
   response_headers->append(content_range);
 
-  if (request->extra_headers.find("If-None-Match") == std::string::npos) {
+  if (request->extra_headers.find("If-None-Match") == std::string::npos ||
+      modified_) {
     EXPECT_EQ(9, (end - start) % 10);
     std::string data;
     for (int block_start = start; block_start < end; block_start += 10)
       StringAppendF(&data, "rg: %02d-%02d ", block_start, block_start + 9);
     *response_data = data;
 
     if (end - start != 9) {
       // We also have to fix content-length.
       int len = end - start + 1;
       EXPECT_EQ(0, len % 10);
@@ skipping 1226 matching lines @@
                                  &headers);
 
   EXPECT_TRUE(Verify206Response(headers, 40, 49));
   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(&kRangeGET_TransactionOK);
 }
 
+// Tests that we deal with 206s when revalidating range requests.
+TEST(HttpCache, DISABLED_RangeGET_ModifiedResult) {
+  MockHttpCache cache;
+  AddMockTransaction(&kRangeGET_TransactionOK);
+  std::string headers;
+
+  // Write to the cache (40-49).
+  RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
+                                 &headers);
+
+  EXPECT_TRUE(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());
+
+  // Attempt to read from the cache (40-49).
+  RangeTransactionServer handler;
+  handler.set_modified(true);
+  RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
+                                 &headers);
+
+  EXPECT_TRUE(Verify206Response(headers, 40, 49));
+  EXPECT_EQ(2, cache.network_layer()->transaction_count());
+  EXPECT_EQ(1, cache.disk_cache()->open_count());
+  EXPECT_EQ(1, cache.disk_cache()->create_count());
+
+  // And the entry should be gone.
+  RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
+  EXPECT_EQ(3, cache.network_layer()->transaction_count());
+  EXPECT_EQ(1, cache.disk_cache()->open_count());
+  EXPECT_EQ(2, cache.disk_cache()->create_count());
+
+  RemoveMockTransaction(&kRangeGET_TransactionOK);
+}
+
 // Tests that we can cache range requests when the start or end is unknown.
 // We start with one suffix request, followed by a request from a given point.
 TEST(HttpCache, DISABLED_UnknownRangeGET_1) {
   MockHttpCache cache;
   AddMockTransaction(&kRangeGET_TransactionOK);
   std::string headers;
 
   // Write to the cache (70-79).
   MockTransaction transaction(kRangeGET_TransactionOK);
   transaction.request_headers = "Range: bytes = -10\r\n";
@@ skipping 607 matching lines @@
 
   // force this transaction to write to the cache again
   MockTransaction transaction(kSimpleGET_Transaction);
 
   RunTransactionTest(cache.http_cache(), transaction);
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }