Exposing CacheEntryStatus (former TransactionPattern) via UrlRequest

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 30 matching lines @@
 #include "net/http/http_util.h"
 #include "net/ssl/ssl_cert_request_info.h"
 #include "net/ssl/ssl_config_service.h"
 
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace net {
 
+using CacheEntryStatus = HttpResponseInfo::CacheEntryStatus;
+
 namespace {
 
 // TODO(ricea): Move this to HttpResponseHeaders once it is standardised.
 static const char kFreshnessHeader[] = "Resource-Freshness";
 
 // From http://tools.ietf.org/html/draft-ietf-httpbis-p6-cache-21#section-6
 //      a "non-error response" is one with a 2xx (Successful) or 3xx
 //      (Redirection) status code.
 bool NonErrorResponse(int status_code) {
   int status_code_range = status_code / 100;
@@ skipping 97 matching lines @@
       cache_pending_(false),
       done_reading_(false),
       vary_mismatch_(false),
       couldnt_conditionalize_request_(false),
       bypass_lock_for_test_(false),
       fail_conditionalization_for_test_(false),
       io_buf_len_(0),
       read_offset_(0),
       effective_load_flags_(0),
       write_len_(0),
-      transaction_pattern_(PATTERN_UNDEFINED),
+      cache_entry_status_(CacheEntryStatus::ENTRY_UNDEFINED),
       validation_cause_(VALIDATION_CAUSE_UNDEFINED),
       total_received_bytes_(0),
       total_sent_bytes_(0),
       websocket_handshake_stream_base_create_helper_(NULL),
       weak_factory_(this) {
   static_assert(HttpCache::Transaction::kNumValidationHeaders ==
                     arraysize(kValidationHeaders),
                 "invalid number of validation headers");
 
   io_callback_ = base::Bind(&Transaction::OnIOComplete,
@@ skipping 146 matching lines @@
   DCHECK(auth_response_.headers.get());
   DCHECK(!callback.is_null());
 
   // Ensure that we only have one asynchronous call at a time.
   DCHECK(callback_.is_null());
 
   if (!cache_.get())
     return ERR_UNEXPECTED;
 
   // Clear the intermediate response since we are going to start over.
-  auth_response_ = HttpResponseInfo();
+  SetAuthResponse(HttpResponseInfo());
 
   int rv = RestartNetworkRequestWithAuth(credentials);
 
   if (rv == ERR_IO_PENDING)
     callback_ = callback;
 
   return rv;
 }
 
 bool HttpCache::Transaction::IsReadyToRestartForAuth() {
@@ skipping 11 matching lines @@
 
   DCHECK(callback_.is_null());
 
   if (!cache_.get())
     return ERR_UNEXPECTED;
 
   // If we have an intermediate auth response at this point, then it means the
   // user wishes to read the network response (the error page).  If there is a
   // previous response in the cache then we should leave it intact.
   if (auth_response_.headers.get() && mode_ != NONE) {
-    UpdateTransactionPattern(PATTERN_NOT_COVERED);
+    UpdateCacheEntryStatus(CacheEntryStatus::ENTRY_OTHER);
     DCHECK(mode_ & WRITE);
     DoneWritingToEntry(mode_ == READ_WRITE);
     mode_ = NONE;
   }
 
   reading_ = true;
   read_buf_ = buf;
   io_buf_len_ = buf_len;
   if (network_trans_) {
     DCHECK(mode_ == WRITE || mode_ == NONE ||
@@ skipping 64 matching lines @@
       // for mode_ to be NONE and entry_ non-NULL with a write entry
       // if StopCaching was called.
       cache_->DoneReadingFromEntry(entry_, this);
       entry_ = NULL;
     }
   }
 }
 
 const HttpResponseInfo* HttpCache::Transaction::GetResponseInfo() const {
   // Null headers means we encountered an error or haven't a response yet
-  if (auth_response_.headers.get())
+  if (auth_response_.headers.get()) {
+    DCHECK_EQ(cache_entry_status_, auth_response_.cache_entry_status)
+        << "These must be in sync via SetResponse and SetAuthResponse.";
     return &auth_response_;
+  }
+  DCHECK_EQ(cache_entry_status_, response_.cache_entry_status)
+      << "These must be in sync via SetResponse and SetAuthResponse.";
   return &response_;
 }
 
 LoadState HttpCache::Transaction::GetLoadState() const {
   LoadState state = GetWriterLoadState();
   if (state != LOAD_STATE_WAITING_FOR_CACHE)
     return state;
 
   if (cache_.get())
     return cache_->GetLoadStateForPendingTransaction(this);
@@ skipping 779 matching lines @@
   //    to be validated and then issue a network request if needed or just read
   //    from the cache if the cache entry is already valid.
   //
   //  o if we are set to UPDATE, then we are handling an externally
   //    conditionalized request (if-modified-since / if-none-match). We check
   //    if the request headers define a validation request.
   //
   int result = ERR_FAILED;
   switch (mode_) {
     case READ:
-      UpdateTransactionPattern(PATTERN_ENTRY_USED);
+      UpdateCacheEntryStatus(CacheEntryStatus::ENTRY_USED);
       result = BeginCacheRead();
       break;
     case READ_WRITE:
       result = BeginPartialCacheValidation();
       break;
     case UPDATE:
       result = BeginExternallyConditionalizedRequest();
       break;
     case WRITE:
     default:
@@ skipping 88 matching lines @@
 
   if (result == OK) {
     next_state_ = STATE_SUCCESSFUL_SEND_REQUEST;
     return OK;
   }
 
   const HttpResponseInfo* response = network_trans_->GetResponseInfo();
   response_.network_accessed = response->network_accessed;
 
   // Do not record requests that have network errors or restarts.
-  UpdateTransactionPattern(PATTERN_NOT_COVERED);
+  UpdateCacheEntryStatus(CacheEntryStatus::ENTRY_OTHER);
   if (IsCertificateError(result)) {
     // If we get a certificate error, then there is a certificate in ssl_info,
     // so GetResponseInfo() should never return NULL here.
     DCHECK(response);
     response_.ssl_info = response->ssl_info;
   } else if (result == ERR_SSL_CLIENT_AUTH_CERT_NEEDED) {
     DCHECK(response);
     response_.cert_request_info = response->cert_request_info;
   } else if (response_.was_cached) {
     DoneWritingToEntry(true);
   }
 
   return result;
 }
 
 // We received the response headers and there is no error.
 int HttpCache::Transaction::DoSuccessfulSendRequest() {
   DCHECK(!new_response_);
   const HttpResponseInfo* new_response = network_trans_->GetResponseInfo();
 
   if (new_response->headers->response_code() == 401 ||
       new_response->headers->response_code() == 407) {
-    auth_response_ = *new_response;
+    SetAuthResponse(*new_response);
     if (!reading_)
       return OK;
 
     // We initiated a second request the caller doesn't know about. We should be
     // able to authenticate this request because we should have authenticated
     // this URL moments ago.
     if (IsReadyToRestartForAuth()) {
       DCHECK(!response_.auth_challenge.get());
       next_state_ = STATE_SEND_REQUEST_COMPLETE;
       // In theory we should check to see if there are new cookies, but there
@@ skipping 14 matching lines @@
     return ERR_CACHE_AUTH_FAILURE_AFTER_READ;
   }
 
   new_response_ = new_response;
   if (!ValidatePartialResponse() && !auth_response_.headers.get()) {
     // Something went wrong with this request and we have to restart it.
     // If we have an authentication response, we are exposed to weird things
     // hapenning if the user cancels the authentication before we receive
     // the new response.
     net_log_.AddEvent(NetLog::TYPE_HTTP_CACHE_RE_SEND_PARTIAL_REQUEST);
-    UpdateTransactionPattern(PATTERN_NOT_COVERED);
-    response_ = HttpResponseInfo();
+    UpdateCacheEntryStatus(CacheEntryStatus::ENTRY_OTHER);
+    SetResponse(HttpResponseInfo());
     ResetNetworkTransaction();
     new_response_ = NULL;
     next_state_ = STATE_SEND_REQUEST;
     return OK;
   }
 
   if (handling_206_ && mode_ == READ_WRITE && !truncated_ && !is_sparse_) {
     // We have stored the full entry, but it changed and the server is
     // sending a range. We have to delete the old entry.
-    UpdateTransactionPattern(PATTERN_NOT_COVERED);
+    UpdateCacheEntryStatus(CacheEntryStatus::ENTRY_OTHER);
     DoneWritingToEntry(false);
   }
 
   if (mode_ == WRITE &&
-      transaction_pattern_ != PATTERN_ENTRY_CANT_CONDITIONALIZE) {
-    UpdateTransactionPattern(PATTERN_ENTRY_NOT_CACHED);
+      cache_entry_status_ != CacheEntryStatus::ENTRY_CANT_CONDITIONALIZE) {
+    UpdateCacheEntryStatus(CacheEntryStatus::ENTRY_NOT_IN_CACHE);
   }
 
   // Invalidate any cached GET with a successful PUT or DELETE.
   if (mode_ == WRITE &&
       (request_->method == "PUT" || request_->method == "DELETE")) {
     if (NonErrorResponse(new_response->headers->response_code())) {
       int ret = cache_->DoomEntry(cache_key_, NULL);
       DCHECK_EQ(OK, ret);
     }
     cache_->DoneWritingToEntry(entry_, true);
     entry_ = NULL;
     mode_ = NONE;
   }
 
   // Invalidate any cached GET with a successful POST.
   if (!(effective_load_flags_ & LOAD_DISABLE_CACHE) &&
       request_->method == "POST" &&
       NonErrorResponse(new_response->headers->response_code())) {
     cache_->DoomMainEntryForUrl(request_->url);
   }
 
   RecordNoStoreHeaderHistogram(request_->load_flags, new_response);
 
   if (new_response_->headers->response_code() == 416 &&
       (request_->method == "GET" || request_->method == "POST")) {
     // If there is an active entry it may be destroyed with this transaction.
-    response_ = *new_response_;
+    SetResponse(*new_response_);
     return OK;
   }
 
   // Are we expecting a response to a conditional query?
   if (mode_ == READ_WRITE || mode_ == UPDATE) {
     if (new_response->headers->response_code() == 304 || handling_206_) {
-      UpdateTransactionPattern(PATTERN_ENTRY_VALIDATED);
+      UpdateCacheEntryStatus(CacheEntryStatus::ENTRY_VALIDATED);
       next_state_ = STATE_UPDATE_CACHED_RESPONSE;
       return OK;
     }
-    UpdateTransactionPattern(PATTERN_ENTRY_UPDATED);
+    UpdateCacheEntryStatus(CacheEntryStatus::ENTRY_UPDATED);
     mode_ = WRITE;
   }
 
   next_state_ = STATE_OVERWRITE_CACHED_RESPONSE;
   return OK;
 }
 
 // We received 304 or 206 and we want to update the cached response headers.
 int HttpCache::Transaction::DoUpdateCachedResponse() {
   next_state_ = STATE_UPDATE_CACHED_RESPONSE_COMPLETE;
@@ skipping 78 matching lines @@
 int HttpCache::Transaction::DoOverwriteCachedResponse() {
   if (mode_ & READ) {
     next_state_ = STATE_PARTIAL_HEADERS_RECEIVED;
     return OK;
   }
 
   // We change the value of Content-Length for partial content.
   if (handling_206_ && partial_)
     partial_->FixContentLength(new_response_->headers.get());
 
-  response_ = *new_response_;
+  SetResponse(*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)) {
@@ skipping 152 matching lines @@
     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_CACHE_READ_DATA,
                                       result);
   }
 
   if (!cache_.get())
     return ERR_UNEXPECTED;
 
   if (partial_) {
     // Partial requests are confusing to report in histograms because they may
     // have multiple underlying requests.
-    UpdateTransactionPattern(PATTERN_NOT_COVERED);
+    UpdateCacheEntryStatus(CacheEntryStatus::ENTRY_OTHER);
     return DoPartialCacheReadCompleted(result);
   }
 
   if (result > 0) {
     read_offset_ += result;
   } else if (result == 0) {  // End of file.
     RecordHistograms();
     cache_->DoneReadingFromEntry(entry_, this);
     entry_ = NULL;
   } else {
@@ skipping 148 matching lines @@
 
   // 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)) {
-    UpdateTransactionPattern(PATTERN_NOT_COVERED);
+    UpdateCacheEntryStatus(CacheEntryStatus::ENTRY_OTHER);
     partial_.reset(new PartialData);
     if (request_->method == "GET" && partial_->Init(request_->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_));
       custom_request_->extra_headers.RemoveHeader(HttpRequestHeaders::kRange);
       request_ = custom_request_.get();
       partial_->SetHeaders(custom_request_->extra_headers);
     } else {
       // The range is invalid or we cannot handle it properly.
@@ skipping 72 matching lines @@
 
     // Bail out!
     next_state_ = STATE_SEND_REQUEST;
     mode_ = NONE;
     return OK;
   }
 
   if (truncated_) {
     // Truncated entries can cause partial gets, so we shouldn't record this
     // load in histograms.
-    UpdateTransactionPattern(PATTERN_NOT_COVERED);
+    UpdateCacheEntryStatus(CacheEntryStatus::ENTRY_OTHER);
     skip_validation = !partial_->initial_validation();
   }
 
   if (partial_ && (is_sparse_ || truncated_) &&
       (!partial_->IsCurrentRangeCached() || invalid_range_)) {
     // Force revalidation for sparse or truncated entries. Note that we don't
     // want to ignore the regular validation logic just because a byte range was
     // part of the request.
     skip_validation = false;
   }
 
   if (skip_validation) {
-    UpdateTransactionPattern(PATTERN_ENTRY_USED);
+    UpdateCacheEntryStatus(CacheEntryStatus::ENTRY_USED);
     return SetupEntryForRead();
   } else {
     // Make the network request conditional, to see if we may reuse our cached
     // response.  If we cannot do so, then we just resort to a normal fetch.
     // Our mode remains READ_WRITE for a conditional request.  Even if the
     // conditionalization fails, we don't switch to WRITE mode until we
     // know we won't be falling back to using the cache entry in the
     // LOAD_FROM_CACHE_IF_OFFLINE case.
     if (!ConditionalizeRequest()) {
       couldnt_conditionalize_request_ = true;
-      UpdateTransactionPattern(PATTERN_ENTRY_CANT_CONDITIONALIZE);
+      UpdateCacheEntryStatus(CacheEntryStatus::ENTRY_CANT_CONDITIONALIZE);
       if (partial_)
         return DoRestartPartialRequest();
 
       DCHECK_NE(206, response_.headers->response_code());
     }
     next_state_ = STATE_SEND_REQUEST;
   }
   return OK;
 }
 
 int HttpCache::Transaction::BeginPartialCacheValidation() {
   DCHECK_EQ(mode_, READ_WRITE);
 
   if (response_.headers->response_code() != 206 && !partial_ && !truncated_)
     return BeginCacheValidation();
 
   // Partial requests should not be recorded in histograms.
-  UpdateTransactionPattern(PATTERN_NOT_COVERED);
+  UpdateCacheEntryStatus(CacheEntryStatus::ENTRY_OTHER);
   if (request_->method == "HEAD")
     return BeginCacheValidation();
 
   if (!range_requested_) {
     // The request is not for a range, but we have stored just ranges.
 
     partial_.reset(new PartialData());
     partial_->SetHeaders(request_->extra_headers);
     if (!custom_request_.get()) {
       custom_request_.reset(new HttpRequestInfo(*request_));
@@ skipping 37 matching lines @@
     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_.values[i]) {
       // The externally conditionalized request is not a validation request
       // for our existing cache entry. Proceed with caching disabled.
-      UpdateTransactionPattern(PATTERN_NOT_COVERED);
+      UpdateCacheEntryStatus(CacheEntryStatus::ENTRY_OTHER);
       DoneWritingToEntry(true);
     }
   }
 
   // TODO(ricea): This calculation is expensive to perform just to collect
   // statistics. Either remove it or use the result, depending on the result of
   // the experiment.
   ExternallyConditionalizedType type =
       EXTERNALLY_CONDITIONALIZED_CACHE_USABLE;
   if (mode_ == NONE)
@@ skipping 238 matching lines @@
     // server is ok with the request, delete the entry, otherwise just ignore
     // this request
     DCHECK(!reading_);
     if (partial_response || response_code == 200) {
       DoomPartialEntry(true);
       mode_ = NONE;
     } else {
       if (response_code == 304) {
         // Change the response code of the request to be 416 (Requested range
         // not satisfiable).
-        response_ = *new_response_;
+        SetResponse(*new_response_);
         partial_->FixResponseHeaders(response_.headers.get(), false);
       }
       IgnoreRangeRequest();
     }
     return true;
   }
 
   if (!partial_) {
     // We are not expecting 206 but we may have one.
     if (partial_response)
@@ skipping 39 matching lines @@
     }
 
     // 304 is not expected here, but we'll spare the entry (unless it was
     // truncated).
     if (truncated_)
       failure = true;
   }
 
   if (failure) {
     // We cannot truncate this entry, it has to be deleted.
-    UpdateTransactionPattern(PATTERN_NOT_COVERED);
+    UpdateCacheEntryStatus(CacheEntryStatus::ENTRY_OTHER);
     mode_ = NONE;
     if (is_sparse_ || truncated_) {
       // There was something cached to start with, either sparsed data (206), or
       // a truncated 200, which means that we probably modified the request,
       // adding a byte range or modifying the range requested by the caller.
       if (!reading_ && !partial_->IsLastRange()) {
         // We have not returned anything to the caller yet so it should be safe
         // to issue another network request, this time without us messing up the
         // headers.
         ResetPartialState(true);
         return false;
       }
       LOG(WARNING) << "Failed to revalidate partial entry";
     }
     DoomPartialEntry(true);
     return true;
   }
 
   IgnoreRangeRequest();
   return true;
 }
 
 void HttpCache::Transaction::IgnoreRangeRequest() {
   // We have a problem. We may or may not be reading already (in which case we
   // returned the headers), but we'll just pretend that this request is not
   // using the cache and see what happens. Most likely this is the first
   // response from the server (it's not changing its mind midway, right?).
-  UpdateTransactionPattern(PATTERN_NOT_COVERED);
+  UpdateCacheEntryStatus(CacheEntryStatus::ENTRY_OTHER);
   if (mode_ & WRITE)
     DoneWritingToEntry(mode_ != WRITE);
   else if (mode_ & READ && entry_)
     cache_->DoneReadingFromEntry(entry_, this);
 
   partial_.reset(NULL);
   entry_ = NULL;
   mode_ = NONE;
 }
 
@@ skipping 253 matching lines @@
   // PartialData::ResponseHeadersOK().
   if (response_.headers->GetContentLength() <= 0 ||
       response_.headers->HasHeaderValue("Accept-Ranges", "none") ||
       !response_.headers->HasStrongValidators()) {
     return false;
   }
 
   return true;
 }
 
-void HttpCache::Transaction::UpdateTransactionPattern(
-    TransactionPattern new_transaction_pattern) {
-  if (transaction_pattern_ == PATTERN_NOT_COVERED)
+void HttpCache::Transaction::SetResponse(const HttpResponseInfo& response) {
+  response_ = response;
+  SyncCacheEntryStatusToResponse();
+}
+
+void HttpCache::Transaction::SetAuthResponse(
+    const HttpResponseInfo& auth_response) {
+  auth_response_ = auth_response;
+  SyncCacheEntryStatusToResponse();
+}
+
+void HttpCache::Transaction::UpdateCacheEntryStatus(
+    CacheEntryStatus new_cache_entry_status) {
+  DCHECK_NE(CacheEntryStatus::ENTRY_UNDEFINED, new_cache_entry_status);
+  if (cache_entry_status_ == CacheEntryStatus::ENTRY_OTHER)
     return;
-  DCHECK(transaction_pattern_ == PATTERN_UNDEFINED ||
-         new_transaction_pattern == PATTERN_NOT_COVERED);
-  transaction_pattern_ = new_transaction_pattern;
+  DCHECK(cache_entry_status_ == CacheEntryStatus::ENTRY_UNDEFINED ||
+         new_cache_entry_status == CacheEntryStatus::ENTRY_OTHER);
+  cache_entry_status_ = new_cache_entry_status;
+  SyncCacheEntryStatusToResponse();
+}
+
+void HttpCache::Transaction::SyncCacheEntryStatusToResponse() {
+  if (cache_entry_status_ == CacheEntryStatus::ENTRY_UNDEFINED)
+    return;
+  response_.cache_entry_status = cache_entry_status_;
+  if (auth_response_.headers.get()) {
+    auth_response_.cache_entry_status = cache_entry_status_;
+  }
 }
 
 void HttpCache::Transaction::RecordHistograms() {
-  DCHECK_NE(PATTERN_UNDEFINED, transaction_pattern_);
+  DCHECK_NE(CacheEntryStatus::ENTRY_UNDEFINED, cache_entry_status_);
   if (!cache_.get() || !cache_->GetCurrentBackend() ||
       cache_->GetCurrentBackend()->GetCacheType() != DISK_CACHE ||
       cache_->mode() != NORMAL || request_->method != "GET") {
     return;
   }
 
-  bool validation_request = transaction_pattern_ == PATTERN_ENTRY_VALIDATED ||
-                            transaction_pattern_ == PATTERN_ENTRY_UPDATED;
+  bool validation_request =
+      cache_entry_status_ == CacheEntryStatus::ENTRY_VALIDATED ||
+      cache_entry_status_ == CacheEntryStatus::ENTRY_UPDATED;
 
   bool stale_request =
       validation_cause_ == VALIDATION_CAUSE_STALE &&
       (validation_request ||
-       transaction_pattern_ == PATTERN_ENTRY_CANT_CONDITIONALIZE);
+       cache_entry_status_ == CacheEntryStatus::ENTRY_CANT_CONDITIONALIZE);
   int64_t freshness_periods_since_last_used = 0;
 
   if (stale_request) {
     // For stale entries, record how many freshness periods have elapsed since
     // the entry was last used.
     DCHECK(!open_entry_last_used_.is_null());
     DCHECK(!stale_entry_freshness_.is_zero());
     base::TimeDelta time_since_use = base::Time::Now() - open_entry_last_used_;
     freshness_periods_since_last_used =
         (time_since_use * 1000) / stale_entry_freshness_;
 
     UMA_HISTOGRAM_COUNTS("HttpCache.StaleEntry.FreshnessPeriodsSinceLastUsed",
                          freshness_periods_since_last_used);
 
     if (validation_request) {
       int64_t age_in_freshness_periods =
           (stale_entry_age_ * 100) / stale_entry_freshness_;
-      if (transaction_pattern_ == PATTERN_ENTRY_VALIDATED) {
+      if (cache_entry_status_ == CacheEntryStatus::ENTRY_VALIDATED) {
         UMA_HISTOGRAM_COUNTS("HttpCache.StaleEntry.Validated.Age",
                              stale_entry_age_.InSeconds());
         UMA_HISTOGRAM_COUNTS(
             "HttpCache.StaleEntry.Validated.AgeInFreshnessPeriods",
             age_in_freshness_periods);
 
       } else {
         UMA_HISTOGRAM_COUNTS("HttpCache.StaleEntry.Updated.Age",
                              stale_entry_age_.InSeconds());
         UMA_HISTOGRAM_COUNTS(
             "HttpCache.StaleEntry.Updated.AgeInFreshnessPeriods",
             age_in_freshness_periods);
       }
     }
   }
 
   std::string mime_type;
   HttpResponseHeaders* response_headers = GetResponseInfo()->headers.get();
   if (response_headers && response_headers->GetMimeType(&mime_type)) {
     // Record the cache pattern by resource type. The type is inferred by
     // response header mime type, which could be incorrect, so this is just an
     // estimate.
     if (mime_type == "text/html" && (request_->load_flags & LOAD_MAIN_FRAME)) {
       UMA_HISTOGRAM_ENUMERATION("HttpCache.Pattern.MainFrameHTML",
-                                transaction_pattern_, PATTERN_MAX);
+                                cache_entry_status_,
+                                CacheEntryStatus::ENTRY_MAX);
       if (validation_request) {
         UMA_HISTOGRAM_ENUMERATION("HttpCache.ValidationCause.MainFrameHTML",
                                   validation_cause_, VALIDATION_CAUSE_MAX);
       }
       if (stale_request) {
         UMA_HISTOGRAM_COUNTS(
             "HttpCache.StaleEntry.FreshnessPeriodsSinceLastUsed.MainFrameHTML",
             freshness_periods_since_last_used);
       }
     } else if (mime_type == "text/html") {
       UMA_HISTOGRAM_ENUMERATION("HttpCache.Pattern.NonMainFrameHTML",
-                                transaction_pattern_, PATTERN_MAX);
+                                cache_entry_status_,
+                                CacheEntryStatus::ENTRY_MAX);
       if (validation_request) {
         UMA_HISTOGRAM_ENUMERATION("HttpCache.ValidationCause.NonMainFrameHTML",
                                   validation_cause_, VALIDATION_CAUSE_MAX);
       }
       if (stale_request) {
         UMA_HISTOGRAM_COUNTS(
             "HttpCache.StaleEntry.FreshnessPeriodsSinceLastUsed."
             "NonMainFrameHTML",
             freshness_periods_since_last_used);
       }
     } else if (mime_type == "text/css") {
-      UMA_HISTOGRAM_ENUMERATION("HttpCache.Pattern.CSS", transaction_pattern_,
-                                PATTERN_MAX);
+      UMA_HISTOGRAM_ENUMERATION("HttpCache.Pattern.CSS", cache_entry_status_,
+                                CacheEntryStatus::ENTRY_MAX);
       if (validation_request) {
         UMA_HISTOGRAM_ENUMERATION("HttpCache.ValidationCause.CSS",
                                   validation_cause_, VALIDATION_CAUSE_MAX);
       }
       if (stale_request) {
         UMA_HISTOGRAM_COUNTS(
             "HttpCache.StaleEntry.FreshnessPeriodsSinceLastUsed.CSS",
             freshness_periods_since_last_used);
       }
     } else if (base::StartsWith(mime_type, "image/",
                                 base::CompareCase::SENSITIVE)) {
       int64_t content_length = response_headers->GetContentLength();
       if (content_length >= 0 && content_length < 100) {
         UMA_HISTOGRAM_ENUMERATION("HttpCache.Pattern.TinyImage",
-                                  transaction_pattern_, PATTERN_MAX);
+                                  cache_entry_status_,
+                                  CacheEntryStatus::ENTRY_MAX);
         if (validation_request) {
           UMA_HISTOGRAM_ENUMERATION("HttpCache.ValidationCause.TinyImage",
                                     validation_cause_, VALIDATION_CAUSE_MAX);
         }
         if (stale_request) {
           UMA_HISTOGRAM_COUNTS(
               "HttpCache.StaleEntry.FreshnessPeriodsSinceLastUsed.TinyImage",
               freshness_periods_since_last_used);
         }
       } else if (content_length >= 100) {
         UMA_HISTOGRAM_ENUMERATION("HttpCache.Pattern.NonTinyImage",
-                                  transaction_pattern_, PATTERN_MAX);
+                                  cache_entry_status_,
+                                  CacheEntryStatus::ENTRY_MAX);
         if (validation_request) {
           UMA_HISTOGRAM_ENUMERATION("HttpCache.ValidationCause.NonTinyImage",
                                     validation_cause_, VALIDATION_CAUSE_MAX);
         }
         if (stale_request) {
           UMA_HISTOGRAM_COUNTS(
               "HttpCache.StaleEntry.FreshnessPeriodsSinceLastUsed.NonTinyImage",
               freshness_periods_since_last_used);
         }
       }
-      UMA_HISTOGRAM_ENUMERATION("HttpCache.Pattern.Image", transaction_pattern_,
-                                PATTERN_MAX);
+      UMA_HISTOGRAM_ENUMERATION("HttpCache.Pattern.Image", cache_entry_status_,
+                                CacheEntryStatus::ENTRY_MAX);
       if (validation_request) {
         UMA_HISTOGRAM_ENUMERATION("HttpCache.ValidationCause.Image",
                                   validation_cause_, VALIDATION_CAUSE_MAX);
       }
       if (stale_request) {
         UMA_HISTOGRAM_COUNTS(
             "HttpCache.StaleEntry.FreshnessPeriodsSinceLastUsed.Image",
             freshness_periods_since_last_used);
       }
     } else if (base::EndsWith(mime_type, "javascript",
                               base::CompareCase::SENSITIVE) ||
                base::EndsWith(mime_type, "ecmascript",
                               base::CompareCase::SENSITIVE)) {
       UMA_HISTOGRAM_ENUMERATION("HttpCache.Pattern.JavaScript",
-                                transaction_pattern_, PATTERN_MAX);
+                                cache_entry_status_,
+                                CacheEntryStatus::ENTRY_MAX);
       if (validation_request) {
         UMA_HISTOGRAM_ENUMERATION("HttpCache.ValidationCause.JavaScript",
                                   validation_cause_, VALIDATION_CAUSE_MAX);
       }
       if (stale_request) {
         UMA_HISTOGRAM_COUNTS(
             "HttpCache.StaleEntry.FreshnessPeriodsSinceLastUsed.JavaScript",
             freshness_periods_since_last_used);
       }
     } else if (mime_type.find("font") != std::string::npos) {
-      UMA_HISTOGRAM_ENUMERATION("HttpCache.Pattern.Font", transaction_pattern_,
-                                PATTERN_MAX);
+      UMA_HISTOGRAM_ENUMERATION("HttpCache.Pattern.Font", cache_entry_status_,
+                                CacheEntryStatus::ENTRY_MAX);
       if (validation_request) {
         UMA_HISTOGRAM_ENUMERATION("HttpCache.ValidationCause.Font",
                                   validation_cause_, VALIDATION_CAUSE_MAX);
       }
       if (stale_request) {
         UMA_HISTOGRAM_COUNTS(
             "HttpCache.StaleEntry.FreshnessPeriodsSinceLastUsed.Font",
             freshness_periods_since_last_used);
       }
     }
   }
 
