Start work on splitting off the usage piece of in-memory index. This revision is just from the prev…

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"  // For OS_POSIX
 
 #if defined(OS_POSIX)
 #include <unistd.h>
@@ skipping 1043 matching lines @@
   if (result == OK) {
     TransitionToState(STATE_ADD_TO_ENTRY);
     return OK;
   }
 
   if (result == ERR_CACHE_RACE) {
     TransitionToState(STATE_HEADERS_PHASE_CANNOT_PROCEED);
     return OK;
   }
 
+  if (result == ERR_CACHE_ENTRY_NOT_SUITABLE) {
+    DCHECK_EQ(mode_, READ_WRITE);
+    // Record this as CantConditionalize, but otherwise proceed as we would
+    // below --- as OpenEntry has already dropped the old entry for us.
+    couldnt_conditionalize_request_ = true;
+    UpdateCacheEntryStatus(CacheEntryStatus::ENTRY_CANT_CONDITIONALIZE);
+  }
+
   if (method_ == "PUT" || method_ == "DELETE" ||
       (method_ == "HEAD" && mode_ == READ_WRITE)) {
     DCHECK(mode_ == READ_WRITE || mode_ == WRITE || method_ == "HEAD");
     mode_ = NONE;
     TransitionToState(STATE_SEND_REQUEST);
     return OK;
   }
 
   if (mode_ == READ_WRITE) {
     mode_ = WRITE;
@@ skipping 1477 matching lines @@
       stale_entry_freshness_ = lifetimes.freshness;
       stale_entry_age_ = response_.headers->GetCurrentAge(
           response_.request_time, response_.response_time,
           cache_->clock_->Now());
     }
   }
 
   return validation_required_by_headers;
 }
 
+bool HttpCache::Transaction::ResponseConditionalizable(
+    std::string* etag_value,
+    std::string* last_modified_value) {
+  DCHECK(response_.headers.get());
+
+  // This only makes sense for cached 200 or 206 responses.
+  if (response_.headers->response_code() != 200 &&
+      response_.headers->response_code() != 206) {
+    return false;
+  }
+
+  // Just use the first available ETag and/or Last-Modified header value.
+  // TODO(darin): Or should we use the last?
+
+  if (response_.headers->GetHttpVersion() >= HttpVersion(1, 1))
+    response_.headers->EnumerateHeader(NULL, "etag", etag_value);
+
+  response_.headers->EnumerateHeader(NULL, "last-modified",
+                                     last_modified_value);
+
+  if (etag_value->empty() && last_modified_value->empty())
+    return false;
+
+  return true;
+}
+
 bool HttpCache::Transaction::ConditionalizeRequest() {
   DCHECK(response_.headers.get());
 
   if (method_ == "PUT" || 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) {
+  if (fail_conditionalization_for_test_)
     return false;
-  }
 
-  if (fail_conditionalization_for_test_)
+  std::string etag_value;
+  std::string last_modified_value;
+  if (!ResponseConditionalizable(&etag_value, &last_modified_value))
     return false;
 
   DCHECK(response_.headers->response_code() != 206 ||
          response_.headers->HasStrongValidators());
 
-  // 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_) {
-    response_.headers->EnumerateHeader(NULL, "last-modified",
-                                       &last_modified_value);
+  if (vary_mismatch_) {
+    // Can't rely on last-modified if vary is different.
+    last_modified_value.clear();
+    if (etag_value.empty())
+      return false;
   }
 
-  if (etag_value.empty() && last_modified_value.empty())
-    return false;
-
   if (!partial_) {
     // Need to customize the request, so this forces us to allocate :(
     custom_request_.reset(new HttpRequestInfo(*request_));
     request_ = custom_request_.get();
   }
   DCHECK(custom_request_.get());
 
   bool use_if_range =
       partial_ && !partial_->IsCurrentRangeCached() && !invalid_range_;
 
@@ skipping 19 matching lines @@
           HttpRequestHeaders::kIfRange, last_modified_value);
     } else {
       custom_request_->extra_headers.SetHeader(
           HttpRequestHeaders::kIfModifiedSince, last_modified_value);
     }
   }
 
   return true;
 }
 
