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