-  UMA_HISTOGRAM_ENUMERATION("HttpCache.Pattern", transaction_pattern_,
-                            PATTERN_MAX);
+  UMA_HISTOGRAM_ENUMERATION("HttpCache.Pattern", cache_entry_status_,
+                            CacheEntryStatus::ENTRY_MAX);
 
   if (validation_request) {
     UMA_HISTOGRAM_ENUMERATION("HttpCache.ValidationCause", validation_cause_,
                               VALIDATION_CAUSE_MAX);
   }
 
-  if (transaction_pattern_ == PATTERN_ENTRY_CANT_CONDITIONALIZE) {
+  if (cache_entry_status_ == CacheEntryStatus::ENTRY_CANT_CONDITIONALIZE) {
     UMA_HISTOGRAM_ENUMERATION("HttpCache.CantConditionalizeCause",
                               validation_cause_, VALIDATION_CAUSE_MAX);
   }
 
-  if (transaction_pattern_ == PATTERN_NOT_COVERED)
+  if (cache_entry_status_ == CacheEntryStatus::ENTRY_OTHER)
     return;
   DCHECK(!range_requested_);
   DCHECK(!first_cache_access_since_.is_null());
 
   TimeDelta total_time = base::TimeTicks::Now() - first_cache_access_since_;
 
   UMA_HISTOGRAM_TIMES("HttpCache.AccessToDone", total_time);
 
   bool did_send_request = !send_request_since_.is_null();
   DCHECK(
       (did_send_request &&
-       (transaction_pattern_ == PATTERN_ENTRY_NOT_CACHED ||
-        transaction_pattern_ == PATTERN_ENTRY_VALIDATED ||
-        transaction_pattern_ == PATTERN_ENTRY_UPDATED ||
-        transaction_pattern_ == PATTERN_ENTRY_CANT_CONDITIONALIZE)) ||
-      (!did_send_request && transaction_pattern_ == PATTERN_ENTRY_USED));
+       (cache_entry_status_ == CacheEntryStatus::ENTRY_NOT_IN_CACHE ||
+        cache_entry_status_ == CacheEntryStatus::ENTRY_VALIDATED ||
+        cache_entry_status_ == CacheEntryStatus::ENTRY_UPDATED ||
+        cache_entry_status_ == CacheEntryStatus::ENTRY_CANT_CONDITIONALIZE)) ||
+      (!did_send_request &&
+       cache_entry_status_ == CacheEntryStatus::ENTRY_USED));
 
   if (!did_send_request) {
-    DCHECK(transaction_pattern_ == PATTERN_ENTRY_USED);
+    DCHECK(cache_entry_status_ == CacheEntryStatus::ENTRY_USED);
     UMA_HISTOGRAM_TIMES("HttpCache.AccessToDone.Used", total_time);
     return;
   }
 
   TimeDelta before_send_time = send_request_since_ - first_cache_access_since_;
   int64_t before_send_percent = (total_time.ToInternalValue() == 0)
                                     ? 0
                                     : before_send_time * 100 / total_time;
   DCHECK_GE(before_send_percent, 0);
   DCHECK_LE(before_send_percent, 100);
   base::HistogramBase::Sample before_send_sample =
       static_cast<base::HistogramBase::Sample>(before_send_percent);
 
   UMA_HISTOGRAM_TIMES("HttpCache.AccessToDone.SentRequest", total_time);
   UMA_HISTOGRAM_TIMES("HttpCache.BeforeSend", before_send_time);
   UMA_HISTOGRAM_PERCENTAGE("HttpCache.PercentBeforeSend", before_send_sample);
 
   // TODO(gavinp): Remove or minimize these histograms, particularly the ones
   // below this comment after we have received initial data.
