net/http/http_cache_transaction.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/http/http_cache_transaction.h"
   6
   7 #include "build/build_config.h"  // For OS_POSIX
   8
   9 #if defined(OS_POSIX)
  10 #include <unistd.h>
  11 #endif
  12
  13 #include <algorithm>
  14 #include <string>
  15
  16 #include "base/bind.h"
  17 #include "base/callback_helpers.h"
  18 #include "base/compiler_specific.h"
  19 #include "base/format_macros.h"
  20 #include "base/location.h"
  21 #include "base/metrics/histogram_macros.h"
  22 #include "base/metrics/sparse_histogram.h"
  23 #include "base/profiler/scoped_tracker.h"
  24 #include "base/single_thread_task_runner.h"
  25 #include "base/strings/string_number_conversions.h"  // For HexEncode.
  26 #include "base/strings/string_piece.h"
  27 #include "base/strings/string_util.h"  // For LowerCaseEqualsASCII.
  28 #include "base/strings/stringprintf.h"
  29 #include "base/thread_task_runner_handle.h"
  30 #include "base/time/clock.h"
  31 #include "base/values.h"
  32 #include "net/base/auth.h"
  33 #include "net/base/load_flags.h"
  34 #include "net/base/load_timing_info.h"
  35 #include "net/base/net_errors.h"
  36 #include "net/base/upload_data_stream.h"
  37 #include "net/cert/cert_status_flags.h"
  38 #include "net/cert/x509_certificate.h"
  39 #include "net/disk_cache/disk_cache.h"
  40 #include "net/http/disk_based_cert_cache.h"
  41 #include "net/http/http_network_session.h"
  42 #include "net/http/http_request_info.h"
  43 #include "net/http/http_util.h"
  44 #include "net/ssl/ssl_cert_request_info.h"
  45 #include "net/ssl/ssl_config_service.h"
  46
  47 using base::Time;
  48 using base::TimeDelta;
  49 using base::TimeTicks;
  50
  51 namespace net {
  52
  53 namespace {
  54
  55 // TODO(ricea): Move this to HttpResponseHeaders once it is standardised.
  56 static const char kFreshnessHeader[] = "Resource-Freshness";
  57
  58 // Stores data relevant to the statistics of writing and reading entire
  59 // certificate chains using DiskBasedCertCache. |num_pending_ops| is the number
  60 // of certificates in the chain that have pending operations in the
  61 // DiskBasedCertCache. |start_time| is the time that the read and write
  62 // commands began being issued to the DiskBasedCertCache.
  63 // TODO(brandonsalmon): Remove this when it is no longer necessary to
  64 // collect data.
  65 class SharedChainData : public base::RefCounted<SharedChainData> {
  66  public:
  67   SharedChainData(int num_ops, TimeTicks start)
  68       : num_pending_ops(num_ops), start_time(start) {}
  69
  70   int num_pending_ops;
  71   TimeTicks start_time;
  72
  73  private:
  74   friend class base::RefCounted<SharedChainData>;
  75   ~SharedChainData() {}
  76   DISALLOW_COPY_AND_ASSIGN(SharedChainData);
  77 };
  78
  79 // Used to obtain a cache entry key for an OSCertHandle.
  80 // TODO(brandonsalmon): Remove this when cache keys are stored
  81 // and no longer have to be recomputed to retrieve the OSCertHandle
  82 // from the disk.
  83 std::string GetCacheKeyForCert(X509Certificate::OSCertHandle cert_handle) {
  84   SHA1HashValue fingerprint =
  85       X509Certificate::CalculateFingerprint(cert_handle);
  86
  87   return "cert:" +
  88          base::HexEncode(fingerprint.data, arraysize(fingerprint.data));
  89 }
  90
  91 // |dist_from_root| indicates the position of the read certificate in the
  92 // certificate chain, 0 indicating it is the root. |is_leaf| indicates
  93 // whether or not the read certificate was the leaf of the chain.
  94 // |shared_chain_data| contains data shared by each certificate in
  95 // the chain.
  96 void OnCertReadIOComplete(
  97     int dist_from_root,
  98     bool is_leaf,
  99     const scoped_refptr<SharedChainData>& shared_chain_data,
 100     X509Certificate::OSCertHandle cert_handle) {
 101   // If |num_pending_ops| is one, this was the last pending read operation
 102   // for this chain of certificates. The total time used to read the chain
 103   // can be calculated by subtracting the starting time from Now().
 104   shared_chain_data->num_pending_ops--;
 105   if (!shared_chain_data->num_pending_ops) {
 106     const TimeDelta read_chain_wait =
 107         TimeTicks::Now() - shared_chain_data->start_time;
 108     UMA_HISTOGRAM_CUSTOM_TIMES("DiskBasedCertCache.ChainReadTime",
 109                                read_chain_wait,
 110                                base::TimeDelta::FromMilliseconds(1),
 111                                base::TimeDelta::FromMinutes(10),
 112                                50);
 113   }
 114
 115   bool success = (cert_handle != NULL);
 116   if (is_leaf)
 117     UMA_HISTOGRAM_BOOLEAN("DiskBasedCertCache.CertIoReadSuccessLeaf", success);
 118
 119   if (success)
 120     UMA_HISTOGRAM_CUSTOM_COUNTS(
 121         "DiskBasedCertCache.CertIoReadSuccess", dist_from_root, 0, 10, 7);
 122   else
 123     UMA_HISTOGRAM_CUSTOM_COUNTS(
 124         "DiskBasedCertCache.CertIoReadFailure", dist_from_root, 0, 10, 7);
 125 }
 126
 127 // |dist_from_root| indicates the position of the written certificate in the
 128 // certificate chain, 0 indicating it is the root. |is_leaf| indicates
 129 // whether or not the written certificate was the leaf of the chain.
 130 // |shared_chain_data| contains data shared by each certificate in
 131 // the chain.
 132 void OnCertWriteIOComplete(
 133     int dist_from_root,
 134     bool is_leaf,
 135     const scoped_refptr<SharedChainData>& shared_chain_data,
 136     const std::string& key) {
 137   // If |num_pending_ops| is one, this was the last pending write operation
 138   // for this chain of certificates. The total time used to write the chain
 139   // can be calculated by subtracting the starting time from Now().
 140   shared_chain_data->num_pending_ops--;
 141   if (!shared_chain_data->num_pending_ops) {
 142     const TimeDelta write_chain_wait =
 143         TimeTicks::Now() - shared_chain_data->start_time;
 144     UMA_HISTOGRAM_CUSTOM_TIMES("DiskBasedCertCache.ChainWriteTime",
 145                                write_chain_wait,
 146                                base::TimeDelta::FromMilliseconds(1),
 147                                base::TimeDelta::FromMinutes(10),
 148                                50);
 149   }
 150
 151   bool success = !key.empty();
 152   if (is_leaf)
 153     UMA_HISTOGRAM_BOOLEAN("DiskBasedCertCache.CertIoWriteSuccessLeaf", success);
 154
 155   if (success)
 156     UMA_HISTOGRAM_CUSTOM_COUNTS(
 157         "DiskBasedCertCache.CertIoWriteSuccess", dist_from_root, 0, 10, 7);
 158   else
 159     UMA_HISTOGRAM_CUSTOM_COUNTS(
 160         "DiskBasedCertCache.CertIoWriteFailure", dist_from_root, 0, 10, 7);
 161 }
 162
 163 // From http://tools.ietf.org/html/draft-ietf-httpbis-p6-cache-21#section-6
 164 //      a "non-error response" is one with a 2xx (Successful) or 3xx
 165 //      (Redirection) status code.
 166 bool NonErrorResponse(int status_code) {
 167   int status_code_range = status_code / 100;
 168   return status_code_range == 2 || status_code_range == 3;
 169 }
 170
 171 void RecordNoStoreHeaderHistogram(int load_flags,
 172                                   const HttpResponseInfo* response) {
 173   if (load_flags & LOAD_MAIN_FRAME) {
 174     UMA_HISTOGRAM_BOOLEAN(
 175         "Net.MainFrameNoStore",
 176         response->headers->HasHeaderValue("cache-control", "no-store"));
 177   }
 178 }
 179
 180 enum ExternallyConditionalizedType {
 181   EXTERNALLY_CONDITIONALIZED_CACHE_REQUIRES_VALIDATION,
 182   EXTERNALLY_CONDITIONALIZED_CACHE_USABLE,
 183   EXTERNALLY_CONDITIONALIZED_MISMATCHED_VALIDATORS,
 184   EXTERNALLY_CONDITIONALIZED_MAX
 185 };
 186
 187 }  // namespace
 188
 189 struct HeaderNameAndValue {
 190   const char* name;
 191   const char* value;
 192 };
 193
 194 // If the request includes one of these request headers, then avoid caching
 195 // to avoid getting confused.
 196 static const HeaderNameAndValue kPassThroughHeaders[] = {
 197   { "if-unmodified-since", NULL },  // causes unexpected 412s
 198   { "if-match", NULL },             // causes unexpected 412s
 199   { "if-range", NULL },
 200   { NULL, NULL }
 201 };
 202
 203 struct ValidationHeaderInfo {
 204   const char* request_header_name;
 205   const char* related_response_header_name;
 206 };
 207
 208 static const ValidationHeaderInfo kValidationHeaders[] = {
 209   { "if-modified-since", "last-modified" },
 210   { "if-none-match", "etag" },
 211 };
 212
 213 // If the request includes one of these request headers, then avoid reusing
 214 // our cached copy if any.
 215 static const HeaderNameAndValue kForceFetchHeaders[] = {
 216   { "cache-control", "no-cache" },
 217   { "pragma", "no-cache" },
 218   { NULL, NULL }
 219 };
 220
 221 // If the request includes one of these request headers, then force our
 222 // cached copy (if any) to be revalidated before reusing it.
 223 static const HeaderNameAndValue kForceValidateHeaders[] = {
 224   { "cache-control", "max-age=0" },
 225   { NULL, NULL }
 226 };
 227
 228 static bool HeaderMatches(const HttpRequestHeaders& headers,
 229                           const HeaderNameAndValue* search) {
 230   for (; search->name; ++search) {
 231     std::string header_value;
 232     if (!headers.GetHeader(search->name, &header_value))
 233       continue;
 234
 235     if (!search->value)
 236       return true;
 237
 238     HttpUtil::ValuesIterator v(header_value.begin(), header_value.end(), ',');
 239     while (v.GetNext()) {
 240       if (base::LowerCaseEqualsASCII(
 241               base::StringPiece(v.value_begin(), v.value_end()), search->value))
 242         return true;
 243     }
 244   }
 245   return false;
 246 }
 247
 248 //-----------------------------------------------------------------------------
 249
 250 HttpCache::Transaction::Transaction(RequestPriority priority, HttpCache* cache)
 251     : next_state_(STATE_NONE),
 252       request_(NULL),
 253       priority_(priority),
 254       cache_(cache->GetWeakPtr()),
 255       entry_(NULL),
 256       new_entry_(NULL),
 257       new_response_(NULL),
 258       mode_(NONE),
 259       reading_(false),
 260       invalid_range_(false),
 261       truncated_(false),
 262       is_sparse_(false),
 263       range_requested_(false),
 264       handling_206_(false),
 265       cache_pending_(false),
 266       done_reading_(false),
 267       vary_mismatch_(false),
 268       couldnt_conditionalize_request_(false),
 269       bypass_lock_for_test_(false),
 270       fail_conditionalization_for_test_(false),
 271       io_buf_len_(0),
 272       read_offset_(0),
 273       effective_load_flags_(0),
 274       write_len_(0),
 275       transaction_pattern_(PATTERN_UNDEFINED),
 276       total_received_bytes_(0),
 277       websocket_handshake_stream_base_create_helper_(NULL),
 278       weak_factory_(this) {
 279   static_assert(HttpCache::Transaction::kNumValidationHeaders ==
 280                     arraysize(kValidationHeaders),
 281                 "invalid number of validation headers");
 282
 283   io_callback_ = base::Bind(&Transaction::OnIOComplete,
 284                               weak_factory_.GetWeakPtr());
 285 }
 286
 287 HttpCache::Transaction::~Transaction() {
 288   // We may have to issue another IO, but we should never invoke the callback_
 289   // after this point.
 290   callback_.Reset();
 291
 292   if (cache_) {
 293     if (entry_) {
 294       bool cancel_request = reading_ && response_.headers.get();
 295       if (cancel_request) {
 296         if (partial_) {
 297           entry_->disk_entry->CancelSparseIO();
 298         } else {
 299           cancel_request &= (response_.headers->response_code() == 200);
 300         }
 301       }
 302
 303       cache_->DoneWithEntry(entry_, this, cancel_request);
 304     } else if (cache_pending_) {
 305       cache_->RemovePendingTransaction(this);
 306     }
 307   }
 308 }
 309
 310 int HttpCache::Transaction::WriteMetadata(IOBuffer* buf, int buf_len,
 311                                           const CompletionCallback& callback) {
 312   DCHECK(buf);
 313   DCHECK_GT(buf_len, 0);
 314   DCHECK(!callback.is_null());
 315   if (!cache_.get() || !entry_)
 316     return ERR_UNEXPECTED;
 317
 318   // We don't need to track this operation for anything.
 319   // It could be possible to check if there is something already written and
 320   // avoid writing again (it should be the same, right?), but let's allow the
 321   // caller to "update" the contents with something new.
 322   return entry_->disk_entry->WriteData(kMetadataIndex, 0, buf, buf_len,
 323                                        callback, true);
 324 }
 325
 326 bool HttpCache::Transaction::AddTruncatedFlag() {
 327   DCHECK(mode_ & WRITE || mode_ == NONE);
 328
 329   // Don't set the flag for sparse entries.
 330   if (partial_ && !truncated_)
 331     return true;
 332
 333   if (!CanResume(true))
 334     return false;
 335
 336   // We may have received the whole resource already.
 337   if (done_reading_)
 338     return true;
 339
 340   truncated_ = true;
 341   next_state_ = STATE_CACHE_WRITE_TRUNCATED_RESPONSE;
 342   DoLoop(OK);
 343   return true;
 344 }
 345
 346 LoadState HttpCache::Transaction::GetWriterLoadState() const {
 347   if (network_trans_.get())
 348     return network_trans_->GetLoadState();
 349   if (entry_ || !request_)
 350     return LOAD_STATE_IDLE;
 351   return LOAD_STATE_WAITING_FOR_CACHE;
 352 }
 353
 354 const BoundNetLog& HttpCache::Transaction::net_log() const {
 355   return net_log_;
 356 }
 357
 358 int HttpCache::Transaction::Start(const HttpRequestInfo* request,
 359                                   const CompletionCallback& callback,
 360                                   const BoundNetLog& net_log) {
 361   DCHECK(request);
 362   DCHECK(!callback.is_null());
 363
 364   // Ensure that we only have one asynchronous call at a time.
 365   DCHECK(callback_.is_null());
 366   DCHECK(!reading_);
 367   DCHECK(!network_trans_.get());
 368   DCHECK(!entry_);
 369   DCHECK_EQ(next_state_, STATE_NONE);
 370
 371   if (!cache_.get())
 372     return ERR_UNEXPECTED;
 373
 374   SetRequest(net_log, request);
 375
 376   // We have to wait until the backend is initialized so we start the SM.
 377   next_state_ = STATE_GET_BACKEND;
 378   int rv = DoLoop(OK);
 379
 380   // Setting this here allows us to check for the existence of a callback_ to
 381   // determine if we are still inside Start.
 382   if (rv == ERR_IO_PENDING)
 383     callback_ = callback;
 384
 385   return rv;
 386 }
 387
 388 int HttpCache::Transaction::RestartIgnoringLastError(
 389     const CompletionCallback& callback) {
 390   DCHECK(!callback.is_null());
 391
 392   // Ensure that we only have one asynchronous call at a time.
 393   DCHECK(callback_.is_null());
 394
 395   if (!cache_.get())
 396     return ERR_UNEXPECTED;
 397
 398   int rv = RestartNetworkRequest();
 399
 400   if (rv == ERR_IO_PENDING)
 401     callback_ = callback;
 402
 403   return rv;
 404 }
 405
 406 int HttpCache::Transaction::RestartWithCertificate(
 407     X509Certificate* client_cert,
 408     const CompletionCallback& callback) {
 409   DCHECK(!callback.is_null());
 410
 411   // Ensure that we only have one asynchronous call at a time.
 412   DCHECK(callback_.is_null());
 413
 414   if (!cache_.get())
 415     return ERR_UNEXPECTED;
 416
 417   int rv = RestartNetworkRequestWithCertificate(client_cert);
 418
 419   if (rv == ERR_IO_PENDING)
 420     callback_ = callback;
 421
 422   return rv;
 423 }
 424
 425 int HttpCache::Transaction::RestartWithAuth(
 426     const AuthCredentials& credentials,
 427     const CompletionCallback& callback) {
 428   DCHECK(auth_response_.headers.get());
 429   DCHECK(!callback.is_null());
 430
 431   // Ensure that we only have one asynchronous call at a time.
 432   DCHECK(callback_.is_null());
 433
 434   if (!cache_.get())
 435     return ERR_UNEXPECTED;
 436
 437   // Clear the intermediate response since we are going to start over.
 438   auth_response_ = HttpResponseInfo();
 439
 440   int rv = RestartNetworkRequestWithAuth(credentials);
 441
 442   if (rv == ERR_IO_PENDING)
 443     callback_ = callback;
 444
 445   return rv;
 446 }
 447
 448 bool HttpCache::Transaction::IsReadyToRestartForAuth() {
 449   if (!network_trans_.get())
 450     return false;
 451   return network_trans_->IsReadyToRestartForAuth();
 452 }
 453
 454 int HttpCache::Transaction::Read(IOBuffer* buf, int buf_len,
 455                                  const CompletionCallback& callback) {
 456   DCHECK_EQ(next_state_, STATE_NONE);
 457   DCHECK(buf);
 458   DCHECK_GT(buf_len, 0);
 459   DCHECK(!callback.is_null());
 460
 461   DCHECK(callback_.is_null());
 462
 463   if (!cache_.get())
 464     return ERR_UNEXPECTED;
 465
 466   // If we have an intermediate auth response at this point, then it means the
 467   // user wishes to read the network response (the error page).  If there is a
 468   // previous response in the cache then we should leave it intact.
 469   if (auth_response_.headers.get() && mode_ != NONE) {
 470     UpdateTransactionPattern(PATTERN_NOT_COVERED);
 471     DCHECK(mode_ & WRITE);
 472     DoneWritingToEntry(mode_ == READ_WRITE);
 473     mode_ = NONE;
 474   }
 475
 476   reading_ = true;
 477   read_buf_ = buf;
 478   io_buf_len_ = buf_len;
 479   if (network_trans_) {
 480     DCHECK(mode_ == WRITE || mode_ == NONE ||
 481            (mode_ == READ_WRITE && partial_));
 482     next_state_ = STATE_NETWORK_READ;
 483   } else {
 484     DCHECK(mode_ == READ || (mode_ == READ_WRITE && partial_));
 485     next_state_ = STATE_CACHE_READ_DATA;
 486   }
 487
 488   int rv = DoLoop(OK);
 489
 490   if (rv == ERR_IO_PENDING) {
 491     DCHECK(callback_.is_null());
 492     callback_ = callback;
 493   }
 494   return rv;
 495 }
 496
 497 void HttpCache::Transaction::StopCaching() {
 498   // We really don't know where we are now. Hopefully there is no operation in
 499   // progress, but nothing really prevents this method to be called after we
 500   // returned ERR_IO_PENDING. We cannot attempt to truncate the entry at this
 501   // point because we need the state machine for that (and even if we are really
 502   // free, that would be an asynchronous operation). In other words, keep the
 503   // entry how it is (it will be marked as truncated at destruction), and let
 504   // the next piece of code that executes know that we are now reading directly
 505   // from the net.
 506   // TODO(mmenke):  This doesn't release the lock on the cache entry, so a
 507   //                future request for the resource will be blocked on this one.
 508   //                Fix this.
 509   if (cache_.get() && entry_ && (mode_ & WRITE) && network_trans_.get() &&
 510       !is_sparse_ && !range_requested_) {
 511     mode_ = NONE;
 512   }
 513 }
 514
 515 bool HttpCache::Transaction::GetFullRequestHeaders(
 516     HttpRequestHeaders* headers) const {
 517   if (network_trans_)
 518     return network_trans_->GetFullRequestHeaders(headers);
 519
 520   // TODO(ttuttle): Read headers from cache.
 521   return false;
 522 }
 523
 524 int64 HttpCache::Transaction::GetTotalReceivedBytes() const {
 525   int64 total_received_bytes = total_received_bytes_;
 526   if (network_trans_)
 527     total_received_bytes += network_trans_->GetTotalReceivedBytes();
 528   return total_received_bytes;
 529 }
 530
 531 void HttpCache::Transaction::DoneReading() {
 532   if (cache_.get() && entry_) {
 533     DCHECK_NE(mode_, UPDATE);
 534     if (mode_ & WRITE) {
 535       DoneWritingToEntry(true);
 536     } else if (mode_ & READ) {
 537       // It is necessary to check mode_ & READ because it is possible
 538       // for mode_ to be NONE and entry_ non-NULL with a write entry
 539       // if StopCaching was called.
 540       cache_->DoneReadingFromEntry(entry_, this);
 541       entry_ = NULL;
 542     }
 543   }
 544 }
 545
 546 const HttpResponseInfo* HttpCache::Transaction::GetResponseInfo() const {
 547   // Null headers means we encountered an error or haven't a response yet
 548   if (auth_response_.headers.get())
 549     return &auth_response_;
 550   return &response_;
 551 }
 552
 553 LoadState HttpCache::Transaction::GetLoadState() const {
 554   LoadState state = GetWriterLoadState();
 555   if (state != LOAD_STATE_WAITING_FOR_CACHE)
 556     return state;
 557
 558   if (cache_.get())
 559     return cache_->GetLoadStateForPendingTransaction(this);
 560
 561   return LOAD_STATE_IDLE;
 562 }
 563
 564 UploadProgress HttpCache::Transaction::GetUploadProgress() const {
 565   if (network_trans_.get())
 566     return network_trans_->GetUploadProgress();
 567   return final_upload_progress_;
 568 }
 569
 570 void HttpCache::Transaction::SetQuicServerInfo(
 571     QuicServerInfo* quic_server_info) {}
 572
 573 bool HttpCache::Transaction::GetLoadTimingInfo(
 574     LoadTimingInfo* load_timing_info) const {
 575   if (network_trans_)
 576     return network_trans_->GetLoadTimingInfo(load_timing_info);
 577
 578   if (old_network_trans_load_timing_) {
 579     *load_timing_info = *old_network_trans_load_timing_;
 580     return true;
 581   }
 582
 583   if (first_cache_access_since_.is_null())
 584     return false;
 585
 586   // If the cache entry was opened, return that time.
 587   load_timing_info->send_start = first_cache_access_since_;
 588   // This time doesn't make much sense when reading from the cache, so just use
 589   // the same time as send_start.
 590   load_timing_info->send_end = first_cache_access_since_;
 591   return true;
 592 }
 593
 594 void HttpCache::Transaction::SetPriority(RequestPriority priority) {
 595   priority_ = priority;
 596   if (network_trans_)
 597     network_trans_->SetPriority(priority_);
 598 }
 599
 600 void HttpCache::Transaction::SetWebSocketHandshakeStreamCreateHelper(
 601     WebSocketHandshakeStreamBase::CreateHelper* create_helper) {
 602   websocket_handshake_stream_base_create_helper_ = create_helper;
 603   if (network_trans_)
 604     network_trans_->SetWebSocketHandshakeStreamCreateHelper(create_helper);
 605 }
 606
 607 void HttpCache::Transaction::SetBeforeNetworkStartCallback(
 608     const BeforeNetworkStartCallback& callback) {
 609   DCHECK(!network_trans_);
 610   before_network_start_callback_ = callback;
 611 }
 612
 613 void HttpCache::Transaction::SetBeforeProxyHeadersSentCallback(
 614     const BeforeProxyHeadersSentCallback& callback) {
 615   DCHECK(!network_trans_);
 616   before_proxy_headers_sent_callback_ = callback;
 617 }
 618
 619 int HttpCache::Transaction::ResumeNetworkStart() {
 620   if (network_trans_)
 621     return network_trans_->ResumeNetworkStart();
 622   return ERR_UNEXPECTED;
 623 }
 624
 625 void HttpCache::Transaction::GetConnectionAttempts(
 626     ConnectionAttempts* out) const {
 627   ConnectionAttempts new_connection_attempts;
 628   if (network_trans_)
 629     network_trans_->GetConnectionAttempts(&new_connection_attempts);
 630
 631   out->swap(new_connection_attempts);
 632   out->insert(out->begin(), old_connection_attempts_.begin(),
 633               old_connection_attempts_.end());
 634 }
 635
 636 //-----------------------------------------------------------------------------
 637
 638 // A few common patterns: (Foo* means Foo -> FooComplete)
 639 //
 640 // 1. Not-cached entry:
 641 //   Start():
 642 //   GetBackend* -> InitEntry -> OpenEntry* -> CreateEntry* -> AddToEntry* ->
 643 //   SendRequest* -> SuccessfulSendRequest -> OverwriteCachedResponse ->
 644 //   CacheWriteResponse* -> TruncateCachedData* -> TruncateCachedMetadata* ->
 645 //   PartialHeadersReceived
 646 //
 647 //   Read():
 648 //   NetworkRead* -> CacheWriteData*
 649 //
 650 // 2. Cached entry, no validation:
 651 //   Start():
 652 //   GetBackend* -> InitEntry -> OpenEntry* -> AddToEntry* -> CacheReadResponse*
 653 //   -> CacheDispatchValidation -> BeginPartialCacheValidation() ->
 654 //   BeginCacheValidation() -> SetupEntryForRead()
 655 //
 656 //   Read():
 657 //   CacheReadData*
 658 //
 659 // 3. Cached entry, validation (304):
 660 //   Start():
 661 //   GetBackend* -> InitEntry -> OpenEntry* -> AddToEntry* -> CacheReadResponse*
 662 //   -> CacheDispatchValidation -> BeginPartialCacheValidation() ->
 663 //   BeginCacheValidation() -> SendRequest* -> SuccessfulSendRequest ->
 664 //   UpdateCachedResponse -> CacheWriteUpdatedResponse* ->
 665 //   UpdateCachedResponseComplete -> OverwriteCachedResponse ->
 666 //   PartialHeadersReceived
 667 //
 668 //   Read():
 669 //   CacheReadData*
 670 //
 671 // 4. Cached entry, validation and replace (200):
 672 //   Start():
 673 //   GetBackend* -> InitEntry -> OpenEntry* -> AddToEntry* -> CacheReadResponse*
 674 //   -> CacheDispatchValidation -> BeginPartialCacheValidation() ->
 675 //   BeginCacheValidation() -> SendRequest* -> SuccessfulSendRequest ->
 676 //   OverwriteCachedResponse -> CacheWriteResponse* -> DoTruncateCachedData* ->
 677 //   TruncateCachedMetadata* -> PartialHeadersReceived
 678 //
 679 //   Read():
 680 //   NetworkRead* -> CacheWriteData*
 681 //
 682 // 5. Sparse entry, partially cached, byte range request:
 683 //   Start():
 684 //   GetBackend* -> InitEntry -> OpenEntry* -> AddToEntry* -> CacheReadResponse*
 685 //   -> CacheDispatchValidation -> BeginPartialCacheValidation() ->
 686 //   CacheQueryData* -> ValidateEntryHeadersAndContinue() ->
 687 //   StartPartialCacheValidation -> CompletePartialCacheValidation ->
 688 //   BeginCacheValidation() -> SendRequest* -> SuccessfulSendRequest ->
 689 //   UpdateCachedResponse -> CacheWriteUpdatedResponse* ->
 690 //   UpdateCachedResponseComplete -> OverwriteCachedResponse ->
 691 //   PartialHeadersReceived
 692 //
 693 //   Read() 1:
 694 //   NetworkRead* -> CacheWriteData*
 695 //
 696 //   Read() 2:
 697 //   NetworkRead* -> CacheWriteData* -> StartPartialCacheValidation ->
 698 //   CompletePartialCacheValidation -> CacheReadData* ->
 699 //
 700 //   Read() 3:
 701 //   CacheReadData* -> StartPartialCacheValidation ->
 702 //   CompletePartialCacheValidation -> BeginCacheValidation() -> SendRequest* ->
 703 //   SuccessfulSendRequest -> UpdateCachedResponse* -> OverwriteCachedResponse
 704 //   -> PartialHeadersReceived -> NetworkRead* -> CacheWriteData*
 705 //
 706 // 6. HEAD. Not-cached entry:
 707 //   Pass through. Don't save a HEAD by itself.
 708 //   Start():
 709 //   GetBackend* -> InitEntry -> OpenEntry* -> SendRequest*
 710 //
 711 // 7. HEAD. Cached entry, no validation:
 712 //   Start():
 713 //   The same flow as for a GET request (example #2)
 714 //
 715 //   Read():
 716 //   CacheReadData (returns 0)
 717 //
 718 // 8. HEAD. Cached entry, validation (304):
 719 //   The request updates the stored headers.
 720 //   Start(): Same as for a GET request (example #3)
 721 //
 722 //   Read():
 723 //   CacheReadData (returns 0)
 724 //
 725 // 9. HEAD. Cached entry, validation and replace (200):
 726 //   Pass through. The request dooms the old entry, as a HEAD won't be stored by
 727 //   itself.
 728 //   Start():
 729 //   GetBackend* -> InitEntry -> OpenEntry* -> AddToEntry* -> CacheReadResponse*
 730 //   -> CacheDispatchValidation -> BeginPartialCacheValidation() ->
 731 //   BeginCacheValidation() -> SendRequest* -> SuccessfulSendRequest ->
 732 //   OverwriteCachedResponse
 733 //
 734 // 10. HEAD. Sparse entry, partially cached:
 735 //   Serve the request from the cache, as long as it doesn't require
 736 //   revalidation. Ignore missing ranges when deciding to revalidate. If the
 737 //   entry requires revalidation, ignore the whole request and go to full pass
 738 //   through (the result of the HEAD request will NOT update the entry).
 739 //
 740 //   Start(): Basically the same as example 7, as we never create a partial_
 741 //   object for this request.
 742 //
 743 // 11. Prefetch, not-cached entry:
 744 //   The same as example 1. The "unused_since_prefetch" bit is stored as true in
 745 //   UpdateCachedResponse.
 746 //
 747 // 12. Prefetch, cached entry:
 748 //   Like examples 2-4, only CacheToggleUnusedSincePrefetch* is inserted between
 749 //   CacheReadResponse* and CacheDispatchValidation if the unused_since_prefetch
 750 //   bit is unset.
 751 //
 752 // 13. Cached entry less than 5 minutes old, unused_since_prefetch is true:
 753 //   Skip validation, similar to example 2.
 754 //   GetBackend* -> InitEntry -> OpenEntry* -> AddToEntry* -> CacheReadResponse*
 755 //   -> CacheToggleUnusedSincePrefetch* -> CacheDispatchValidation ->
 756 //   BeginPartialCacheValidation() -> BeginCacheValidation() ->
 757 //   SetupEntryForRead()
 758 //
 759 //   Read():
 760 //   CacheReadData*
 761 //
 762 // 14. Cached entry more than 5 minutes old, unused_since_prefetch is true:
 763 //   Like examples 2-4, only CacheToggleUnusedSincePrefetch* is inserted between
 764 //   CacheReadResponse* and CacheDispatchValidation.
 765 int HttpCache::Transaction::DoLoop(int result) {
 766   DCHECK(next_state_ != STATE_NONE);
 767
 768   int rv = result;
 769   do {
 770     State state = next_state_;
 771     next_state_ = STATE_NONE;
 772     switch (state) {
 773       case STATE_GET_BACKEND:
 774         DCHECK_EQ(OK, rv);
 775         rv = DoGetBackend();
 776         break;
 777       case STATE_GET_BACKEND_COMPLETE:
 778         rv = DoGetBackendComplete(rv);
 779         break;
 780       case STATE_INIT_ENTRY:
 781         DCHECK_EQ(OK, rv);
 782         rv = DoInitEntry();
 783         break;
 784       case STATE_OPEN_ENTRY:
 785         DCHECK_EQ(OK, rv);
 786         rv = DoOpenEntry();
 787         break;
 788       case STATE_OPEN_ENTRY_COMPLETE:
 789         rv = DoOpenEntryComplete(rv);
 790         break;
 791       case STATE_DOOM_ENTRY:
 792         DCHECK_EQ(OK, rv);
 793         rv = DoDoomEntry();
 794         break;
 795       case STATE_DOOM_ENTRY_COMPLETE:
 796         rv = DoDoomEntryComplete(rv);
 797         break;
 798       case STATE_CREATE_ENTRY:
 799         DCHECK_EQ(OK, rv);
 800         rv = DoCreateEntry();
 801         break;
 802       case STATE_CREATE_ENTRY_COMPLETE:
 803         rv = DoCreateEntryComplete(rv);
 804         break;
 805       case STATE_ADD_TO_ENTRY:
 806         DCHECK_EQ(OK, rv);
 807         rv = DoAddToEntry();
 808         break;
 809       case STATE_ADD_TO_ENTRY_COMPLETE:
 810         rv = DoAddToEntryComplete(rv);
 811         break;
 812       case STATE_CACHE_READ_RESPONSE:
 813         DCHECK_EQ(OK, rv);
 814         rv = DoCacheReadResponse();
 815         break;
 816       case STATE_CACHE_READ_RESPONSE_COMPLETE:
 817         rv = DoCacheReadResponseComplete(rv);
 818         break;
 819       case STATE_TOGGLE_UNUSED_SINCE_PREFETCH:
 820         DCHECK_EQ(OK, rv);
 821         rv = DoCacheToggleUnusedSincePrefetch();
 822         break;
 823       case STATE_TOGGLE_UNUSED_SINCE_PREFETCH_COMPLETE:
 824         rv = DoCacheToggleUnusedSincePrefetchComplete(rv);
 825         break;
 826       case STATE_CACHE_DISPATCH_VALIDATION:
 827         DCHECK_EQ(OK, rv);
 828         rv = DoCacheDispatchValidation();
 829         break;
 830       case STATE_CACHE_QUERY_DATA:
 831         DCHECK_EQ(OK, rv);
 832         rv = DoCacheQueryData();
 833         break;
 834       case STATE_CACHE_QUERY_DATA_COMPLETE:
 835         rv = DoCacheQueryDataComplete(rv);
 836         break;
 837       case STATE_START_PARTIAL_CACHE_VALIDATION:
 838         DCHECK_EQ(OK, rv);
 839         rv = DoStartPartialCacheValidation();
 840         break;
 841       case STATE_COMPLETE_PARTIAL_CACHE_VALIDATION:
 842         rv = DoCompletePartialCacheValidation(rv);
 843         break;
 844       case STATE_SEND_REQUEST:
 845         DCHECK_EQ(OK, rv);
 846         rv = DoSendRequest();
 847         break;
 848       case STATE_SEND_REQUEST_COMPLETE:
 849         rv = DoSendRequestComplete(rv);
 850         break;
 851       case STATE_SUCCESSFUL_SEND_REQUEST:
 852         DCHECK_EQ(OK, rv);
 853         rv = DoSuccessfulSendRequest();
 854         break;
 855       case STATE_UPDATE_CACHED_RESPONSE:
 856         DCHECK_EQ(OK, rv);
 857         rv = DoUpdateCachedResponse();
 858         break;
 859       case STATE_CACHE_WRITE_UPDATED_RESPONSE:
 860         DCHECK_EQ(OK, rv);
 861         rv = DoCacheWriteUpdatedResponse();
 862         break;
 863       case STATE_CACHE_WRITE_UPDATED_RESPONSE_COMPLETE:
 864         rv = DoCacheWriteUpdatedResponseComplete(rv);
 865         break;
 866       case STATE_UPDATE_CACHED_RESPONSE_COMPLETE:
 867         rv = DoUpdateCachedResponseComplete(rv);
 868         break;
 869       case STATE_OVERWRITE_CACHED_RESPONSE:
 870         DCHECK_EQ(OK, rv);
 871         rv = DoOverwriteCachedResponse();
 872         break;
 873       case STATE_CACHE_WRITE_RESPONSE:
 874         DCHECK_EQ(OK, rv);
 875         rv = DoCacheWriteResponse();
 876         break;
 877       case STATE_CACHE_WRITE_RESPONSE_COMPLETE:
 878         rv = DoCacheWriteResponseComplete(rv);
 879         break;
 880       case STATE_TRUNCATE_CACHED_DATA:
 881         DCHECK_EQ(OK, rv);
 882         rv = DoTruncateCachedData();
 883         break;
 884       case STATE_TRUNCATE_CACHED_DATA_COMPLETE:
 885         rv = DoTruncateCachedDataComplete(rv);
 886         break;
 887       case STATE_TRUNCATE_CACHED_METADATA:
 888         DCHECK_EQ(OK, rv);
 889         rv = DoTruncateCachedMetadata();
 890         break;
 891       case STATE_TRUNCATE_CACHED_METADATA_COMPLETE:
 892         rv = DoTruncateCachedMetadataComplete(rv);
 893         break;
 894       case STATE_PARTIAL_HEADERS_RECEIVED:
 895         DCHECK_EQ(OK, rv);
 896         rv = DoPartialHeadersReceived();
 897         break;
 898       case STATE_CACHE_READ_METADATA:
 899         DCHECK_EQ(OK, rv);
 900         rv = DoCacheReadMetadata();
 901         break;
 902       case STATE_CACHE_READ_METADATA_COMPLETE:
 903         rv = DoCacheReadMetadataComplete(rv);
 904         break;
 905       case STATE_NETWORK_READ:
 906         DCHECK_EQ(OK, rv);
 907         rv = DoNetworkRead();
 908         break;
 909       case STATE_NETWORK_READ_COMPLETE:
 910         rv = DoNetworkReadComplete(rv);
 911         break;
 912       case STATE_CACHE_READ_DATA:
 913         DCHECK_EQ(OK, rv);
 914         rv = DoCacheReadData();
 915         break;
 916       case STATE_CACHE_READ_DATA_COMPLETE:
 917         rv = DoCacheReadDataComplete(rv);
 918         break;
 919       case STATE_CACHE_WRITE_DATA:
 920         rv = DoCacheWriteData(rv);
 921         break;
 922       case STATE_CACHE_WRITE_DATA_COMPLETE:
 923         rv = DoCacheWriteDataComplete(rv);
 924         break;
 925       case STATE_CACHE_WRITE_TRUNCATED_RESPONSE:
 926         DCHECK_EQ(OK, rv);
 927         rv = DoCacheWriteTruncatedResponse();
 928         break;
 929       case STATE_CACHE_WRITE_TRUNCATED_RESPONSE_COMPLETE:
 930         rv = DoCacheWriteTruncatedResponseComplete(rv);
 931         break;
 932       default:
 933         NOTREACHED() << "bad state";
 934         rv = ERR_FAILED;
 935         break;
 936     }
 937   } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE);
 938
 939   if (rv != ERR_IO_PENDING && !callback_.is_null()) {
 940     read_buf_ = NULL;  // Release the buffer before invoking the callback.
 941     base::ResetAndReturn(&callback_).Run(rv);
 942   }
 943
 944   return rv;
 945 }
 946
 947 int HttpCache::Transaction::DoGetBackend() {
 948   cache_pending_ = true;
 949   next_state_ = STATE_GET_BACKEND_COMPLETE;
 950   net_log_.BeginEvent(NetLog::TYPE_HTTP_CACHE_GET_BACKEND);
 951   return cache_->GetBackendForTransaction(this);
 952 }
 953
 954 int HttpCache::Transaction::DoGetBackendComplete(int result) {
 955   DCHECK(result == OK || result == ERR_FAILED);
 956   net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_CACHE_GET_BACKEND,
 957                                     result);
 958   cache_pending_ = false;
 959
 960   if (!ShouldPassThrough()) {
 961     cache_key_ = cache_->GenerateCacheKey(request_);
 962
 963     // Requested cache access mode.
 964     if (effective_load_flags_ & LOAD_ONLY_FROM_CACHE) {
 965       mode_ = READ;
 966     } else if (effective_load_flags_ & LOAD_BYPASS_CACHE) {
 967       mode_ = WRITE;
 968     } else {
 969       mode_ = READ_WRITE;
 970     }
 971
 972     // Downgrade to UPDATE if the request has been externally conditionalized.
 973     if (external_validation_.initialized) {
 974       if (mode_ & WRITE) {
 975         // Strip off the READ_DATA bit (and maybe add back a READ_META bit
 976         // in case READ was off).
 977         mode_ = UPDATE;
 978       } else {
 979         mode_ = NONE;
 980       }
 981     }
 982   }
 983
 984   // Use PUT and DELETE only to invalidate existing stored entries.
 985   if ((request_->method == "PUT" || request_->method == "DELETE") &&
 986       mode_ != READ_WRITE && mode_ != WRITE) {
 987     mode_ = NONE;
 988   }
 989
 990   // Note that if mode_ == UPDATE (which is tied to external_validation_), the
 991   // transaction behaves the same for GET and HEAD requests at this point: if it
 992   // was not modified, the entry is updated and a response is not returned from
 993   // the cache. If we receive 200, it doesn't matter if there was a validation
 994   // header or not.
 995   if (request_->method == "HEAD" && mode_ == WRITE)
 996     mode_ = NONE;
 997
 998   // If must use cache, then we must fail.  This can happen for back/forward
 999   // navigations to a page generated via a form post.
