Http cache: Allow multiple external validation headers....

net/http/http_cache.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 <algorithm>
 #include <string>
 
 #include "base/compiler_specific.h"
@@ skipping 53 matching lines @@
   const char* related_response_header_name;
 };
 
 static const ValidationHeaderInfo kValidationHeaders[] = {
   { "if-modified-since", "last-modified" },
   { "if-none-match", "etag" },
 };
 
 // Helper struct to pair a header name with its value, for
 // headers used to validate cache entries.
-struct ValidationHeader {
-  enum {kInvalidIndex = -1};
+struct ValidationHeaders {
+  ValidationHeaders() : initialized(false) {}
 
-  ValidationHeader() : type_index(kInvalidIndex) {}
-
-  bool initialized() const {
-    return type_index != kInvalidIndex;
-  }
-
-  const ValidationHeaderInfo& type_info() {
-    DCHECK(initialized());
-    return kValidationHeaders[type_index];
-  }
-
-  // Index into |kValidationHeaders|.
-  int type_index;
-  std::string value;
+  std::string values[ARRAYSIZE_UNSAFE(kValidationHeaders)];
+  bool initialized;
 };
 
 // If the request includes one of these request headers, then avoid reusing
 // our cached copy if any.
 static const HeaderNameAndValue kForceFetchHeaders[] = {
   { "cache-control", "no-cache" },
   { "pragma", "no-cache" },
   { NULL, NULL }
 };
 
@@ skipping 263 matching lines @@
   // Called to signal completion of the cache's WriteData method:
   void OnCacheWriteCompleted(int result);
 
   // Called to signal completion of the cache entry's ReadyForSparseIO method:
   void OnCacheEntryReady(int result);
 
   scoped_refptr<LoadLog> load_log_;
   const HttpRequestInfo* request_;
   scoped_ptr<HttpRequestInfo> custom_request_;
   // If extra_headers specified a "if-modified-since" or "if-none-match",
-  // |external_validation_| contains the value of that header.
-  ValidationHeader external_validation_;
+  // |external_validation_| contains the value of those headers.
+  ValidationHeaders external_validation_;
   base::WeakPtr<HttpCache> cache_;
   HttpCache::ActiveEntry* entry_;
   scoped_ptr<HttpTransaction> network_trans_;
   CompletionCallback* callback_;  // Consumer's callback.
   HttpResponseInfo response_;
   HttpResponseInfo auth_response_;
   std::string cache_key_;
   Mode mode_;
   bool reading_;  // We are already reading.
   bool invalid_range_;  // We may bypass the cache for this request.
@@ skipping 65 matching lines @@
     // requested cache access mode
     if (effective_load_flags_ & LOAD_ONLY_FROM_CACHE) {
       mode_ = READ;
     } else if (effective_load_flags_ & LOAD_BYPASS_CACHE) {
       mode_ = WRITE;
     } else {
       mode_ = READ_WRITE;
     }
 
     // Downgrade to UPDATE if the request has been externally conditionalized.
-    if (external_validation_.initialized()) {
+    if (external_validation_.initialized) {
       if (mode_ & WRITE) {
         // Strip off the READ_DATA bit (and maybe add back a READ_META bit
         // in case READ was off).
         mode_ = UPDATE;
       } else {
         mode_ = NONE;
       }
     }
   }
 
@@ skipping 320 matching lines @@
     const HeaderNameAndValue* search;
     int load_flag;
   } kSpecialHeaders[] = {
     { kPassThroughHeaders, LOAD_DISABLE_CACHE },
     { kForceFetchHeaders, LOAD_BYPASS_CACHE },
     { kForceValidateHeaders, LOAD_VALIDATE_CACHE },
   };
 
   std::string new_extra_headers;
   bool range_found = false;
-
-  // We will scan through the headers to see if any "if-modified-since" or
-  // "if-none-match" request headers were specified as part of extra_headers.
-  int num_validation_headers = 0;
-  ValidationHeader validation_header;
+  bool external_validation_error = false;
 
   // scan request headers to see if we have any that would impact our load flags
   HttpUtil::HeadersIterator it(request_->extra_headers.begin(),
                                request_->extra_headers.end(),
                                "\r\n");
   while (it.GetNext()) {
     if (!LowerCaseEqualsASCII(it.name(), "range")) {
       new_extra_headers.append(it.name_begin(), it.values_end());
       new_extra_headers.append("\r\n");
     } else {
@@ skipping 10 matching lines @@
         break;
       }
     }
 
     // Check for conditionalization headers which may correspond with a
     // cache validation request.
     for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kValidationHeaders); ++i) {
       const ValidationHeaderInfo& info = kValidationHeaders[i];
       if (LowerCaseEqualsASCII(it.name_begin(), it.name_end(),
                                info.request_header_name)) {
-        num_validation_headers++;
-        validation_header.type_index = i;
-        validation_header.value = it.values();
+        if (!external_validation_.values[i].empty() || it.values().empty())
+          external_validation_error = true;
+        external_validation_.values[i] = it.values();
+        external_validation_.initialized = true;
         break;
       }
     }
   }
 
   // We don't support ranges and validation headers.
