Remove HTTP cache Record/Playback support

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 1403 matching lines @@
     mode_ = WRITE;
     next_state_ = STATE_CREATE_ENTRY;
     return OK;
   }
   if (mode_ == UPDATE) {
     // There is no cache entry to update; proceed without caching.
     mode_ = NONE;
     next_state_ = STATE_SEND_REQUEST;
     return OK;
   }
-  if (cache_->mode() == PLAYBACK)
-    DVLOG(1) << "Playback Cache Miss: " << request_->url;
 
   // The entry does not exist, and we are not permitted to create a new entry,
   // so we must fail.
   return ERR_CACHE_MISS;
 }
 
 int HttpCache::Transaction::DoCreateEntry() {
   // TODO(vadimt): Remove ScopedTracker below once crbug.com/422516 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
@@ skipping 814 matching lines @@
   }
   DCHECK_EQ(0, dist_from_root);
 }
 
 void HttpCache::Transaction::SetRequest(const BoundNetLog& net_log,
                                         const HttpRequestInfo* request) {
   net_log_ = net_log;
   request_ = request;
   effective_load_flags_ = request_->load_flags;
 
-  switch (cache_->mode()) {
-    case NORMAL:
-      break;
-    case RECORD:
-      // When in record mode, we want to NEVER load from the cache.
-      // The reason for this is because we save the Set-Cookie headers
-      // (intentionally).  If we read from the cache, we replay them
-      // prematurely.
-      effective_load_flags_ |= LOAD_BYPASS_CACHE;
-      break;
-    case PLAYBACK:
-      // When in playback mode, we want to load exclusively from the cache.
-      effective_load_flags_ |= LOAD_ONLY_FROM_CACHE;
-      break;
-    case DISABLE:
-      effective_load_flags_ |= LOAD_DISABLE_CACHE;
-      break;
-  }
+  if (cache_->mode() == DISABLE)
+    effective_load_flags_ |= LOAD_DISABLE_CACHE;
 
   // Some headers imply load flags.  The order here is significant.
   //
   //   LOAD_DISABLE_CACHE   : no cache read or write
   //   LOAD_BYPASS_CACHE    : no cache read
   //   LOAD_VALIDATE_CACHE  : no cache read unless validation
   //
   // The former modes trump latter modes, so if we find a matching header we
   // can stop iterating kSpecialHeaders.
   //
@@ skipping 78 matching lines @@
     }
   }
 }
 
 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_.get())
     return true;
 
-  // When using the record/playback modes, we always use the cache
-  // and we never pass through.
-  if (cache_->mode() == RECORD || cache_->mode() == PLAYBACK)
-    return false;
-
   if (effective_load_flags_ & LOAD_DISABLE_CACHE)
     return true;
 
   if (request_->method == "GET" || request_->method == "HEAD")
     return false;
 
   if (request_->method == "POST" && request_->upload_data_stream &&
       request_->upload_data_stream->identifier()) {
     return false;
   }
@@ skipping 223 matching lines @@
   if (rv != ERR_IO_PENDING)
     return DoLoop(rv);
   return rv;
 }
 
 ValidationType HttpCache::Transaction::RequiresValidation() {
   // TODO(darin): need to do more work here:
   //  - make sure we have a matching request method
   //  - watch out for cached responses that depend on authentication
 
-  // In playback mode, nothing requires validation.
-  if (cache_->mode() == net::HttpCache::PLAYBACK)
-    return VALIDATION_NONE;
-
   if (response_.vary_data.is_valid() &&
       !response_.vary_data.MatchesRequest(*request_,
                                           *response_.headers.get())) {
     vary_mismatch_ = true;
     return VALIDATION_SYNCHRONOUS;
   }
 
   if (effective_load_flags_ & LOAD_PREFERRING_CACHE)
     return VALIDATION_NONE;
 
@@ skipping 341 matching lines @@
     rv = partial_->CacheWrite(entry_->disk_entry, data, data_len, callback);
   }
   return rv;
 }
 
 int HttpCache::Transaction::WriteResponseInfoToEntry(bool truncated) {
   next_state_ = STATE_CACHE_WRITE_RESPONSE_COMPLETE;
   if (!entry_)
     return OK;
 
-  // Do not cache no-store content (unless we are record mode).  Do not cache
-  // content with cert errors either.  This is to prevent not reporting net
-  // errors when loading a resource from the cache.  When we load a page over
-  // HTTPS with a cert error we show an SSL blocking page.  If the user clicks
-  // proceed we reload the resource ignoring the errors.  The loaded resource
-  // is then cached.  If that resource is subsequently loaded from the cache,
-  // no net error is reported (even though the cert status contains the actual
-  // errors) and no SSL blocking page is shown.  An alternative would be to
-  // reverse-map the cert status to a net error and replay the net error.
-  if ((cache_->mode() != RECORD &&
-       response_.headers->HasHeaderValue("cache-control", "no-store")) ||
+  // Do not cache no-store content.  Do not cache content with cert errors
+  // either.  This is to prevent not reporting net errors when loading a
+  // resource from the cache.  When we load a page over HTTPS with a cert error
+  // we show an SSL blocking page.  If the user clicks proceed we reload the
+  // resource ignoring the errors.  The loaded resource is then cached.  If that
+  // resource is subsequently loaded from the cache, no net error is reported
+  // (even though the cert status contains the actual errors) and no SSL
+  // blocking page is shown.  An alternative would be to reverse-map the cert
+  // status to a net error and replay the net error.
+  if ((response_.headers->HasHeaderValue("cache-control", "no-store")) ||
       net::IsCertStatusError(response_.ssl_info.cert_status)) {
     DoneWritingToEntry(false);
     if (net_log_.IsLogging())
       net_log_.EndEvent(NetLog::TYPE_HTTP_CACHE_WRITE_INFO);
     return OK;
   }
 
   // cert_cache() will be null if the CertCacheTrial field trial is disabled.
   if (cache_->cert_cache() && response_.ssl_info.is_valid())
     WriteCertChain();
 
-  // When writing headers, we normally only write the non-transient
-  // headers; when in record mode, record everything.
-  bool skip_transient_headers = (cache_->mode() != RECORD);
-
   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();
   return entry_->disk_entry->WriteData(kResponseInfoIndex, 0, data.get(),
                                        io_buf_len_, io_callback_, true);
 }
 
 int HttpCache::Transaction::AppendResponseDataToEntry(
@@ skipping 251 matching lines @@
 
 void HttpCache::Transaction::OnIOComplete(int result) {
   // TODO(vadimt): Remove ScopedTracker below once crbug.com/422516 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION("422516 Transaction::OnIOComplete"));
 
   DoLoop(result);
 }
 
 }  // namespace net