1000   if (!(mode_ & READ) && effective_load_flags_ & LOAD_ONLY_FROM_CACHE)
1001     return ERR_CACHE_MISS;
1002
1003   if (mode_ == NONE) {
1004     if (partial_) {
1005       partial_->RestoreHeaders(&custom_request_->extra_headers);
1006       partial_.reset();
1007     }
1008     next_state_ = STATE_SEND_REQUEST;
1009   } else {
1010     next_state_ = STATE_INIT_ENTRY;
1011   }
1012
1013   // This is only set if we have something to do with the response.
1014   range_requested_ = (partial_.get() != NULL);
1015
1016   return OK;
1017 }
1018
1019 int HttpCache::Transaction::DoInitEntry() {
1020   DCHECK(!new_entry_);
1021
1022   if (!cache_.get())
1023     return ERR_UNEXPECTED;
1024
1025   if (mode_ == WRITE) {
1026     next_state_ = STATE_DOOM_ENTRY;
1027     return OK;
1028   }
1029
1030   next_state_ = STATE_OPEN_ENTRY;
1031   return OK;
1032 }
1033
1034 int HttpCache::Transaction::DoOpenEntry() {
1035   DCHECK(!new_entry_);
1036   next_state_ = STATE_OPEN_ENTRY_COMPLETE;
1037   cache_pending_ = true;
1038   net_log_.BeginEvent(NetLog::TYPE_HTTP_CACHE_OPEN_ENTRY);
1039   first_cache_access_since_ = TimeTicks::Now();
1040   return cache_->OpenEntry(cache_key_, &new_entry_, this);
1041 }
1042
1043 int HttpCache::Transaction::DoOpenEntryComplete(int result) {
1044   // It is important that we go to STATE_ADD_TO_ENTRY whenever the result is
1045   // OK, otherwise the cache will end up with an active entry without any
1046   // transaction attached.
1047   net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_CACHE_OPEN_ENTRY, result);
1048   cache_pending_ = false;
1049   if (result == OK) {
1050     next_state_ = STATE_ADD_TO_ENTRY;
1051     return OK;
1052   }
1053
1054   if (result == ERR_CACHE_RACE) {
1055     next_state_ = STATE_INIT_ENTRY;
1056     return OK;
1057   }
1058
1059   if (request_->method == "PUT" || request_->method == "DELETE" ||
1060       (request_->method == "HEAD" && mode_ == READ_WRITE)) {
1061     DCHECK(mode_ == READ_WRITE || mode_ == WRITE || request_->method == "HEAD");
1062     mode_ = NONE;
1063     next_state_ = STATE_SEND_REQUEST;
1064     return OK;
1065   }
1066
1067   if (mode_ == READ_WRITE) {
1068     mode_ = WRITE;
1069     next_state_ = STATE_CREATE_ENTRY;
1070     return OK;
1071   }
1072   if (mode_ == UPDATE) {
1073     // There is no cache entry to update; proceed without caching.
1074     mode_ = NONE;
1075     next_state_ = STATE_SEND_REQUEST;
1076     return OK;
1077   }
1078
1079   // The entry does not exist, and we are not permitted to create a new entry,
1080   // so we must fail.
1081   return ERR_CACHE_MISS;
1082 }
1083
1084 int HttpCache::Transaction::DoDoomEntry() {
1085   next_state_ = STATE_DOOM_ENTRY_COMPLETE;
1086   cache_pending_ = true;
1087   if (first_cache_access_since_.is_null())
1088     first_cache_access_since_ = TimeTicks::Now();
1089   net_log_.BeginEvent(NetLog::TYPE_HTTP_CACHE_DOOM_ENTRY);
1090   return cache_->DoomEntry(cache_key_, this);
1091 }
1092
1093 int HttpCache::Transaction::DoDoomEntryComplete(int result) {
1094   net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_CACHE_DOOM_ENTRY, result);
1095   next_state_ = STATE_CREATE_ENTRY;
1096   cache_pending_ = false;
1097   if (result == ERR_CACHE_RACE)
1098     next_state_ = STATE_INIT_ENTRY;
1099   return OK;
1100 }
1101
1102 int HttpCache::Transaction::DoCreateEntry() {
1103   DCHECK(!new_entry_);
1104   next_state_ = STATE_CREATE_ENTRY_COMPLETE;
1105   cache_pending_ = true;
1106   net_log_.BeginEvent(NetLog::TYPE_HTTP_CACHE_CREATE_ENTRY);
1107   return cache_->CreateEntry(cache_key_, &new_entry_, this);
1108 }
1109
1110 int HttpCache::Transaction::DoCreateEntryComplete(int result) {
1111   // It is important that we go to STATE_ADD_TO_ENTRY whenever the result is
1112   // OK, otherwise the cache will end up with an active entry without any
1113   // transaction attached.
1114   net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_CACHE_CREATE_ENTRY,
1115                                     result);
1116   cache_pending_ = false;
1117   switch (result) {
1118     case OK:
1119       next_state_ = STATE_ADD_TO_ENTRY;
1120       break;
1121
1122     case ERR_CACHE_RACE:
1123       next_state_ = STATE_INIT_ENTRY;
1124       break;
1125
1126     default:
1127       // We have a race here: Maybe we failed to open the entry and decided to
1128       // create one, but by the time we called create, another transaction
1129       // already created the entry. If we want to eliminate this issue, we
1130       // need an atomic OpenOrCreate() method exposed by the disk cache.
1131       DLOG(WARNING) << "Unable to create cache entry";
1132       mode_ = NONE;
1133       if (partial_)
1134         partial_->RestoreHeaders(&custom_request_->extra_headers);
1135       next_state_ = STATE_SEND_REQUEST;
1136   }
1137   return OK;
1138 }
1139
1140 int HttpCache::Transaction::DoAddToEntry() {
1141   DCHECK(new_entry_);
1142   cache_pending_ = true;
1143   next_state_ = STATE_ADD_TO_ENTRY_COMPLETE;
1144   net_log_.BeginEvent(NetLog::TYPE_HTTP_CACHE_ADD_TO_ENTRY);
1145   DCHECK(entry_lock_waiting_since_.is_null());
1146   entry_lock_waiting_since_ = TimeTicks::Now();
1147   int rv = cache_->AddTransactionToEntry(new_entry_, this);
1148   if (rv == ERR_IO_PENDING) {
1149     if (bypass_lock_for_test_) {
1150       OnAddToEntryTimeout(entry_lock_waiting_since_);
1151     } else {
1152       int timeout_milliseconds = 20 * 1000;
1153       if (partial_ && new_entry_->writer &&
1154           new_entry_->writer->range_requested_) {
1155         // Quickly timeout and bypass the cache if we're a range request and
1156         // we're blocked by the reader/writer lock. Doing so eliminates a long
1157         // running issue, http://crbug.com/31014, where two of the same media
1158         // resources could not be played back simultaneously due to one locking
1159         // the cache entry until the entire video was downloaded.
1160         //
1161         // Bypassing the cache is not ideal, as we are now ignoring the cache
1162         // entirely for all range requests to a resource beyond the first. This
1163         // is however a much more succinct solution than the alternatives, which
1164         // would require somewhat significant changes to the http caching logic.
1165         //
1166         // Allow some timeout slack for the entry addition to complete in case
1167         // the writer lock is imminently released; we want to avoid skipping
1168         // the cache if at all possible. See http://crbug.com/408765
1169         timeout_milliseconds = 25;
1170       }
1171       base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
1172           FROM_HERE,
1173           base::Bind(&HttpCache::Transaction::OnAddToEntryTimeout,
1174                      weak_factory_.GetWeakPtr(), entry_lock_waiting_since_),
1175           TimeDelta::FromMilliseconds(timeout_milliseconds));
1176     }
1177   }
1178   return rv;
1179 }
1180
1181 int HttpCache::Transaction::DoAddToEntryComplete(int result) {
1182   net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_CACHE_ADD_TO_ENTRY,
1183                                     result);
1184   const TimeDelta entry_lock_wait =
1185       TimeTicks::Now() - entry_lock_waiting_since_;
1186   UMA_HISTOGRAM_TIMES("HttpCache.EntryLockWait", entry_lock_wait);
1187
1188   entry_lock_waiting_since_ = TimeTicks();
1189   DCHECK(new_entry_);
1190   cache_pending_ = false;
1191
1192   if (result == OK)
1193     entry_ = new_entry_;
1194
1195   // If there is a failure, the cache should have taken care of new_entry_.
1196   new_entry_ = NULL;
1197
1198   if (result == ERR_CACHE_RACE) {
1199     next_state_ = STATE_INIT_ENTRY;
1200     return OK;
1201   }
1202
1203   if (result == ERR_CACHE_LOCK_TIMEOUT) {
1204     // The cache is busy, bypass it for this transaction.
1205     mode_ = NONE;
1206     next_state_ = STATE_SEND_REQUEST;
1207     if (partial_) {
1208       partial_->RestoreHeaders(&custom_request_->extra_headers);
1209       partial_.reset();
1210     }
1211     return OK;
1212   }
1213
1214   if (result != OK) {
1215     NOTREACHED();
1216     return result;
1217   }
1218
1219   if (mode_ == WRITE) {
1220     if (partial_)
1221       partial_->RestoreHeaders(&custom_request_->extra_headers);
1222     next_state_ = STATE_SEND_REQUEST;
1223   } else {
1224     // We have to read the headers from the cached entry.
1225     DCHECK(mode_ & READ_META);
1226     next_state_ = STATE_CACHE_READ_RESPONSE;
1227   }
1228   return OK;
1229 }
1230
1231 int HttpCache::Transaction::DoCacheReadResponse() {
1232   DCHECK(entry_);
1233   next_state_ = STATE_CACHE_READ_RESPONSE_COMPLETE;
1234
1235   io_buf_len_ = entry_->disk_entry->GetDataSize(kResponseInfoIndex);
1236   read_buf_ = new IOBuffer(io_buf_len_);
1237
1238   net_log_.BeginEvent(NetLog::TYPE_HTTP_CACHE_READ_INFO);
1239   return entry_->disk_entry->ReadData(kResponseInfoIndex, 0, read_buf_.get(),
1240                                       io_buf_len_, io_callback_);
1241 }
1242
1243 int HttpCache::Transaction::DoCacheReadResponseComplete(int result) {
1244   net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_CACHE_READ_INFO, result);
1245   if (result != io_buf_len_ ||
1246       !HttpCache::ParseResponseInfo(read_buf_->data(), io_buf_len_, &response_,
1247                                     &truncated_)) {
1248     return OnCacheReadError(result, true);
1249   }
1250
1251   // cert_cache() will be null if the CertCacheTrial field trial is disabled.
1252   if (cache_->cert_cache() && response_.ssl_info.is_valid())
1253     ReadCertChain();
1254
1255   // Some resources may have slipped in as truncated when they're not.
1256   int current_size = entry_->disk_entry->GetDataSize(kResponseContentIndex);
1257   if (response_.headers->GetContentLength() == current_size)
1258     truncated_ = false;
1259
1260   if ((response_.unused_since_prefetch &&
1261        !(request_->load_flags & LOAD_PREFETCH)) ||
1262       (!response_.unused_since_prefetch &&
1263        (request_->load_flags & LOAD_PREFETCH))) {
1264     // Either this is the first use of an entry since it was prefetched or
1265     // this is a prefetch. The value of response.unused_since_prefetch is valid
1266     // for this transaction but the bit needs to be flipped in storage.
1267     next_state_ = STATE_TOGGLE_UNUSED_SINCE_PREFETCH;
1268     return OK;
1269   }
1270
1271   next_state_ = STATE_CACHE_DISPATCH_VALIDATION;
1272   return OK;
1273 }
1274
1275 int HttpCache::Transaction::DoCacheToggleUnusedSincePrefetch() {
1276   // Write back the toggled value for the next use of this entry.
1277   response_.unused_since_prefetch = !response_.unused_since_prefetch;
1278
1279   // TODO(jkarlin): If DoUpdateCachedResponse is also called for this
1280   // transaction then metadata will be written to cache twice. If prefetching
1281   // becomes more common, consider combining the writes.
1282
1283   // TODO(rtenneti): Remove ScopedTracker below once crbug.com/422516 is fixed.
1284   tracked_objects::ScopedTracker tracking_profile(
1285       FROM_HERE_WITH_EXPLICIT_FUNCTION(
1286           "422516 HttpCache::Transaction::DoCacheToggleUnusedSincePrefetch"));
1287
1288   next_state_ = STATE_TOGGLE_UNUSED_SINCE_PREFETCH_COMPLETE;
1289   return WriteResponseInfoToEntry(false);
1290 }
1291
1292 int HttpCache::Transaction::DoCacheToggleUnusedSincePrefetchComplete(
1293     int result) {
1294   // Restore the original value for this transaction.
1295   response_.unused_since_prefetch = !response_.unused_since_prefetch;
1296   next_state_ = STATE_CACHE_DISPATCH_VALIDATION;
1297   return OnWriteResponseInfoToEntryComplete(result);
1298 }
1299
1300 int HttpCache::Transaction::DoCacheDispatchValidation() {
1301   // We now have access to the cache entry.
1302   //
1303   //  o if we are a reader for the transaction, then we can start reading the
1304   //    cache entry.
1305   //
1306   //  o if we can read or write, then we should check if the cache entry needs
1307   //    to be validated and then issue a network request if needed or just read
1308   //    from the cache if the cache entry is already valid.
1309   //
1310   //  o if we are set to UPDATE, then we are handling an externally
1311   //    conditionalized request (if-modified-since / if-none-match). We check
1312   //    if the request headers define a validation request.
1313   //
1314   int result = ERR_FAILED;
1315   switch (mode_) {
1316     case READ:
1317       UpdateTransactionPattern(PATTERN_ENTRY_USED);
1318       result = BeginCacheRead();
1319       break;
1320     case READ_WRITE:
1321       result = BeginPartialCacheValidation();
1322       break;
1323     case UPDATE:
1324       result = BeginExternallyConditionalizedRequest();
1325       break;
1326     case WRITE:
1327     default:
1328       NOTREACHED();
1329   }
1330   return result;
1331 }
1332
1333 int HttpCache::Transaction::DoCacheQueryData() {
1334   next_state_ = STATE_CACHE_QUERY_DATA_COMPLETE;
1335   return entry_->disk_entry->ReadyForSparseIO(io_callback_);
1336 }
1337
1338 int HttpCache::Transaction::DoCacheQueryDataComplete(int result) {
1339   DCHECK_EQ(OK, result);
1340   if (!cache_.get())
1341     return ERR_UNEXPECTED;
1342
1343   return ValidateEntryHeadersAndContinue();
1344 }
1345
1346 // We may end up here multiple times for a given request.
1347 int HttpCache::Transaction::DoStartPartialCacheValidation() {
1348   if (mode_ == NONE)
1349     return OK;
1350
1351   next_state_ = STATE_COMPLETE_PARTIAL_CACHE_VALIDATION;
1352   return partial_->ShouldValidateCache(entry_->disk_entry, io_callback_);
1353 }
1354
1355 int HttpCache::Transaction::DoCompletePartialCacheValidation(int result) {
1356   if (!result) {
1357     // This is the end of the request.
1358     if (mode_ & WRITE) {
1359       DoneWritingToEntry(true);
1360     } else {
1361       cache_->DoneReadingFromEntry(entry_, this);
1362       entry_ = NULL;
1363     }
1364     return result;
1365   }
1366
1367   if (result < 0)
1368     return result;
1369
1370   partial_->PrepareCacheValidation(entry_->disk_entry,
1371                                    &custom_request_->extra_headers);
1372
1373   if (reading_ && partial_->IsCurrentRangeCached()) {
1374     next_state_ = STATE_CACHE_READ_DATA;
1375     return OK;
1376   }
1377
1378   return BeginCacheValidation();
1379 }
1380
1381 int HttpCache::Transaction::DoSendRequest() {
1382   DCHECK(mode_ & WRITE || mode_ == NONE);
1383   DCHECK(!network_trans_.get());
1384
1385   send_request_since_ = TimeTicks::Now();
1386
1387   // Create a network transaction.
1388   int rv =
1389       cache_->network_layer_->CreateTransaction(priority_, &network_trans_);
1390   if (rv != OK)
1391     return rv;
1392   network_trans_->SetBeforeNetworkStartCallback(before_network_start_callback_);
1393   network_trans_->SetBeforeProxyHeadersSentCallback(
1394       before_proxy_headers_sent_callback_);
1395
1396   // Old load timing information, if any, is now obsolete.
1397   old_network_trans_load_timing_.reset();
1398
1399   if (websocket_handshake_stream_base_create_helper_)
1400     network_trans_->SetWebSocketHandshakeStreamCreateHelper(
1401         websocket_handshake_stream_base_create_helper_);
1402
1403   next_state_ = STATE_SEND_REQUEST_COMPLETE;
1404   rv = network_trans_->Start(request_, io_callback_, net_log_);
1405   return rv;
1406 }
1407
1408 int HttpCache::Transaction::DoSendRequestComplete(int result) {
1409   if (!cache_.get())
1410     return ERR_UNEXPECTED;
1411
1412   // If we tried to conditionalize the request and failed, we know
1413   // we won't be reading from the cache after this point.
1414   if (couldnt_conditionalize_request_)
1415     mode_ = WRITE;
1416
1417   if (result == OK) {
1418     next_state_ = STATE_SUCCESSFUL_SEND_REQUEST;
1419     return OK;
1420   }
1421
1422   const HttpResponseInfo* response = network_trans_->GetResponseInfo();
1423   response_.network_accessed = response->network_accessed;
1424
1425   // Do not record requests that have network errors or restarts.
1426   UpdateTransactionPattern(PATTERN_NOT_COVERED);
1427   if (IsCertificateError(result)) {
1428     // If we get a certificate error, then there is a certificate in ssl_info,
1429     // so GetResponseInfo() should never return NULL here.
1430     DCHECK(response);
1431     response_.ssl_info = response->ssl_info;
1432   } else if (result == ERR_SSL_CLIENT_AUTH_CERT_NEEDED) {
1433     DCHECK(response);
1434     response_.cert_request_info = response->cert_request_info;
1435   } else if (response_.was_cached) {
1436     DoneWritingToEntry(true);
1437   }
1438
1439   return result;
1440 }
1441
1442 // We received the response headers and there is no error.
1443 int HttpCache::Transaction::DoSuccessfulSendRequest() {
1444   DCHECK(!new_response_);
1445   const HttpResponseInfo* new_response = network_trans_->GetResponseInfo();
1446
1447   if (new_response->headers->response_code() == 401 ||
1448       new_response->headers->response_code() == 407) {
1449     auth_response_ = *new_response;
1450     if (!reading_)
1451       return OK;
1452
1453     // We initiated a second request the caller doesn't know about. We should be
1454     // able to authenticate this request because we should have authenticated
1455     // this URL moments ago.
1456     if (IsReadyToRestartForAuth()) {
1457       DCHECK(!response_.auth_challenge.get());
1458       next_state_ = STATE_SEND_REQUEST_COMPLETE;
1459       // In theory we should check to see if there are new cookies, but there
1460       // is no way to do that from here.
1461       return network_trans_->RestartWithAuth(AuthCredentials(), io_callback_);
1462     }
1463
1464     // We have to perform cleanup at this point so that at least the next
1465     // request can succeed.  We do not retry at this point, because data
1466     // has been read and we have no way to gather credentials.  We would
1467     // fail again, and potentially loop.  This can happen if the credentials
1468     // expire while chrome is suspended.
1469     if (entry_)
1470       DoomPartialEntry(false);
1471     mode_ = NONE;
1472     partial_.reset();
1473     ResetNetworkTransaction();
1474     return ERR_CACHE_AUTH_FAILURE_AFTER_READ;
1475   }
1476
1477   new_response_ = new_response;
1478   if (!ValidatePartialResponse() && !auth_response_.headers.get()) {
1479     // Something went wrong with this request and we have to restart it.
1480     // If we have an authentication response, we are exposed to weird things
1481     // hapenning if the user cancels the authentication before we receive
1482     // the new response.
1483     net_log_.AddEvent(NetLog::TYPE_HTTP_CACHE_RE_SEND_PARTIAL_REQUEST);
1484     UpdateTransactionPattern(PATTERN_NOT_COVERED);
1485     response_ = HttpResponseInfo();
1486     ResetNetworkTransaction();
1487     new_response_ = NULL;
1488     next_state_ = STATE_SEND_REQUEST;
1489     return OK;
1490   }
1491
1492   if (handling_206_ && mode_ == READ_WRITE && !truncated_ && !is_sparse_) {
1493     // We have stored the full entry, but it changed and the server is
1494     // sending a range. We have to delete the old entry.
1495     UpdateTransactionPattern(PATTERN_NOT_COVERED);
1496     DoneWritingToEntry(false);
1497   }
1498
1499   if (mode_ == WRITE &&
1500       transaction_pattern_ != PATTERN_ENTRY_CANT_CONDITIONALIZE) {
1501     UpdateTransactionPattern(PATTERN_ENTRY_NOT_CACHED);
1502   }
1503
1504   // Invalidate any cached GET with a successful PUT or DELETE.
1505   if (mode_ == WRITE &&
1506       (request_->method == "PUT" || request_->method == "DELETE")) {
1507     if (NonErrorResponse(new_response->headers->response_code())) {
1508       int ret = cache_->DoomEntry(cache_key_, NULL);
1509       DCHECK_EQ(OK, ret);
1510     }
1511     cache_->DoneWritingToEntry(entry_, true);
1512     entry_ = NULL;
1513     mode_ = NONE;
1514   }
1515
1516   // Invalidate any cached GET with a successful POST.
1517   if (!(effective_load_flags_ & LOAD_DISABLE_CACHE) &&
1518       request_->method == "POST" &&
1519       NonErrorResponse(new_response->headers->response_code())) {
1520     cache_->DoomMainEntryForUrl(request_->url);
1521   }
1522
1523   RecordNoStoreHeaderHistogram(request_->load_flags, new_response);
1524
1525   if (new_response_->headers->response_code() == 416 &&
1526       (request_->method == "GET" || request_->method == "POST")) {
1527     // If there is an active entry it may be destroyed with this transaction.
1528     response_ = *new_response_;
1529     return OK;
1530   }
1531
1532   // Are we expecting a response to a conditional query?
1533   if (mode_ == READ_WRITE || mode_ == UPDATE) {
1534     if (new_response->headers->response_code() == 304 || handling_206_) {
1535       UpdateTransactionPattern(PATTERN_ENTRY_VALIDATED);
1536       next_state_ = STATE_UPDATE_CACHED_RESPONSE;
1537       return OK;
1538     }
1539     UpdateTransactionPattern(PATTERN_ENTRY_UPDATED);
1540     mode_ = WRITE;
1541   }
1542
1543   next_state_ = STATE_OVERWRITE_CACHED_RESPONSE;
1544   return OK;
1545 }
1546
1547 // We received 304 or 206 and we want to update the cached response headers.
1548 int HttpCache::Transaction::DoUpdateCachedResponse() {
1549   next_state_ = STATE_UPDATE_CACHED_RESPONSE_COMPLETE;
1550   int rv = OK;
1551   // Update the cached response based on the headers and properties of
1552   // new_response_.
1553   response_.headers->Update(*new_response_->headers.get());
1554   response_.response_time = new_response_->response_time;
1555   response_.request_time = new_response_->request_time;
1556   response_.network_accessed = new_response_->network_accessed;
1557   response_.unused_since_prefetch = new_response_->unused_since_prefetch;
1558   response_.ssl_info = new_response_->ssl_info;
1559   if (new_response_->vary_data.is_valid()) {
1560     response_.vary_data = new_response_->vary_data;
1561   } else if (response_.vary_data.is_valid()) {
1562     // There is a vary header in the stored response but not in the current one.
1563     // Update the data with the new request headers.
1564     HttpVaryData new_vary_data;
1565     new_vary_data.Init(*request_, *response_.headers.get());
1566     response_.vary_data = new_vary_data;
1567   }
1568
1569   if (response_.headers->HasHeaderValue("cache-control", "no-store")) {
1570     if (!entry_->doomed) {
1571       int ret = cache_->DoomEntry(cache_key_, NULL);
1572       DCHECK_EQ(OK, ret);
1573     }
1574   } else {
1575     // If we are already reading, we already updated the headers for this
1576     // request; doing it again will change Content-Length.
1577     if (!reading_) {
1578       next_state_ = STATE_CACHE_WRITE_UPDATED_RESPONSE;
1579       rv = OK;
1580     }
1581   }
1582   return rv;
1583 }
1584
1585 int HttpCache::Transaction::DoCacheWriteUpdatedResponse() {
1586   // TODO(rtenneti): Remove ScopedTracker below once crbug.com/422516 is fixed.
1587   tracked_objects::ScopedTracker tracking_profile(
1588       FROM_HERE_WITH_EXPLICIT_FUNCTION(
1589           "422516 HttpCache::Transaction::DoCacheWriteUpdatedResponse"));
1590
1591   next_state_ = STATE_CACHE_WRITE_UPDATED_RESPONSE_COMPLETE;
1592   return WriteResponseInfoToEntry(false);
1593 }
1594
1595 int HttpCache::Transaction::DoCacheWriteUpdatedResponseComplete(int result) {
1596   next_state_ = STATE_UPDATE_CACHED_RESPONSE_COMPLETE;
1597   return OnWriteResponseInfoToEntryComplete(result);
1598 }
1599
1600 int HttpCache::Transaction::DoUpdateCachedResponseComplete(int result) {
1601   if (mode_ == UPDATE) {
1602     DCHECK(!handling_206_);
1603     // We got a "not modified" response and already updated the corresponding
1604     // cache entry above.
1605     //
1606     // By closing the cached entry now, we make sure that the 304 rather than
1607     // the cached 200 response, is what will be returned to the user.
1608     DoneWritingToEntry(true);
1609   } else if (entry_ && !handling_206_) {
1610     DCHECK_EQ(READ_WRITE, mode_);
1611     if (!partial_ || partial_->IsLastRange()) {
1612       cache_->ConvertWriterToReader(entry_);
1613       mode_ = READ;
1614     }
1615     // We no longer need the network transaction, so destroy it.
1616     final_upload_progress_ = network_trans_->GetUploadProgress();
1617     ResetNetworkTransaction();
1618   } else if (entry_ && handling_206_ && truncated_ &&
1619              partial_->initial_validation()) {
1620     // We just finished the validation of a truncated entry, and the server
1621     // is willing to resume the operation. Now we go back and start serving
1622     // the first part to the user.
1623     ResetNetworkTransaction();
1624     new_response_ = NULL;
1625     next_state_ = STATE_START_PARTIAL_CACHE_VALIDATION;
1626     partial_->SetRangeToStartDownload();
1627     return OK;
1628   }
1629   next_state_ = STATE_OVERWRITE_CACHED_RESPONSE;
1630   return OK;
1631 }
1632
1633 int HttpCache::Transaction::DoOverwriteCachedResponse() {
1634   if (mode_ & READ) {
1635     next_state_ = STATE_PARTIAL_HEADERS_RECEIVED;
1636     return OK;
1637   }
1638
1639   // We change the value of Content-Length for partial content.
1640   if (handling_206_ && partial_)
1641     partial_->FixContentLength(new_response_->headers.get());
1642
1643   response_ = *new_response_;
1644
1645   if (request_->method == "HEAD") {
1646     // This response is replacing the cached one.
1647     DoneWritingToEntry(false);
1648     mode_ = NONE;
1649     new_response_ = NULL;
1650     return OK;
1651   }
1652
1653   if (handling_206_ && !CanResume(false)) {
1654     // There is no point in storing this resource because it will never be used.
1655     // This may change if we support LOAD_ONLY_FROM_CACHE with sparse entries.
1656     DoneWritingToEntry(false);
1657     if (partial_)
1658       partial_->FixResponseHeaders(response_.headers.get(), true);
1659     next_state_ = STATE_PARTIAL_HEADERS_RECEIVED;
1660     return OK;
1661   }
1662
1663   next_state_ = STATE_CACHE_WRITE_RESPONSE;
1664   return OK;
1665 }
1666
1667 int HttpCache::Transaction::DoCacheWriteResponse() {
1668   // TODO(rtenneti): Remove ScopedTracker below once crbug.com/422516 is fixed.
1669   tracked_objects::ScopedTracker tracking_profile(
1670       FROM_HERE_WITH_EXPLICIT_FUNCTION(
1671           "422516 HttpCache::Transaction::DoCacheWriteResponse"));
1672
1673   next_state_ = STATE_CACHE_WRITE_RESPONSE_COMPLETE;
1674   return WriteResponseInfoToEntry(truncated_);
1675 }
1676
1677 int HttpCache::Transaction::DoCacheWriteResponseComplete(int result) {
1678   next_state_ = STATE_TRUNCATE_CACHED_DATA;
1679   return OnWriteResponseInfoToEntryComplete(result);
1680 }
1681
1682 int HttpCache::Transaction::DoTruncateCachedData() {
1683   next_state_ = STATE_TRUNCATE_CACHED_DATA_COMPLETE;
1684   if (!entry_)
1685     return OK;
1686   if (net_log_.IsCapturing())
1687     net_log_.BeginEvent(NetLog::TYPE_HTTP_CACHE_WRITE_DATA);
1688   // Truncate the stream.
1689   return WriteToEntry(kResponseContentIndex, 0, NULL, 0, io_callback_);
1690 }
1691
1692 int HttpCache::Transaction::DoTruncateCachedDataComplete(int result) {
1693   if (entry_) {
1694     if (net_log_.IsCapturing()) {
1695       net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_CACHE_WRITE_DATA,
1696                                         result);
1697     }
1698   }
1699
1700   next_state_ = STATE_TRUNCATE_CACHED_METADATA;
1701   return OK;
1702 }
1703
1704 int HttpCache::Transaction::DoTruncateCachedMetadata() {
1705   next_state_ = STATE_TRUNCATE_CACHED_METADATA_COMPLETE;
1706   if (!entry_)
1707     return OK;
1708
1709   if (net_log_.IsCapturing())
1710     net_log_.BeginEvent(NetLog::TYPE_HTTP_CACHE_WRITE_INFO);
1711   return WriteToEntry(kMetadataIndex, 0, NULL, 0, io_callback_);
1712 }
1713
1714 int HttpCache::Transaction::DoTruncateCachedMetadataComplete(int result) {
1715   if (entry_) {
1716     if (net_log_.IsCapturing()) {
1717       net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_CACHE_WRITE_INFO,
1718                                         result);
1719     }
1720   }
1721
1722   next_state_ = STATE_PARTIAL_HEADERS_RECEIVED;
1723   return OK;
1724 }
1725
1726 int HttpCache::Transaction::DoPartialHeadersReceived() {
1727   new_response_ = NULL;
1728   if (entry_ && !partial_ && entry_->disk_entry->GetDataSize(kMetadataIndex))
1729     next_state_ = STATE_CACHE_READ_METADATA;
1730
1731   if (!partial_)
1732     return OK;
1733
1734   if (reading_) {
1735     if (network_trans_.get()) {
1736       next_state_ = STATE_NETWORK_READ;
1737     } else {
1738       next_state_ = STATE_CACHE_READ_DATA;
1739     }
1740   } else if (mode_ != NONE) {
1741     // We are about to return the headers for a byte-range request to the user,
1742     // so let's fix them.
1743     partial_->FixResponseHeaders(response_.headers.get(), true);
1744   }
1745   return OK;
1746 }
1747
1748 int HttpCache::Transaction::DoCacheReadMetadata() {
1749   DCHECK(entry_);
1750   DCHECK(!response_.metadata.get());
1751   next_state_ = STATE_CACHE_READ_METADATA_COMPLETE;
1752
1753   response_.metadata =
1754       new IOBufferWithSize(entry_->disk_entry->GetDataSize(kMetadataIndex));
1755
1756   net_log_.BeginEvent(NetLog::TYPE_HTTP_CACHE_READ_INFO);
1757   return entry_->disk_entry->ReadData(kMetadataIndex, 0,
1758                                       response_.metadata.get(),
1759                                       response_.metadata->size(),
1760                                       io_callback_);
1761 }
1762
1763 int HttpCache::Transaction::DoCacheReadMetadataComplete(int result) {
1764   net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_CACHE_READ_INFO, result);
1765   if (result != response_.metadata->size())
1766     return OnCacheReadError(result, false);
1767   return OK;
1768 }
1769
1770 int HttpCache::Transaction::DoNetworkRead() {
1771   next_state_ = STATE_NETWORK_READ_COMPLETE;
1772   return network_trans_->Read(read_buf_.get(), io_buf_len_, io_callback_);
1773 }
1774
1775 int HttpCache::Transaction::DoNetworkReadComplete(int result) {
1776   DCHECK(mode_ & WRITE || mode_ == NONE);
1777
1778   if (!cache_.get())
1779     return ERR_UNEXPECTED;
1780
1781   // If there is an error or we aren't saving the data, we are done; just wait
1782   // until the destructor runs to see if we can keep the data.
1783   if (mode_ == NONE || result < 0)
1784     return result;
1785
1786   next_state_ = STATE_CACHE_WRITE_DATA;
1787   return result;
1788 }
1789
1790 int HttpCache::Transaction::DoCacheReadData() {
1791   if (request_->method == "HEAD")
1792     return 0;
1793
1794   DCHECK(entry_);
1795   next_state_ = STATE_CACHE_READ_DATA_COMPLETE;
1796
1797   if (net_log_.IsCapturing())
1798     net_log_.BeginEvent(NetLog::TYPE_HTTP_CACHE_READ_DATA);
1799   if (partial_) {
1800     return partial_->CacheRead(entry_->disk_entry, read_buf_.get(), io_buf_len_,
1801                                io_callback_);
1802   }
1803
1804   return entry_->disk_entry->ReadData(kResponseContentIndex, read_offset_,
1805                                       read_buf_.get(), io_buf_len_,
1806                                       io_callback_);
1807 }
1808
1809 int HttpCache::Transaction::DoCacheReadDataComplete(int result) {
1810   if (net_log_.IsCapturing()) {
1811     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_CACHE_READ_DATA,
1812                                       result);
1813   }
1814
1815   if (!cache_.get())
1816     return ERR_UNEXPECTED;
1817
1818   if (partial_) {
1819     // Partial requests are confusing to report in histograms because they may
1820     // have multiple underlying requests.
1821     UpdateTransactionPattern(PATTERN_NOT_COVERED);
1822     return DoPartialCacheReadCompleted(result);
1823   }
1824
1825   if (result > 0) {
1826     read_offset_ += result;
1827   } else if (result == 0) {  // End of file.
1828     RecordHistograms();
1829     cache_->DoneReadingFromEntry(entry_, this);
1830     entry_ = NULL;
1831   } else {
1832     return OnCacheReadError(result, false);
1833   }
1834   return result;
1835 }
1836
1837 int HttpCache::Transaction::DoCacheWriteData(int num_bytes) {
1838   next_state_ = STATE_CACHE_WRITE_DATA_COMPLETE;
1839   write_len_ = num_bytes;
1840   if (entry_) {
1841     if (net_log_.IsCapturing())
1842       net_log_.BeginEvent(NetLog::TYPE_HTTP_CACHE_WRITE_DATA);
1843   }
1844
1845   if (!entry_ || !num_bytes)
1846     return num_bytes;
1847
1848   int current_size = entry_->disk_entry->GetDataSize(kResponseContentIndex);
1849   return WriteToEntry(kResponseContentIndex, current_size, read_buf_.get(),
1850                       num_bytes, io_callback_);
1851 }
1852
1853 int HttpCache::Transaction::DoCacheWriteDataComplete(int result) {
1854   if (entry_) {
1855     if (net_log_.IsCapturing()) {
1856       net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_CACHE_WRITE_DATA,
1857                                         result);
1858     }
1859   }
1860   if (!cache_.get())
1861     return ERR_UNEXPECTED;
1862
1863   if (result != write_len_) {
1864     DLOG(ERROR) << "failed to write response data to cache";
1865     DoneWritingToEntry(false);
1866
1867     // We want to ignore errors writing to disk and just keep reading from
1868     // the network.
1869     result = write_len_;
1870   } else if (!done_reading_ && entry_) {
1871     int current_size = entry_->disk_entry->GetDataSize(kResponseContentIndex);
1872     int64 body_size = response_.headers->GetContentLength();
1873     if (body_size >= 0 && body_size <= current_size)
1874       done_reading_ = true;
1875   }
1876
1877   if (partial_) {
1878     // This may be the last request.
1879     if (result != 0 || truncated_ ||
1880         !(partial_->IsLastRange() || mode_ == WRITE)) {
1881       return DoPartialNetworkReadCompleted(result);
1882     }
1883   }
1884
1885   if (result == 0) {
1886     // End of file. This may be the result of a connection problem so see if we
1887     // have to keep the entry around to be flagged as truncated later on.
1888     if (done_reading_ || !entry_ || partial_ ||
1889         response_.headers->GetContentLength() <= 0) {
1890       DoneWritingToEntry(true);
1891     }
1892   }
1893
1894   return result;
1895 }
1896
1897 int HttpCache::Transaction::DoCacheWriteTruncatedResponse() {
1898   next_state_ = STATE_CACHE_WRITE_TRUNCATED_RESPONSE_COMPLETE;
1899   return WriteResponseInfoToEntry(true);
1900 }
1901
1902 int HttpCache::Transaction::DoCacheWriteTruncatedResponseComplete(int result) {
1903   return OnWriteResponseInfoToEntryComplete(result);
1904 }
1905
1906 //-----------------------------------------------------------------------------
1907
1908 void HttpCache::Transaction::ReadCertChain() {
1909   std::string key =
1910       GetCacheKeyForCert(response_.ssl_info.cert->os_cert_handle());
1911   const X509Certificate::OSCertHandles& intermediates =
1912       response_.ssl_info.cert->GetIntermediateCertificates();
1913   int dist_from_root = intermediates.size();
1914
1915   scoped_refptr<SharedChainData> shared_chain_data(
1916       new SharedChainData(intermediates.size() + 1, TimeTicks::Now()));
1917   cache_->cert_cache()->GetCertificate(key,
1918                                        base::Bind(&OnCertReadIOComplete,
1919                                                   dist_from_root,
1920                                                   true /* is leaf */,
1921                                                   shared_chain_data));
1922
1923   for (X509Certificate::OSCertHandles::const_iterator it =
1924            intermediates.begin();
1925        it != intermediates.end();
1926        ++it) {
1927     --dist_from_root;
1928     key = GetCacheKeyForCert(*it);
1929     cache_->cert_cache()->GetCertificate(key,
1930                                          base::Bind(&OnCertReadIOComplete,
1931                                                     dist_from_root,
1932                                                     false /* is not leaf */,
1933                                                     shared_chain_data));
1934   }
1935   DCHECK_EQ(0, dist_from_root);
1936 }
1937
1938 void HttpCache::Transaction::WriteCertChain() {
1939   const X509Certificate::OSCertHandles& intermediates =
1940       response_.ssl_info.cert->GetIntermediateCertificates();
1941   int dist_from_root = intermediates.size();
1942
1943   scoped_refptr<SharedChainData> shared_chain_data(
1944       new SharedChainData(intermediates.size() + 1, TimeTicks::Now()));
1945   cache_->cert_cache()->SetCertificate(
1946       response_.ssl_info.cert->os_cert_handle(),
1947       base::Bind(&OnCertWriteIOComplete,
1948                  dist_from_root,
1949                  true /* is leaf */,
1950                  shared_chain_data));
1951   for (X509Certificate::OSCertHandles::const_iterator it =
1952            intermediates.begin();
1953        it != intermediates.end();
1954        ++it) {
1955     --dist_from_root;
1956     cache_->cert_cache()->SetCertificate(*it,
1957                                          base::Bind(&OnCertWriteIOComplete,
1958                                                     dist_from_root,
1959                                                     false /* is not leaf */,
1960                                                     shared_chain_data));
1961   }
1962   DCHECK_EQ(0, dist_from_root);
1963 }
1964
1965 void HttpCache::Transaction::SetRequest(const BoundNetLog& net_log,
1966                                         const HttpRequestInfo* request) {
1967   net_log_ = net_log;
1968   request_ = request;
1969   effective_load_flags_ = request_->load_flags;
1970
1971   if (cache_->mode() == DISABLE)
1972     effective_load_flags_ |= LOAD_DISABLE_CACHE;
1973
1974   // Some headers imply load flags.  The order here is significant.
1975   //
1976   //   LOAD_DISABLE_CACHE   : no cache read or write
1977   //   LOAD_BYPASS_CACHE    : no cache read
1978   //   LOAD_VALIDATE_CACHE  : no cache read unless validation
1979   //
1980   // The former modes trump latter modes, so if we find a matching header we
1981   // can stop iterating kSpecialHeaders.
1982   //
1983   static const struct {
1984     const HeaderNameAndValue* search;
1985     int load_flag;
1986   } kSpecialHeaders[] = {
1987     { kPassThroughHeaders, LOAD_DISABLE_CACHE },
1988     { kForceFetchHeaders, LOAD_BYPASS_CACHE },
1989     { kForceValidateHeaders, LOAD_VALIDATE_CACHE },
1990   };
1991
1992   bool range_found = false;
1993   bool external_validation_error = false;
1994   bool special_headers = false;
1995
1996   if (request_->extra_headers.HasHeader(HttpRequestHeaders::kRange))
1997     range_found = true;
1998
1999   for (size_t i = 0; i < arraysize(kSpecialHeaders); ++i) {
2000     if (HeaderMatches(request_->extra_headers, kSpecialHeaders[i].search)) {
2001       effective_load_flags_ |= kSpecialHeaders[i].load_flag;
2002       special_headers = true;
2003       break;
2004     }
2005   }
2006
2007   // Check for conditionalization headers which may correspond with a
2008   // cache validation request.
2009   for (size_t i = 0; i < arraysize(kValidationHeaders); ++i) {
2010     const ValidationHeaderInfo& info = kValidationHeaders[i];
2011     std::string validation_value;
2012     if (request_->extra_headers.GetHeader(
2013             info.request_header_name, &validation_value)) {
2014       if (!external_validation_.values[i].empty() ||
2015           validation_value.empty()) {
2016         external_validation_error = true;
2017       }
2018       external_validation_.values[i] = validation_value;
2019       external_validation_.initialized = true;
2020     }
2021   }
2022
2023   if (range_found || special_headers || external_validation_.initialized) {
2024     // Log the headers before request_ is modified.
2025     std::string empty;
2026     net_log_.AddEvent(
2027         NetLog::TYPE_HTTP_CACHE_CALLER_REQUEST_HEADERS,
2028         base::Bind(&HttpRequestHeaders::NetLogCallback,
2029                    base::Unretained(&request_->extra_headers), &empty));
2030   }
2031
2032   // We don't support ranges and validation headers.
2033   if (range_found && external_validation_.initialized) {
2034     LOG(WARNING) << "Byte ranges AND validation headers found.";
2035     effective_load_flags_ |= LOAD_DISABLE_CACHE;
2036   }
2037
2038   // If there is more than one validation header, we can't treat this request as
2039   // a cache validation, since we don't know for sure which header the server
2040   // will give us a response for (and they could be contradictory).
2041   if (external_validation_error) {
2042     LOG(WARNING) << "Multiple or malformed validation headers found.";
2043     effective_load_flags_ |= LOAD_DISABLE_CACHE;
2044   }
2045
2046   if (range_found && !(effective_load_flags_ & LOAD_DISABLE_CACHE)) {
2047     UpdateTransactionPattern(PATTERN_NOT_COVERED);
2048     partial_.reset(new PartialData);
2049     if (request_->method == "GET" && partial_->Init(request_->extra_headers)) {
2050       // We will be modifying the actual range requested to the server, so
2051       // let's remove the header here.
2052       custom_request_.reset(new HttpRequestInfo(*request_));
2053       custom_request_->extra_headers.RemoveHeader(HttpRequestHeaders::kRange);
2054       request_ = custom_request_.get();
2055       partial_->SetHeaders(custom_request_->extra_headers);
2056     } else {
2057       // The range is invalid or we cannot handle it properly.
2058       VLOG(1) << "Invalid byte range found.";
2059       effective_load_flags_ |= LOAD_DISABLE_CACHE;
2060       partial_.reset(NULL);
2061     }
2062   }
2063 }
2064
2065 bool HttpCache::Transaction::ShouldPassThrough() {
2066   // We may have a null disk_cache if there is an error we cannot recover from,
2067   // like not enough disk space, or sharing violations.
2068   if (!cache_->disk_cache_.get())
2069     return true;
2070
2071   if (effective_load_flags_ & LOAD_DISABLE_CACHE)
2072     return true;
2073
2074   if (request_->method == "GET" || request_->method == "HEAD")
2075     return false;
2076
2077   if (request_->method == "POST" && request_->upload_data_stream &&
2078       request_->upload_data_stream->identifier()) {
2079     return false;
2080   }
2081
2082   if (request_->method == "PUT" && request_->upload_data_stream)
2083     return false;
2084
2085   if (request_->method == "DELETE")
2086     return false;
2087
2088   return true;
2089 }
2090
2091 int HttpCache::Transaction::BeginCacheRead() {
2092   // We don't support any combination of LOAD_ONLY_FROM_CACHE and byte ranges.
2093   if (response_.headers->response_code() == 206 || partial_) {
2094     NOTREACHED();
2095     return ERR_CACHE_MISS;
2096   }
2097
2098   if (request_->method == "HEAD")
2099     FixHeadersForHead();
2100
2101   // We don't have the whole resource.
2102   if (truncated_)
2103     return ERR_CACHE_MISS;
2104
2105   if (entry_->disk_entry->GetDataSize(kMetadataIndex))
2106     next_state_ = STATE_CACHE_READ_METADATA;
2107
2108   return OK;
2109 }
2110
2111 int HttpCache::Transaction::BeginCacheValidation() {
2112   DCHECK_EQ(mode_, READ_WRITE);
2113
2114   ValidationType required_validation = RequiresValidation();
2115
2116   bool skip_validation = (required_validation == VALIDATION_NONE);
2117
2118   if ((effective_load_flags_ & LOAD_SUPPORT_ASYNC_REVALIDATION) &&
2119       required_validation == VALIDATION_ASYNCHRONOUS) {
2120     DCHECK_EQ(request_->method, "GET");
2121     skip_validation = true;
2122     response_.async_revalidation_required = true;
2123   }
2124
2125   if (request_->method == "HEAD" &&
2126       (truncated_ || response_.headers->response_code() == 206)) {
2127     DCHECK(!partial_);
2128     if (skip_validation)
2129       return SetupEntryForRead();
2130
2131     // Bail out!
2132     next_state_ = STATE_SEND_REQUEST;
2133     mode_ = NONE;
2134     return OK;
2135   }
2136
2137   if (truncated_) {
2138     // Truncated entries can cause partial gets, so we shouldn't record this
2139     // load in histograms.
2140     UpdateTransactionPattern(PATTERN_NOT_COVERED);
2141     skip_validation = !partial_->initial_validation();
2142   }
2143
2144   if (partial_ && (is_sparse_ || truncated_) &&
2145       (!partial_->IsCurrentRangeCached() || invalid_range_)) {
2146     // Force revalidation for sparse or truncated entries. Note that we don't
2147     // want to ignore the regular validation logic just because a byte range was
2148     // part of the request.
2149     skip_validation = false;
2150   }
2151
2152   if (skip_validation) {
2153     UpdateTransactionPattern(PATTERN_ENTRY_USED);
2154     return SetupEntryForRead();
2155   } else {
2156     // Make the network request conditional, to see if we may reuse our cached
2157     // response.  If we cannot do so, then we just resort to a normal fetch.
2158     // Our mode remains READ_WRITE for a conditional request.  Even if the
2159     // conditionalization fails, we don't switch to WRITE mode until we
2160     // know we won't be falling back to using the cache entry in the
2161     // LOAD_FROM_CACHE_IF_OFFLINE case.
2162     if (!ConditionalizeRequest()) {
2163       couldnt_conditionalize_request_ = true;
2164       UpdateTransactionPattern(PATTERN_ENTRY_CANT_CONDITIONALIZE);
2165       if (partial_)
2166         return DoRestartPartialRequest();
2167
2168       DCHECK_NE(206, response_.headers->response_code());
2169     }
2170     next_state_ = STATE_SEND_REQUEST;
2171   }
2172   return OK;
2173 }
2174
2175 int HttpCache::Transaction::BeginPartialCacheValidation() {
2176   DCHECK_EQ(mode_, READ_WRITE);
2177
2178   if (response_.headers->response_code() != 206 && !partial_ && !truncated_)
2179     return BeginCacheValidation();
2180
2181   // Partial requests should not be recorded in histograms.
2182   UpdateTransactionPattern(PATTERN_NOT_COVERED);
2183   if (request_->method == "HEAD")
2184     return BeginCacheValidation();
2185
2186   if (!range_requested_) {
2187     // The request is not for a range, but we have stored just ranges.
2188
2189     partial_.reset(new PartialData());
2190     partial_->SetHeaders(request_->extra_headers);
2191     if (!custom_request_.get()) {
2192       custom_request_.reset(new HttpRequestInfo(*request_));
2193       request_ = custom_request_.get();
2194     }
2195   }
2196
2197   next_state_ = STATE_CACHE_QUERY_DATA;
2198   return OK;
2199 }
2200
2201 // This should only be called once per request.
2202 int HttpCache::Transaction::ValidateEntryHeadersAndContinue() {
2203   DCHECK_EQ(mode_, READ_WRITE);
2204
2205   if (!partial_->UpdateFromStoredHeaders(
2206           response_.headers.get(), entry_->disk_entry, truncated_)) {
2207     return DoRestartPartialRequest();
2208   }
2209
2210   if (response_.headers->response_code() == 206)
2211     is_sparse_ = true;
2212
2213   if (!partial_->IsRequestedRangeOK()) {
2214     // The stored data is fine, but the request may be invalid.
2215     invalid_range_ = true;
2216   }
2217
2218   next_state_ = STATE_START_PARTIAL_CACHE_VALIDATION;
2219   return OK;
2220 }
2221
2222 int HttpCache::Transaction::BeginExternallyConditionalizedRequest() {
2223   DCHECK_EQ(UPDATE, mode_);
2224   DCHECK(external_validation_.initialized);
2225
2226   for (size_t i = 0;  i < arraysize(kValidationHeaders); i++) {
2227     if (external_validation_.values[i].empty())
2228       continue;
2229     // Retrieve either the cached response's "etag" or "last-modified" header.
2230     std::string validator;
2231     response_.headers->EnumerateHeader(
2232         NULL,
2233         kValidationHeaders[i].related_response_header_name,
2234         &validator);
2235
2236     if (response_.headers->response_code() != 200 || truncated_ ||
2237         validator.empty() || validator != external_validation_.values[i]) {
2238       // The externally conditionalized request is not a validation request
2239       // for our existing cache entry. Proceed with caching disabled.
2240       UpdateTransactionPattern(PATTERN_NOT_COVERED);
2241       DoneWritingToEntry(true);
2242     }
2243   }
2244
2245   // TODO(ricea): This calculation is expensive to perform just to collect
2246   // statistics. Either remove it or use the result, depending on the result of
2247   // the experiment.
2248   ExternallyConditionalizedType type =
2249       EXTERNALLY_CONDITIONALIZED_CACHE_USABLE;
2250   if (mode_ == NONE)
2251     type = EXTERNALLY_CONDITIONALIZED_MISMATCHED_VALIDATORS;
2252   else if (RequiresValidation() != VALIDATION_NONE)
2253     type = EXTERNALLY_CONDITIONALIZED_CACHE_REQUIRES_VALIDATION;
2254
2255   // TODO(ricea): Add CACHE_USABLE_STALE once stale-while-revalidate CL landed.
2256   // TODO(ricea): Either remove this histogram or make it permanent by M40.
2257   UMA_HISTOGRAM_ENUMERATION("HttpCache.ExternallyConditionalized",
2258                             type,
2259                             EXTERNALLY_CONDITIONALIZED_MAX);
2260
2261   next_state_ = STATE_SEND_REQUEST;
2262   return OK;
2263 }
2264
2265 int HttpCache::Transaction::RestartNetworkRequest() {
2266   DCHECK(mode_ & WRITE || mode_ == NONE);
2267   DCHECK(network_trans_.get());
2268   DCHECK_EQ(STATE_NONE, next_state_);
2269
2270   next_state_ = STATE_SEND_REQUEST_COMPLETE;
2271   int rv = network_trans_->RestartIgnoringLastError(io_callback_);
2272   if (rv != ERR_IO_PENDING)
2273     return DoLoop(rv);
2274   return rv;
2275 }
2276
2277 int HttpCache::Transaction::RestartNetworkRequestWithCertificate(
2278     X509Certificate* client_cert) {
2279   DCHECK(mode_ & WRITE || mode_ == NONE);
2280   DCHECK(network_trans_.get());
2281   DCHECK_EQ(STATE_NONE, next_state_);
2282
2283   next_state_ = STATE_SEND_REQUEST_COMPLETE;
2284   int rv = network_trans_->RestartWithCertificate(client_cert, io_callback_);
2285   if (rv != ERR_IO_PENDING)
2286     return DoLoop(rv);
2287   return rv;
2288 }
2289
2290 int HttpCache::Transaction::RestartNetworkRequestWithAuth(
2291     const AuthCredentials& credentials) {
2292   DCHECK(mode_ & WRITE || mode_ == NONE);
2293   DCHECK(network_trans_.get());
2294   DCHECK_EQ(STATE_NONE, next_state_);
2295
2296   next_state_ = STATE_SEND_REQUEST_COMPLETE;
2297   int rv = network_trans_->RestartWithAuth(credentials, io_callback_);
2298   if (rv != ERR_IO_PENDING)
2299     return DoLoop(rv);
2300   return rv;
2301 }
2302
2303 ValidationType HttpCache::Transaction::RequiresValidation() {
2304   // TODO(darin): need to do more work here:
2305   //  - make sure we have a matching request method
2306   //  - watch out for cached responses that depend on authentication
2307
2308   if (response_.vary_data.is_valid() &&
2309       !response_.vary_data.MatchesRequest(*request_,
2310                                           *response_.headers.get())) {
2311     vary_mismatch_ = true;
2312     return VALIDATION_SYNCHRONOUS;
2313   }
2314
2315   if (effective_load_flags_ & LOAD_PREFERRING_CACHE)
2316     return VALIDATION_NONE;
2317
2318   if (response_.unused_since_prefetch &&
2319       !(effective_load_flags_ & LOAD_PREFETCH) &&
2320       response_.headers->GetCurrentAge(
2321           response_.request_time, response_.response_time,
2322           cache_->clock_->Now()) < TimeDelta::FromMinutes(kPrefetchReuseMins)) {
2323     // The first use of a resource after prefetch within a short window skips
2324     // validation.
2325     return VALIDATION_NONE;
2326   }
2327
2328   if (effective_load_flags_ & LOAD_VALIDATE_CACHE)
2329     return VALIDATION_SYNCHRONOUS;
2330
2331   if (request_->method == "PUT" || request_->method == "DELETE")
2332     return VALIDATION_SYNCHRONOUS;
2333
2334   ValidationType validation_required_by_headers =
2335       response_.headers->RequiresValidation(response_.request_time,
2336                                             response_.response_time,
2337                                             cache_->clock_->Now());
2338
2339   if (validation_required_by_headers == VALIDATION_ASYNCHRONOUS) {
2340     // Asynchronous revalidation is only supported for GET and HEAD methods.
2341     if (request_->method != "GET" && request_->method != "HEAD")
2342       return VALIDATION_SYNCHRONOUS;
2343   }
2344
2345   return validation_required_by_headers;
2346 }
2347
2348 bool HttpCache::Transaction::ConditionalizeRequest() {
2349   DCHECK(response_.headers.get());
2350
2351   if (request_->method == "PUT" || request_->method == "DELETE")
2352     return false;
2353
2354   // This only makes sense for cached 200 or 206 responses.
2355   if (response_.headers->response_code() != 200 &&
2356       response_.headers->response_code() != 206) {
2357     return false;
2358   }
2359
2360   if (fail_conditionalization_for_test_)
2361     return false;
2362
2363   DCHECK(response_.headers->response_code() != 206 ||
2364          response_.headers->HasStrongValidators());
2365
2366   // Just use the first available ETag and/or Last-Modified header value.
2367   // TODO(darin): Or should we use the last?
2368
2369   std::string etag_value;
2370   if (response_.headers->GetHttpVersion() >= HttpVersion(1, 1))
2371     response_.headers->EnumerateHeader(NULL, "etag", &etag_value);
2372
2373   std::string last_modified_value;
2374   if (!vary_mismatch_) {
2375     response_.headers->EnumerateHeader(NULL, "last-modified",
2376                                        &last_modified_value);
2377   }
2378
2379   if (etag_value.empty() && last_modified_value.empty())
2380     return false;
2381
2382   if (!partial_) {
2383     // Need to customize the request, so this forces us to allocate :(
2384     custom_request_.reset(new HttpRequestInfo(*request_));
2385     request_ = custom_request_.get();
2386   }
2387   DCHECK(custom_request_.get());
2388
2389   bool use_if_range =
2390       partial_ && !partial_->IsCurrentRangeCached() && !invalid_range_;
2391
2392   if (!use_if_range) {
2393     // stale-while-revalidate is not useful when we only have a partial response
2394     // cached, so don't set the header in that case.
2395     HttpResponseHeaders::FreshnessLifetimes lifetimes =
2396         response_.headers->GetFreshnessLifetimes(response_.response_time);
2397     if (lifetimes.staleness > TimeDelta()) {
2398       TimeDelta current_age = response_.headers->GetCurrentAge(
2399           response_.request_time, response_.response_time,
2400           cache_->clock_->Now());
2401
2402       custom_request_->extra_headers.SetHeader(
2403           kFreshnessHeader,
2404           base::StringPrintf("max-age=%" PRId64
2405                              ",stale-while-revalidate=%" PRId64 ",age=%" PRId64,
2406                              lifetimes.freshness.InSeconds(),
2407                              lifetimes.staleness.InSeconds(),
2408                              current_age.InSeconds()));
2409     }
2410   }
2411
2412   if (!etag_value.empty()) {
2413     if (use_if_range) {
2414       // We don't want to switch to WRITE mode if we don't have this block of a
2415       // byte-range request because we may have other parts cached.
2416       custom_request_->extra_headers.SetHeader(
2417           HttpRequestHeaders::kIfRange, etag_value);
2418     } else {
2419       custom_request_->extra_headers.SetHeader(
2420           HttpRequestHeaders::kIfNoneMatch, etag_value);
2421     }
2422     // For byte-range requests, make sure that we use only one way to validate
2423     // the request.
2424     if (partial_ && !partial_->IsCurrentRangeCached())
2425       return true;
2426   }
2427
2428   if (!last_modified_value.empty()) {
2429     if (use_if_range) {
2430       custom_request_->extra_headers.SetHeader(
2431           HttpRequestHeaders::kIfRange, last_modified_value);
2432     } else {
2433       custom_request_->extra_headers.SetHeader(
2434           HttpRequestHeaders::kIfModifiedSince, last_modified_value);
2435     }
2436   }
2437
2438   return true;
2439 }
2440
2441 // We just received some headers from the server. We may have asked for a range,
2442 // in which case partial_ has an object. This could be the first network request
2443 // we make to fulfill the original request, or we may be already reading (from
2444 // the net and / or the cache). If we are not expecting a certain response, we
2445 // just bypass the cache for this request (but again, maybe we are reading), and
2446 // delete partial_ (so we are not able to "fix" the headers that we return to
2447 // the user). This results in either a weird response for the caller (we don't
2448 // expect it after all), or maybe a range that was not exactly what it was asked
2449 // for.
2450 //
2451 // If the server is simply telling us that the resource has changed, we delete
2452 // the cached entry and restart the request as the caller intended (by returning
2453 // false from this method). However, we may not be able to do that at any point,
2454 // for instance if we already returned the headers to the user.
2455 //
2456 // WARNING: Whenever this code returns false, it has to make sure that the next
2457 // time it is called it will return true so that we don't keep retrying the
2458 // request.
2459 bool HttpCache::Transaction::ValidatePartialResponse() {
2460   const HttpResponseHeaders* headers = new_response_->headers.get();
2461   int response_code = headers->response_code();
2462   bool partial_response = (response_code == 206);
2463   handling_206_ = false;
2464
2465   if (!entry_ || request_->method != "GET")
2466     return true;
2467
2468   if (invalid_range_) {
2469     // We gave up trying to match this request with the stored data. If the
2470     // server is ok with the request, delete the entry, otherwise just ignore
2471     // this request
2472     DCHECK(!reading_);
2473     if (partial_response || response_code == 200) {
2474       DoomPartialEntry(true);
2475       mode_ = NONE;
2476     } else {
2477       if (response_code == 304) {
2478         // Change the response code of the request to be 416 (Requested range
2479         // not satisfiable).
2480         response_ = *new_response_;
2481         partial_->FixResponseHeaders(response_.headers.get(), false);
2482       }
2483       IgnoreRangeRequest();
2484     }
2485     return true;
2486   }
2487
2488   if (!partial_) {
2489     // We are not expecting 206 but we may have one.
2490     if (partial_response)
2491       IgnoreRangeRequest();
2492
2493     return true;
2494   }
2495
2496   // TODO(rvargas): Do we need to consider other results here?.
2497   bool failure = response_code == 200 || response_code == 416;
2498
2499   if (partial_->IsCurrentRangeCached()) {
2500     // We asked for "If-None-Match: " so a 206 means a new object.
2501     if (partial_response)
2502       failure = true;
2503
2504     if (response_code == 304 && partial_->ResponseHeadersOK(headers))
2505       return true;
2506   } else {
2507     // We asked for "If-Range: " so a 206 means just another range.
2508     if (partial_response) {
2509       if (partial_->ResponseHeadersOK(headers)) {
2510         handling_206_ = true;
2511         return true;
2512       } else {
2513         failure = true;
2514       }
2515     }
2516
2517     if (!reading_ && !is_sparse_ && !partial_response) {
2518       // See if we can ignore the fact that we issued a byte range request.
2519       // If the server sends 200, just store it. If it sends an error, redirect
2520       // or something else, we may store the response as long as we didn't have
2521       // anything already stored.
2522       if (response_code == 200 ||
2523           (!truncated_ && response_code != 304 && response_code != 416)) {
2524         // The server is sending something else, and we can save it.
2525         DCHECK((truncated_ && !partial_->IsLastRange()) || range_requested_);
2526         partial_.reset();
2527         truncated_ = false;
2528         return true;
2529       }
2530     }
2531
2532     // 304 is not expected here, but we'll spare the entry (unless it was
2533     // truncated).
2534     if (truncated_)
2535       failure = true;
2536   }
2537
2538   if (failure) {
2539     // We cannot truncate this entry, it has to be deleted.
2540     UpdateTransactionPattern(PATTERN_NOT_COVERED);
2541     mode_ = NONE;
2542     if (is_sparse_ || truncated_) {
2543       // There was something cached to start with, either sparsed data (206), or
2544       // a truncated 200, which means that we probably modified the request,
2545       // adding a byte range or modifying the range requested by the caller.
2546       if (!reading_ && !partial_->IsLastRange()) {
2547         // We have not returned anything to the caller yet so it should be safe
2548         // to issue another network request, this time without us messing up the
2549         // headers.
2550         ResetPartialState(true);
2551         return false;
2552       }
2553       LOG(WARNING) << "Failed to revalidate partial entry";
2554     }
2555     DoomPartialEntry(true);
2556     return true;
2557   }
2558
2559   IgnoreRangeRequest();
2560   return true;
2561 }
2562
2563 void HttpCache::Transaction::IgnoreRangeRequest() {
2564   // We have a problem. We may or may not be reading already (in which case we
2565   // returned the headers), but we'll just pretend that this request is not
2566   // using the cache and see what happens. Most likely this is the first
2567   // response from the server (it's not changing its mind midway, right?).
2568   UpdateTransactionPattern(PATTERN_NOT_COVERED);
2569   if (mode_ & WRITE)
2570     DoneWritingToEntry(mode_ != WRITE);
2571   else if (mode_ & READ && entry_)
2572     cache_->DoneReadingFromEntry(entry_, this);
2573
2574   partial_.reset(NULL);
2575   entry_ = NULL;
2576   mode_ = NONE;
2577 }
2578
2579 void HttpCache::Transaction::FixHeadersForHead() {
2580   if (response_.headers->response_code() == 206) {
2581     response_.headers->RemoveHeader("Content-Range");
2582     response_.headers->ReplaceStatusLine("HTTP/1.1 200 OK");
2583   }
2584 }
2585
2586 int HttpCache::Transaction::SetupEntryForRead() {
2587   if (network_trans_)
2588     ResetNetworkTransaction();
2589   if (partial_) {
2590     if (truncated_ || is_sparse_ || !invalid_range_) {
2591       // We are going to return the saved response headers to the caller, so
2592       // we may need to adjust them first.
2593       next_state_ = STATE_PARTIAL_HEADERS_RECEIVED;
2594       return OK;
2595     } else {
2596       partial_.reset();
2597     }
2598   }
2599   cache_->ConvertWriterToReader(entry_);
2600   mode_ = READ;
2601
2602   if (request_->method == "HEAD")
2603     FixHeadersForHead();
2604
2605   if (entry_->disk_entry->GetDataSize(kMetadataIndex))
2606     next_state_ = STATE_CACHE_READ_METADATA;
2607   return OK;
2608 }
2609
2610 int HttpCache::Transaction::WriteToEntry(int index, int offset,
2611                                          IOBuffer* data, int data_len,
2612                                          const CompletionCallback& callback) {
2613   if (!entry_)
2614     return data_len;
2615
2616   int rv = 0;
2617   if (!partial_ || !data_len) {
2618     rv = entry_->disk_entry->WriteData(index, offset, data, data_len, callback,
2619                                        true);
2620   } else {
2621     rv = partial_->CacheWrite(entry_->disk_entry, data, data_len, callback);
2622   }
2623   return rv;
2624 }
2625
2626 int HttpCache::Transaction::WriteResponseInfoToEntry(bool truncated) {
2627   if (!entry_)
2628     return OK;
2629
2630   if (net_log_.IsCapturing())
2631     net_log_.BeginEvent(NetLog::TYPE_HTTP_CACHE_WRITE_INFO);
2632
2633   // Do not cache no-store content.  Do not cache content with cert errors
2634   // either.  This is to prevent not reporting net errors when loading a
2635   // resource from the cache.  When we load a page over HTTPS with a cert error
2636   // we show an SSL blocking page.  If the user clicks proceed we reload the
2637   // resource ignoring the errors.  The loaded resource is then cached.  If that
2638   // resource is subsequently loaded from the cache, no net error is reported
2639   // (even though the cert status contains the actual errors) and no SSL
2640   // blocking page is shown.  An alternative would be to reverse-map the cert
2641   // status to a net error and replay the net error.
2642   if ((response_.headers->HasHeaderValue("cache-control", "no-store")) ||
2643       IsCertStatusError(response_.ssl_info.cert_status)) {
2644     DoneWritingToEntry(false);
2645     if (net_log_.IsCapturing())
2646       net_log_.EndEvent(NetLog::TYPE_HTTP_CACHE_WRITE_INFO);
2647     return OK;
2648   }
2649
2650   // cert_cache() will be null if the CertCacheTrial field trial is disabled.
2651   if (cache_->cert_cache() && response_.ssl_info.is_valid())
2652     WriteCertChain();
2653
2654   if (truncated)
2655     DCHECK_EQ(200, response_.headers->response_code());
2656
2657   // When writing headers, we normally only write the non-transient headers.
2658   bool skip_transient_headers = true;
2659   scoped_refptr<PickledIOBuffer> data(new PickledIOBuffer());
2660   response_.Persist(data->pickle(), skip_transient_headers, truncated);
2661   data->Done();
2662
2663   io_buf_len_ = data->pickle()->size();
2664   return entry_->disk_entry->WriteData(kResponseInfoIndex, 0, data.get(),
2665                                        io_buf_len_, io_callback_, true);
2666 }
2667
2668 int HttpCache::Transaction::OnWriteResponseInfoToEntryComplete(int result) {
2669   if (!entry_)
2670     return OK;
2671   if (net_log_.IsCapturing()) {
2672     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_CACHE_WRITE_INFO,
2673                                       result);
2674   }
2675
2676   if (result != io_buf_len_) {
2677     DLOG(ERROR) << "failed to write response info to cache";
2678     DoneWritingToEntry(false);
2679   }
2680   return OK;
2681 }
2682
2683 void HttpCache::Transaction::DoneWritingToEntry(bool success) {
2684   if (!entry_)
2685     return;
2686
2687   RecordHistograms();
2688
2689   cache_->DoneWritingToEntry(entry_, success);
2690   entry_ = NULL;
2691   mode_ = NONE;  // switch to 'pass through' mode
2692 }
2693
2694 int HttpCache::Transaction::OnCacheReadError(int result, bool restart) {
2695   DLOG(ERROR) << "ReadData failed: " << result;
2696   const int result_for_histogram = std::max(0, -result);
2697   if (restart) {
2698     UMA_HISTOGRAM_SPARSE_SLOWLY("HttpCache.ReadErrorRestartable",
2699                                 result_for_histogram);
2700   } else {
2701     UMA_HISTOGRAM_SPARSE_SLOWLY("HttpCache.ReadErrorNonRestartable",
2702                                 result_for_histogram);
2703   }
2704
2705   // Avoid using this entry in the future.
2706   if (cache_.get())
2707     cache_->DoomActiveEntry(cache_key_);
2708
2709   if (restart) {
2710     DCHECK(!reading_);
2711     DCHECK(!network_trans_.get());
2712     cache_->DoneWithEntry(entry_, this, false);
2713     entry_ = NULL;
2714     is_sparse_ = false;
2715     partial_.reset();
2716     next_state_ = STATE_GET_BACKEND;
2717     return OK;
2718   }
2719
2720   return ERR_CACHE_READ_FAILURE;
2721 }
2722
2723 void HttpCache::Transaction::OnAddToEntryTimeout(base::TimeTicks start_time) {
2724   if (entry_lock_waiting_since_ != start_time)
2725     return;
2726
2727   DCHECK_EQ(next_state_, STATE_ADD_TO_ENTRY_COMPLETE);
2728
2729   if (!cache_)
2730     return;
2731
2732   cache_->RemovePendingTransaction(this);
2733   OnIOComplete(ERR_CACHE_LOCK_TIMEOUT);
2734 }
2735
2736 void HttpCache::Transaction::DoomPartialEntry(bool delete_object) {
2737   DVLOG(2) << "DoomPartialEntry";
2738   int rv = cache_->DoomEntry(cache_key_, NULL);
2739   DCHECK_EQ(OK, rv);
2740   cache_->DoneWithEntry(entry_, this, false);
2741   entry_ = NULL;
2742   is_sparse_ = false;
2743   truncated_ = false;
2744   if (delete_object)
2745     partial_.reset(NULL);
2746 }
2747
2748 int HttpCache::Transaction::DoPartialNetworkReadCompleted(int result) {
2749   partial_->OnNetworkReadCompleted(result);
2750
2751   if (result == 0) {
2752     // We need to move on to the next range.
2753     ResetNetworkTransaction();
2754     next_state_ = STATE_START_PARTIAL_CACHE_VALIDATION;
2755   }
2756   return result;
2757 }
2758
2759 int HttpCache::Transaction::DoPartialCacheReadCompleted(int result) {
2760   partial_->OnCacheReadCompleted(result);
2761
2762   if (result == 0 && mode_ == READ_WRITE) {
2763     // We need to move on to the next range.
2764     next_state_ = STATE_START_PARTIAL_CACHE_VALIDATION;
2765   } else if (result < 0) {
2766     return OnCacheReadError(result, false);
2767   }
2768   return result;
2769 }
2770
2771 int HttpCache::Transaction::DoRestartPartialRequest() {
2772   // The stored data cannot be used. Get rid of it and restart this request.
2773   net_log_.AddEvent(NetLog::TYPE_HTTP_CACHE_RESTART_PARTIAL_REQUEST);
2774
2775   // WRITE + Doom + STATE_INIT_ENTRY == STATE_CREATE_ENTRY (without an attempt
2776   // to Doom the entry again).
2777   mode_ = WRITE;
2778   ResetPartialState(!range_requested_);
2779   next_state_ = STATE_CREATE_ENTRY;
2780   return OK;
2781 }
2782
2783 void HttpCache::Transaction::ResetPartialState(bool delete_object) {
2784   partial_->RestoreHeaders(&custom_request_->extra_headers);
2785   DoomPartialEntry(delete_object);
2786
2787   if (!delete_object) {
2788     // The simplest way to re-initialize partial_ is to create a new object.
2789     partial_.reset(new PartialData());
2790     if (partial_->Init(request_->extra_headers))
2791       partial_->SetHeaders(custom_request_->extra_headers);
2792     else
2793       partial_.reset();
2794   }
2795 }
2796
2797 void HttpCache::Transaction::ResetNetworkTransaction() {
2798   DCHECK(!old_network_trans_load_timing_);
2799   DCHECK(network_trans_);
2800   LoadTimingInfo load_timing;
2801   if (network_trans_->GetLoadTimingInfo(&load_timing))
2802     old_network_trans_load_timing_.reset(new LoadTimingInfo(load_timing));
2803   total_received_bytes_ += network_trans_->GetTotalReceivedBytes();
2804   ConnectionAttempts attempts;
2805   network_trans_->GetConnectionAttempts(&attempts);
2806   for (const auto& attempt : attempts)
2807     old_connection_attempts_.push_back(attempt);
2808   network_trans_.reset();
2809 }
2810
2811 // Histogram data from the end of 2010 show the following distribution of
2812 // response headers:
2813 //
2814 //   Content-Length............... 87%
2815 //   Date......................... 98%
2816 //   Last-Modified................ 49%
2817 //   Etag......................... 19%
2818 //   Accept-Ranges: bytes......... 25%
2819 //   Accept-Ranges: none.......... 0.4%
2820 //   Strong Validator............. 50%
2821 //   Strong Validator + ranges.... 24%
2822 //   Strong Validator + CL........ 49%
2823 //
2824 bool HttpCache::Transaction::CanResume(bool has_data) {
2825   // Double check that there is something worth keeping.
2826   if (has_data && !entry_->disk_entry->GetDataSize(kResponseContentIndex))
2827     return false;
2828
2829   if (request_->method != "GET")
2830     return false;
2831
2832   // Note that if this is a 206, content-length was already fixed after calling
2833   // PartialData::ResponseHeadersOK().
2834   if (response_.headers->GetContentLength() <= 0 ||
2835       response_.headers->HasHeaderValue("Accept-Ranges", "none") ||
2836       !response_.headers->HasStrongValidators()) {
2837     return false;
2838   }
2839
2840   return true;
2841 }
2842
2843 void HttpCache::Transaction::UpdateTransactionPattern(
2844     TransactionPattern new_transaction_pattern) {
2845   if (transaction_pattern_ == PATTERN_NOT_COVERED)
2846     return;
2847   DCHECK(transaction_pattern_ == PATTERN_UNDEFINED ||
2848          new_transaction_pattern == PATTERN_NOT_COVERED);
2849   transaction_pattern_ = new_transaction_pattern;
2850 }
2851
2852 void HttpCache::Transaction::RecordHistograms() {
2853   DCHECK_NE(PATTERN_UNDEFINED, transaction_pattern_);
2854   if (!cache_.get() || !cache_->GetCurrentBackend() ||
2855       cache_->GetCurrentBackend()->GetCacheType() != DISK_CACHE ||
2856       cache_->mode() != NORMAL || request_->method != "GET") {
2857     return;
2858   }
2859   UMA_HISTOGRAM_ENUMERATION(
2860       "HttpCache.Pattern", transaction_pattern_, PATTERN_MAX);
2861   if (transaction_pattern_ == PATTERN_NOT_COVERED)
2862     return;
2863   DCHECK(!range_requested_);
2864   DCHECK(!first_cache_access_since_.is_null());
2865
2866   TimeDelta total_time = base::TimeTicks::Now() - first_cache_access_since_;
2867
2868   UMA_HISTOGRAM_TIMES("HttpCache.AccessToDone", total_time);
2869
2870   bool did_send_request = !send_request_since_.is_null();
2871   DCHECK(
2872       (did_send_request &&
2873        (transaction_pattern_ == PATTERN_ENTRY_NOT_CACHED ||
2874         transaction_pattern_ == PATTERN_ENTRY_VALIDATED ||
2875         transaction_pattern_ == PATTERN_ENTRY_UPDATED ||
2876         transaction_pattern_ == PATTERN_ENTRY_CANT_CONDITIONALIZE)) ||
2877       (!did_send_request && transaction_pattern_ == PATTERN_ENTRY_USED));
2878
2879   if (!did_send_request) {
2880     DCHECK(transaction_pattern_ == PATTERN_ENTRY_USED);
2881     UMA_HISTOGRAM_TIMES("HttpCache.AccessToDone.Used", total_time);
2882     return;
2883   }
2884
2885   TimeDelta before_send_time = send_request_since_ - first_cache_access_since_;
2886   int64 before_send_percent = (total_time.ToInternalValue() == 0) ?
2887       0 : before_send_time * 100 / total_time;
2888   DCHECK_GE(before_send_percent, 0);
2889   DCHECK_LE(before_send_percent, 100);
2890   base::HistogramBase::Sample before_send_sample =
2891       static_cast<base::HistogramBase::Sample>(before_send_percent);
2892
2893   UMA_HISTOGRAM_TIMES("HttpCache.AccessToDone.SentRequest", total_time);
2894   UMA_HISTOGRAM_TIMES("HttpCache.BeforeSend", before_send_time);
2895   UMA_HISTOGRAM_PERCENTAGE("HttpCache.PercentBeforeSend", before_send_sample);
2896
2897   // TODO(gavinp): Remove or minimize these histograms, particularly the ones
2898   // below this comment after we have received initial data.
2899   switch (transaction_pattern_) {
2900     case PATTERN_ENTRY_CANT_CONDITIONALIZE: {
2901       UMA_HISTOGRAM_TIMES("HttpCache.BeforeSend.CantConditionalize",
2902                           before_send_time);
2903       UMA_HISTOGRAM_PERCENTAGE("HttpCache.PercentBeforeSend.CantConditionalize",
2904                                before_send_sample);
2905       break;
2906     }
2907     case PATTERN_ENTRY_NOT_CACHED: {
2908       UMA_HISTOGRAM_TIMES("HttpCache.BeforeSend.NotCached", before_send_time);
2909       UMA_HISTOGRAM_PERCENTAGE("HttpCache.PercentBeforeSend.NotCached",
2910                                before_send_sample);
2911       break;
2912     }
2913     case PATTERN_ENTRY_VALIDATED: {
2914       UMA_HISTOGRAM_TIMES("HttpCache.BeforeSend.Validated", before_send_time);
2915       UMA_HISTOGRAM_PERCENTAGE("HttpCache.PercentBeforeSend.Validated",
2916                                before_send_sample);
2917       break;
2918     }
2919     case PATTERN_ENTRY_UPDATED: {
2920       UMA_HISTOGRAM_TIMES("HttpCache.BeforeSend.Updated", before_send_time);
2921       UMA_HISTOGRAM_PERCENTAGE("HttpCache.PercentBeforeSend.Updated",
2922                                before_send_sample);
2923       break;
2924     }
2925     default:
2926       NOTREACHED();
2927   }
2928 }
2929
2930 void HttpCache::Transaction::OnIOComplete(int result) {
2931   DoLoop(result);
2932 }
2933
2934 }  // namespace net