+bool HttpCache::Transaction::MaybeRejectBasedOnEntryInMemoryData(
+    uint8_t in_memory_info) {
+  // Not going to be clever with those...
+  if (partial_)
+    return false;
+
+  // Unclear how to reconcile trying to avoid opening the entry with UPDATE's
+  // semantics.
+  if (mode_ == UPDATE)
+    return false;
+
+  // If we are loading ignoring cache validity (aka back button), obviously
+  // can't reject things based on it.
+  if (effective_load_flags_ & LOAD_SKIP_CACHE_VALIDATION)
+    return false;
+
+  // This is a prefetch resource that hasn't been used yet; those get a slight
+  // loosening of caching rules.
+  if (in_memory_info & HttpCache::HINT_UNUSED_SINCE_PREFETCH)
+    return false;
+
+  // We need the entry to have zero lifetime to be able to tell it's expired
+  // w/o reading full headers --- an expiration date is hard to fit into a few
+  // bits.
+  if (!(in_memory_info & HttpCache::HINT_ZERO_LIFETIME))
+    return false;
+
+  // We also need to know that the entry can't be used for a conditional request
+  // (e.g. perhaps because it has neither ETag nor Last-Modified).
+  //
+  // This could potentially be refined to look at the actual request, since
+  // it may be unconditionalizable for reasons not captured in the hint.
+  if (!(in_memory_info & HttpCache::HINT_RESPONSE_CANT_CONDITIONALIZE))
+    return false;
+
+  return true;
+}
+
 // We just received some headers from the server. We may have asked for a range,
 // in which case partial_ has an object. This could be the first network request
 // we make to fulfill the original request, or we may be already reading (from
 // the net and / or the cache). If we are not expecting a certain response, we
 // just bypass the cache for this request (but again, maybe we are reading), and
 // delete partial_ (so we are not able to "fix" the headers that we return to
 // the user). This results in either a weird response for the caller (we don't
 // expect it after all), or maybe a range that was not exactly what it was asked
 // for.
 //
@@ skipping 202 matching lines @@
   if (truncated)
     DCHECK_EQ(200, response_.headers->response_code());
 
   // When writing headers, we normally only write the non-transient headers.
   bool skip_transient_headers = true;
   scoped_refptr<PickledIOBuffer> data(new PickledIOBuffer());
   response_.Persist(data->pickle(), skip_transient_headers, truncated);
   data->Done();
 
   io_buf_len_ = data->pickle()->size();
+
+  // Summarize some info on cacheability in memory.
+  uint8_t hints = 0;
+  if (response_.headers->GetFreshnessLifetimes(response_.response_time)
+          .freshness.is_zero())
+    hints |= HttpCache::HINT_ZERO_LIFETIME;
+  std::string etag_ignored, last_modified_ignored;
+  if (!ResponseConditionalizable(&etag_ignored, &last_modified_ignored))
+    hints |= HttpCache::HINT_RESPONSE_CANT_CONDITIONALIZE;
+  if (response_.unused_since_prefetch)
+    hints |= HttpCache::HINT_UNUSED_SINCE_PREFETCH;
+  cache_->GetCurrentBackend()->SetEntryInMemoryData(cache_key_, hints);
+
   return entry_->disk_entry->WriteData(kResponseInfoIndex, 0, data.get(),
                                        io_buf_len_, io_callback_, true);
 }
 
 int HttpCache::Transaction::OnWriteResponseInfoToEntryComplete(int result) {
   if (!entry_)
     return OK;
   if (net_log_.IsCapturing()) {
     net_log_.EndEventWithNetErrorCode(NetLogEventType::HTTP_CACHE_WRITE_INFO,
                                       result);
@@ skipping 386 matching lines @@
 }
 
 void HttpCache::Transaction::TransitionToState(State state) {
   // Ensure that the state is only set once per Do* state.
   DCHECK(in_do_loop_);
   DCHECK_EQ(STATE_UNSET, next_state_) << "Next state is " << state;
   next_state_ = state;
 }
 
 }  // namespace net