-  switch (transaction_pattern_) {
-    case PATTERN_ENTRY_CANT_CONDITIONALIZE: {
+  switch (cache_entry_status_) {
+    case CacheEntryStatus::ENTRY_CANT_CONDITIONALIZE: {
       UMA_HISTOGRAM_TIMES("HttpCache.BeforeSend.CantConditionalize",
                           before_send_time);
       UMA_HISTOGRAM_PERCENTAGE("HttpCache.PercentBeforeSend.CantConditionalize",
                                before_send_sample);
       break;
     }
-    case PATTERN_ENTRY_NOT_CACHED: {
+    case CacheEntryStatus::ENTRY_NOT_IN_CACHE: {
       UMA_HISTOGRAM_TIMES("HttpCache.BeforeSend.NotCached", before_send_time);
       UMA_HISTOGRAM_PERCENTAGE("HttpCache.PercentBeforeSend.NotCached",
                                before_send_sample);
       break;
     }
-    case PATTERN_ENTRY_VALIDATED: {
+    case CacheEntryStatus::ENTRY_VALIDATED: {
       UMA_HISTOGRAM_TIMES("HttpCache.BeforeSend.Validated", before_send_time);
       UMA_HISTOGRAM_PERCENTAGE("HttpCache.PercentBeforeSend.Validated",
                                before_send_sample);
       break;
     }
-    case PATTERN_ENTRY_UPDATED: {
+    case CacheEntryStatus::ENTRY_UPDATED: {
       UMA_HISTOGRAM_TIMES("HttpCache.BeforeSend.Updated", before_send_time);
       UMA_HISTOGRAM_PERCENTAGE("HttpCache.PercentBeforeSend.Updated",
                                before_send_sample);
       break;
     }
     default:
       NOTREACHED();
   }
 }
 
 void HttpCache::Transaction::OnIOComplete(int result) {
   DoLoop(result);
 }
 
 }  // namespace net