Http cache: Allow caching of byte ranges without strong validators.

net/http/http_cache_transaction.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_transaction.h"
 
 #include "build/build_config.h"
 
 #if defined(OS_POSIX)
 #include <unistd.h>
@@ skipping 1541 matching lines @@
   response_ = *new_response_;
 
   if (request_->method == "HEAD") {
     // This response is replacing the cached one.
     DoneWritingToEntry(false);
     mode_ = NONE;
     new_response_ = NULL;
     return OK;
   }
 
-  if (handling_206_ && !CanResume(false)) {

[davidben, 2014/08/29 18:03:23]

CanResume checks for a few things other than HasStrongValidators, like a missing
Content-Length. Should that still skip writing to the cache or will the rest of
the logic handle it?

[rvargas (doing something else), 2014/08/29 19:34:27]

The rest of the logic will handle that. CanResume checks all conditions needed
to issue a conditional byte-range request, which we now don't consider to save a
response. If matching the stored data with a requested range fails, we bail out
before getting to the revalidation logic (PartialData::UpdateFromStoredHeaders)

-    // There is no point in storing this resource because it will never be used.
-    DoneWritingToEntry(false);
-    if (partial_.get())
-      partial_->FixResponseHeaders(response_.headers.get(), true);
-    next_state_ = STATE_PARTIAL_HEADERS_RECEIVED;
-    return OK;
-  }
-
   target_state_ = STATE_TRUNCATE_CACHED_DATA;
   next_state_ = truncated_ ? STATE_CACHE_WRITE_TRUNCATED_RESPONSE :
                              STATE_CACHE_WRITE_RESPONSE;
   return OK;
 }
 
 int HttpCache::Transaction::DoTruncateCachedData() {
   next_state_ = STATE_TRUNCATE_CACHED_DATA_COMPLETE;
   if (!entry_)
     return OK;
@@ skipping 719 matching lines @@
 
   if (request_->method == "PUT" || request_->method == "DELETE")
     return false;
 
   // This only makes sense for cached 200 or 206 responses.
   if (response_.headers->response_code() != 200 &&
       response_.headers->response_code() != 206) {
     return false;
   }
 
-  // We should have handled this case before.
-  DCHECK(response_.headers->response_code() != 206 ||
-         response_.headers->HasStrongValidators());
+  if (response_.headers->response_code() == 206 &&
+      !response_.headers->HasStrongValidators()) {
+    return false;
+  }
 
   // Just use the first available ETag and/or Last-Modified header value.
   // TODO(darin): Or should we use the last?
 
   std::string etag_value;
   if (response_.headers->GetHttpVersion() >= HttpVersion(1, 1))
     response_.headers->EnumerateHeader(NULL, "etag", &etag_value);
 
   std::string last_modified_value;
   if (!vary_mismatch_) {
@@ skipping 539 matching lines @@
     default:
       NOTREACHED();
   }
 }
 
 void HttpCache::Transaction::OnIOComplete(int result) {
   DoLoop(result);
 }
 
 }  // namespace net