-  if (range_found && num_validation_headers) {
+  if (range_found && external_validation_.initialized) {
     LOG(WARNING) << "Byte ranges AND validation headers found.";
     effective_load_flags_ |= LOAD_DISABLE_CACHE;
   }
 
+  // If there is more than one validation header, we can't treat this request as
+  // a cache validation, since we don't know for sure which header the server
+  // will give us a response for (and they could be contradictory).
+  if (external_validation_error) {
+    LOG(WARNING) << "Multiple or malformed validation headers found.";
+    effective_load_flags_ |= LOAD_DISABLE_CACHE;
+  }
+
   if (range_found && !(effective_load_flags_ & LOAD_DISABLE_CACHE)) {
     partial_.reset(new PartialData);
     if (partial_->Init(request_->extra_headers, new_extra_headers)) {
       // We will be modifying the actual range requested to the server, so
       // let's remove the header here.
       custom_request_.reset(new HttpRequestInfo(*request_));
       request_ = custom_request_.get();
       custom_request_->extra_headers = new_extra_headers;
     } else {
       // The range is invalid or we cannot handle it properly.
       LOG(WARNING) << "Invalid byte range found.";
       effective_load_flags_ |= LOAD_DISABLE_CACHE;
       partial_.reset(NULL);
     }
   }
-
-  // If there is more than one validation header, we can't treat this request as
-  // a cache validation, since we don't know for sure which header the server
-  // will give us a response for (and they could be contradictory).
-  if (num_validation_headers > 1) {
-    LOG(WARNING) << "Multiple validation headers found.";
-    effective_load_flags_ |= LOAD_DISABLE_CACHE;
-  }
-
-  if (num_validation_headers == 1) {
-    DCHECK(validation_header.initialized());
-    external_validation_ = validation_header;
-  }
 }
 
 bool HttpCache::Transaction::ShouldPassThrough() {
   // We may have a null disk_cache if there is an error we cannot recover from,
   // like not enough disk space, or sharing violations.
   if (!cache_->disk_cache())
     return true;
 
   // When using the record/playback modes, we always use the cache
   // and we never pass through.
@@ skipping 133 matching lines @@
     if (rv < 0 && rv != ERR_IO_PENDING)
       HandleResult(rv);
     return rv;
   }
 
   return BeginCacheValidation();
 }
 
 int HttpCache::Transaction::BeginExternallyConditionalizedRequest() {
   DCHECK_EQ(UPDATE, mode_);
-  DCHECK(external_validation_.initialized());
+  DCHECK(external_validation_.initialized);
 
   // Read the cached response.
   int rv = ReadResponseInfoFromEntry();
   if (rv != OK) {
     DCHECK(rv != ERR_IO_PENDING);
     return HandleResult(rv);
   }
 
-  // Retrieve either the cached response's "etag" or "last-modified" header,
-  // depending on which is applicable for the caller's request header.
-  std::string validator;
-  response_.headers->EnumerateHeader(
-      NULL,
-      external_validation_.type_info().related_response_header_name,
-      &validator);
+  for (size_t i = 0;  i < ARRAYSIZE_UNSAFE(kValidationHeaders); i++) {
+    if (external_validation_.values[i].empty())
+      continue;
+    // Retrieve either the cached response's "etag" or "last-modified" header.
+    std::string validator;
+    response_.headers->EnumerateHeader(
+        NULL,
+        kValidationHeaders[i].related_response_header_name,
+        &validator);
 
-  if (response_.headers->response_code() != 200 || truncated_ ||
-      validator.empty() || validator != external_validation_.value) {
-    // The externally conditionalized request is not a validation request
-    // for our existing cache entry. Proceed with caching disabled.
-    DoneWritingToEntry(true);
+    if (response_.headers->response_code() != 200 || truncated_ ||
+        validator.empty() || validator != external_validation_.values[i]) {
+      // The externally conditionalized request is not a validation request
+      // for our existing cache entry. Proceed with caching disabled.
+      DoneWritingToEntry(true);
+    }
   }
 
   return BeginNetworkRequest();
 }
 
 int HttpCache::Transaction::BeginNetworkRequest() {
   DCHECK(mode_ & WRITE || mode_ == NONE);
   DCHECK(!network_trans_.get());
 
   // Create a network transaction.
@@ skipping 1050 matching lines @@
       static_cast<net::HttpNetworkLayer*>(network_layer_.get());
   HttpNetworkSession* session = network->GetSession();
   if (session) {
     session->tcp_socket_pool()->CloseIdleSockets();
   }
 }
 
 //-----------------------------------------------------------------------------
 
 }  // namespace net