| OLD | NEW |
|---|
| (Empty) |
| 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.h" | |
| 6 | |
| 7 #include <algorithm> | |
| 8 | |
| 9 #include "base/compiler_specific.h" | |
| 10 | |
| 11 #if defined(OS_POSIX) | |
| 12 #include <unistd.h> | |
| 13 #endif | |
| 14 | |
| 15 #include "base/bind.h" | |
| 16 #include "base/bind_helpers.h" | |
| 17 #include "base/callback.h" | |
| 18 #include "base/files/file_util.h" | |
| 19 #include "base/format_macros.h" | |
| 20 #include "base/location.h" | |
| 21 #include "base/memory/ref_counted.h" | |
| 22 #include "base/message_loop/message_loop.h" | |
| 23 #include "base/metrics/field_trial.h" | |
| 24 #include "base/metrics/histogram.h" | |
| 25 #include "base/pickle.h" | |
| 26 #include "base/profiler/scoped_tracker.h" | |
| 27 #include "base/stl_util.h" | |
| 28 #include "base/strings/string_number_conversions.h" | |
| 29 #include "base/strings/string_util.h" | |
| 30 #include "base/strings/stringprintf.h" | |
| 31 #include "base/threading/worker_pool.h" | |
| 32 #include "base/time/default_clock.h" | |
| 33 #include "base/time/time.h" | |
| 34 #include "net/base/cache_type.h" | |
| 35 #include "net/base/io_buffer.h" | |
| 36 #include "net/base/load_flags.h" | |
| 37 #include "net/base/net_errors.h" | |
| 38 #include "net/base/network_delegate.h" | |
| 39 #include "net/base/upload_data_stream.h" | |
| 40 #include "net/disk_cache/disk_cache.h" | |
| 41 #include "net/http/disk_based_cert_cache.h" | |
| 42 #include "net/http/disk_cache_based_quic_server_info.h" | |
| 43 #include "net/http/http_cache_transaction.h" | |
| 44 #include "net/http/http_network_layer.h" | |
| 45 #include "net/http/http_network_session.h" | |
| 46 #include "net/http/http_request_info.h" | |
| 47 #include "net/http/http_response_headers.h" | |
| 48 #include "net/http/http_response_info.h" | |
| 49 #include "net/http/http_util.h" | |
| 50 #include "net/quic/crypto/quic_server_info.h" | |
| 51 | |
| 52 namespace { | |
| 53 | |
| 54 bool UseCertCache() { | |
| 55 return base::FieldTrialList::FindFullName("CertCacheTrial") == | |
| 56 "ExperimentGroup"; | |
| 57 } | |
| 58 | |
| 59 // Adaptor to delete a file on a worker thread. | |
| 60 void DeletePath(base::FilePath path) { | |
| 61 base::DeleteFile(path, false); | |
| 62 } | |
| 63 | |
| 64 } // namespace | |
| 65 | |
| 66 namespace net { | |
| 67 | |
| 68 HttpCache::DefaultBackend::DefaultBackend( | |
| 69 CacheType type, | |
| 70 BackendType backend_type, | |
| 71 const base::FilePath& path, | |
| 72 int max_bytes, | |
| 73 const scoped_refptr<base::SingleThreadTaskRunner>& thread) | |
| 74 : type_(type), | |
| 75 backend_type_(backend_type), | |
| 76 path_(path), | |
| 77 max_bytes_(max_bytes), | |
| 78 thread_(thread) { | |
| 79 } | |
| 80 | |
| 81 HttpCache::DefaultBackend::~DefaultBackend() {} | |
| 82 | |
| 83 // static | |
| 84 HttpCache::BackendFactory* HttpCache::DefaultBackend::InMemory(int max_bytes) { | |
| 85 return new DefaultBackend(MEMORY_CACHE, net::CACHE_BACKEND_DEFAULT, | |
| 86 base::FilePath(), max_bytes, NULL); | |
| 87 } | |
| 88 | |
| 89 int HttpCache::DefaultBackend::CreateBackend( | |
| 90 NetLog* net_log, scoped_ptr<disk_cache::Backend>* backend, | |
| 91 const CompletionCallback& callback) { | |
| 92 DCHECK_GE(max_bytes_, 0); | |
| 93 return disk_cache::CreateCacheBackend(type_, | |
| 94 backend_type_, | |
| 95 path_, | |
| 96 max_bytes_, | |
| 97 true, | |
| 98 thread_, | |
| 99 net_log, | |
| 100 backend, | |
| 101 callback); | |
| 102 } | |
| 103 | |
| 104 //----------------------------------------------------------------------------- | |
| 105 | |
| 106 HttpCache::ActiveEntry::ActiveEntry(disk_cache::Entry* entry) | |
| 107 : disk_entry(entry), | |
| 108 writer(NULL), | |
| 109 will_process_pending_queue(false), | |
| 110 doomed(false) { | |
| 111 } | |
| 112 | |
| 113 HttpCache::ActiveEntry::~ActiveEntry() { | |
| 114 if (disk_entry) { | |
| 115 disk_entry->Close(); | |
| 116 disk_entry = NULL; | |
| 117 } | |
| 118 } | |
| 119 | |
| 120 //----------------------------------------------------------------------------- | |
| 121 | |
| 122 // This structure keeps track of work items that are attempting to create or | |
| 123 // open cache entries or the backend itself. | |
| 124 struct HttpCache::PendingOp { | |
| 125 PendingOp() : disk_entry(NULL), writer(NULL) {} | |
| 126 ~PendingOp() {} | |
| 127 | |
| 128 disk_cache::Entry* disk_entry; | |
| 129 scoped_ptr<disk_cache::Backend> backend; | |
| 130 WorkItem* writer; | |
| 131 CompletionCallback callback; // BackendCallback. | |
| 132 WorkItemList pending_queue; | |
| 133 }; | |
| 134 | |
| 135 //----------------------------------------------------------------------------- | |
| 136 | |
| 137 // The type of operation represented by a work item. | |
| 138 enum WorkItemOperation { | |
| 139 WI_CREATE_BACKEND, | |
| 140 WI_OPEN_ENTRY, | |
| 141 WI_CREATE_ENTRY, | |
| 142 WI_DOOM_ENTRY | |
| 143 }; | |
| 144 | |
| 145 // A work item encapsulates a single request to the backend with all the | |
| 146 // information needed to complete that request. | |
| 147 class HttpCache::WorkItem { | |
| 148 public: | |
| 149 WorkItem(WorkItemOperation operation, Transaction* trans, ActiveEntry** entry) | |
| 150 : operation_(operation), | |
| 151 trans_(trans), | |
| 152 entry_(entry), | |
| 153 backend_(NULL) {} | |
| 154 WorkItem(WorkItemOperation operation, Transaction* trans, | |
| 155 const net::CompletionCallback& cb, disk_cache::Backend** backend) | |
| 156 : operation_(operation), | |
| 157 trans_(trans), | |
| 158 entry_(NULL), | |
| 159 callback_(cb), | |
| 160 backend_(backend) {} | |
| 161 ~WorkItem() {} | |
| 162 | |
| 163 // Calls back the transaction with the result of the operation. | |
| 164 void NotifyTransaction(int result, ActiveEntry* entry) { | |
| 165 DCHECK(!entry || entry->disk_entry); | |
| 166 if (entry_) | |
| 167 *entry_ = entry; | |
| 168 if (trans_) | |
| 169 trans_->io_callback().Run(result); | |
| 170 } | |
| 171 | |
| 172 // Notifies the caller about the operation completion. Returns true if the | |
| 173 // callback was invoked. | |
| 174 bool DoCallback(int result, disk_cache::Backend* backend) { | |
| 175 if (backend_) | |
| 176 *backend_ = backend; | |
| 177 if (!callback_.is_null()) { | |
| 178 callback_.Run(result); | |
| 179 return true; | |
| 180 } | |
| 181 return false; | |
| 182 } | |
| 183 | |
| 184 WorkItemOperation operation() { return operation_; } | |
| 185 void ClearTransaction() { trans_ = NULL; } | |
| 186 void ClearEntry() { entry_ = NULL; } | |
| 187 void ClearCallback() { callback_.Reset(); } | |
| 188 bool Matches(Transaction* trans) const { return trans == trans_; } | |
| 189 bool IsValid() const { return trans_ || entry_ || !callback_.is_null(); } | |
| 190 | |
| 191 private: | |
| 192 WorkItemOperation operation_; | |
| 193 Transaction* trans_; | |
| 194 ActiveEntry** entry_; | |
| 195 net::CompletionCallback callback_; // User callback. | |
| 196 disk_cache::Backend** backend_; | |
| 197 }; | |
| 198 | |
| 199 //----------------------------------------------------------------------------- | |
| 200 | |
| 201 // This class encapsulates a transaction whose only purpose is to write metadata | |
| 202 // to a given entry. | |
| 203 class HttpCache::MetadataWriter { | |
| 204 public: | |
| 205 explicit MetadataWriter(HttpCache::Transaction* trans) | |
| 206 : transaction_(trans), | |
| 207 verified_(false), | |
| 208 buf_len_(0) { | |
| 209 } | |
| 210 | |
| 211 ~MetadataWriter() {} | |
| 212 | |
| 213 // Implements the bulk of HttpCache::WriteMetadata. | |
| 214 void Write(const GURL& url, | |
| 215 double expected_response_time, | |
| 216 IOBuffer* buf, | |
| 217 int buf_len); | |
| 218 | |
| 219 private: | |
| 220 void VerifyResponse(int result); | |
| 221 void SelfDestroy(); | |
| 222 void OnIOComplete(int result); | |
| 223 | |
| 224 scoped_ptr<HttpCache::Transaction> transaction_; | |
| 225 bool verified_; | |
| 226 scoped_refptr<IOBuffer> buf_; | |
| 227 int buf_len_; | |
| 228 double expected_response_time_; | |
| 229 HttpRequestInfo request_info_; | |
| 230 DISALLOW_COPY_AND_ASSIGN(MetadataWriter); | |
| 231 }; | |
| 232 | |
| 233 void HttpCache::MetadataWriter::Write(const GURL& url, | |
| 234 double expected_response_time, | |
| 235 IOBuffer* buf, | |
| 236 int buf_len) { | |
| 237 DCHECK_GT(buf_len, 0); | |
| 238 DCHECK(buf); | |
| 239 DCHECK(buf->data()); | |
| 240 request_info_.url = url; | |
| 241 request_info_.method = "GET"; | |
| 242 request_info_.load_flags = LOAD_ONLY_FROM_CACHE; | |
| 243 | |
| 244 expected_response_time_ = expected_response_time; | |
| 245 buf_ = buf; | |
| 246 buf_len_ = buf_len; | |
| 247 verified_ = false; | |
| 248 | |
| 249 int rv = transaction_->Start( | |
| 250 &request_info_, | |
| 251 base::Bind(&MetadataWriter::OnIOComplete, base::Unretained(this)), | |
| 252 BoundNetLog()); | |
| 253 if (rv != ERR_IO_PENDING) | |
| 254 VerifyResponse(rv); | |
| 255 } | |
| 256 | |
| 257 void HttpCache::MetadataWriter::VerifyResponse(int result) { | |
| 258 verified_ = true; | |
| 259 if (result != OK) | |
| 260 return SelfDestroy(); | |
| 261 | |
| 262 const HttpResponseInfo* response_info = transaction_->GetResponseInfo(); | |
| 263 DCHECK(response_info->was_cached); | |
| 264 if (response_info->response_time.ToDoubleT() != expected_response_time_) | |
| 265 return SelfDestroy(); | |
| 266 | |
| 267 result = transaction_->WriteMetadata( | |
| 268 buf_.get(), | |
| 269 buf_len_, | |
| 270 base::Bind(&MetadataWriter::OnIOComplete, base::Unretained(this))); | |
| 271 if (result != ERR_IO_PENDING) | |
| 272 SelfDestroy(); | |
| 273 } | |
| 274 | |
| 275 void HttpCache::MetadataWriter::SelfDestroy() { | |
| 276 delete this; | |
| 277 } | |
| 278 | |
| 279 void HttpCache::MetadataWriter::OnIOComplete(int result) { | |
| 280 if (!verified_) | |
| 281 return VerifyResponse(result); | |
| 282 SelfDestroy(); | |
| 283 } | |
| 284 | |
| 285 //----------------------------------------------------------------------------- | |
| 286 | |
| 287 class HttpCache::QuicServerInfoFactoryAdaptor : public QuicServerInfoFactory { | |
| 288 public: | |
| 289 explicit QuicServerInfoFactoryAdaptor(HttpCache* http_cache) | |
| 290 : http_cache_(http_cache) { | |
| 291 } | |
| 292 | |
| 293 QuicServerInfo* GetForServer(const QuicServerId& server_id) override { | |
| 294 return new DiskCacheBasedQuicServerInfo(server_id, http_cache_); | |
| 295 } | |
| 296 | |
| 297 private: | |
| 298 HttpCache* const http_cache_; | |
| 299 }; | |
| 300 | |
| 301 //----------------------------------------------------------------------------- | |
| 302 | |
| 303 class HttpCache::AsyncValidation { | |
| 304 public: | |
| 305 AsyncValidation(const HttpRequestInfo& original_request, HttpCache* cache) | |
| 306 : request_(original_request), cache_(cache) {} | |
| 307 ~AsyncValidation() {} | |
| 308 | |
| 309 void Start(const BoundNetLog& net_log, | |
| 310 scoped_ptr<Transaction> transaction, | |
| 311 NetworkDelegate* network_delegate); | |
| 312 | |
| 313 private: | |
| 314 void OnStarted(int result); | |
| 315 void DoRead(); | |
| 316 void OnRead(int result); | |
| 317 | |
| 318 // Terminate this request with net error code |result|. Logs the transaction | |
| 319 // result and asks HttpCache to delete this object. | |
| 320 // If there was a client or server certificate error, it cannot be recovered | |
| 321 // asynchronously, so we need to prevent future attempts to asynchronously | |
| 322 // fetch the resource. In this case, the cache entry is doomed. | |
| 323 void Terminate(int result); | |
| 324 | |
| 325 HttpRequestInfo request_; | |
| 326 scoped_refptr<IOBuffer> buf_; | |
| 327 CompletionCallback read_callback_; | |
| 328 scoped_ptr<Transaction> transaction_; | |
| 329 base::Time start_time_; | |
| 330 | |
| 331 // The HttpCache object owns this object. This object is always deleted before | |
| 332 // the pointer to the cache becomes invalid. | |
| 333 HttpCache* cache_; | |
| 334 | |
| 335 DISALLOW_COPY_AND_ASSIGN(AsyncValidation); | |
| 336 }; | |
| 337 | |
| 338 void HttpCache::AsyncValidation::Start(const BoundNetLog& net_log, | |
| 339 scoped_ptr<Transaction> transaction, | |
| 340 NetworkDelegate* network_delegate) { | |
| 341 transaction_ = transaction.Pass(); | |
| 342 if (network_delegate) { | |
| 343 // This code is necessary to enable async transactions to pass over the | |
| 344 // data-reduction proxy. This is a violation of the "once-and-only-once" | |
| 345 // principle, since it copies code from URLRequestHttpJob. We cannot use the | |
| 346 // original callback passed to HttpCache::Transaction by URLRequestHttpJob | |
| 347 // as it will only be valid as long as the URLRequestHttpJob object is | |
| 348 // alive, and that object will be deleted as soon as the synchronous request | |
| 349 // completes. | |
| 350 // | |
| 351 // This code is also an encapsulation violation. We are exploiting the fact | |
| 352 // that the |request| parameter to NotifyBeforeSendProxyHeaders() is never | |
| 353 // actually used for anything, and so can be NULL. | |
| 354 // | |
| 355 // TODO(ricea): Do this better. | |
| 356 transaction_->SetBeforeProxyHeadersSentCallback( | |
| 357 base::Bind(&NetworkDelegate::NotifyBeforeSendProxyHeaders, | |
| 358 base::Unretained(network_delegate), | |
| 359 static_cast<URLRequest*>(NULL))); | |
| 360 // The above use of base::Unretained is safe because the NetworkDelegate has | |
| 361 // to live at least as long as the HttpNetworkSession which has to live as | |
| 362 // least as long as the HttpNetworkLayer which has to live at least as long | |
| 363 // this HttpCache object. | |
| 364 } | |
| 365 | |
| 366 DCHECK_EQ(0, request_.load_flags & LOAD_ASYNC_REVALIDATION); | |
| 367 request_.load_flags |= LOAD_ASYNC_REVALIDATION; | |
| 368 start_time_ = cache_->clock()->Now(); | |
| 369 // This use of base::Unretained is safe because |transaction_| is owned by | |
| 370 // this object. | |
| 371 read_callback_ = base::Bind(&AsyncValidation::OnRead, base::Unretained(this)); | |
| 372 // This use of base::Unretained is safe as above. | |
| 373 int rv = transaction_->Start( | |
| 374 &request_, | |
| 375 base::Bind(&AsyncValidation::OnStarted, base::Unretained(this)), | |
| 376 net_log); | |
| 377 | |
| 378 if (rv == ERR_IO_PENDING) | |
| 379 return; | |
| 380 | |
| 381 OnStarted(rv); | |
| 382 } | |
| 383 | |
| 384 void HttpCache::AsyncValidation::OnStarted(int result) { | |
| 385 if (result != OK) { | |
| 386 DVLOG(1) << "Asynchronous transaction start failed for " << request_.url; | |
| 387 Terminate(result); | |
| 388 return; | |
| 389 } | |
| 390 | |
| 391 while (transaction_->IsReadyToRestartForAuth()) { | |
| 392 // This code is based on URLRequestHttpJob::RestartTransactionWithAuth, | |
| 393 // however when we do this here cookies on the response will not be | |
| 394 // stored. Fortunately only a tiny number of sites set cookies on 401 | |
| 395 // responses, and none of them use stale-while-revalidate. | |
| 396 result = transaction_->RestartWithAuth( | |
| 397 AuthCredentials(), | |
| 398 base::Bind(&AsyncValidation::OnStarted, base::Unretained(this))); | |
| 399 if (result == ERR_IO_PENDING) | |
| 400 return; | |
| 401 if (result != OK) { | |
| 402 DVLOG(1) << "Synchronous transaction restart with auth failed for " | |
| 403 << request_.url; | |
| 404 Terminate(result); | |
| 405 return; | |
| 406 } | |
| 407 } | |
| 408 | |
| 409 DoRead(); | |
| 410 } | |
| 411 | |
| 412 void HttpCache::AsyncValidation::DoRead() { | |
| 413 const size_t kBufSize = 4096; | |
| 414 if (!buf_.get()) | |
| 415 buf_ = new IOBuffer(kBufSize); | |
| 416 | |
| 417 int rv = 0; | |
| 418 do { | |
| 419 rv = transaction_->Read(buf_.get(), kBufSize, read_callback_); | |
| 420 } while (rv > 0); | |
| 421 | |
| 422 if (rv == ERR_IO_PENDING) | |
| 423 return; | |
| 424 | |
| 425 OnRead(rv); | |
| 426 } | |
| 427 | |
| 428 void HttpCache::AsyncValidation::OnRead(int result) { | |
| 429 if (result > 0) { | |
| 430 DoRead(); | |
| 431 return; | |
| 432 } | |
| 433 Terminate(result); | |
| 434 } | |
| 435 | |
| 436 void HttpCache::AsyncValidation::Terminate(int result) { | |
| 437 if (result == ERR_SSL_CLIENT_AUTH_CERT_NEEDED || IsCertificateError(result)) { | |
| 438 // We should not attempt to access this resource asynchronously again until | |
| 439 // the certificate problem has been resolved. | |
| 440 // TODO(ricea): For ERR_SSL_CLIENT_AUTH_CERT_NEEDED, mark the entry as | |
| 441 // requiring synchronous revalidation rather than just deleting it. Other | |
| 442 // certificate errors cause the resource to be considered uncacheable | |
| 443 // anyway. | |
| 444 cache_->DoomEntry(transaction_->key(), transaction_.get()); | |
| 445 } | |
| 446 base::TimeDelta duration = cache_->clock()->Now() - start_time_; | |
| 447 UMA_HISTOGRAM_TIMES("HttpCache.AsyncValidationDuration", duration); | |
| 448 transaction_->net_log().EndEventWithNetErrorCode( | |
| 449 NetLog::TYPE_ASYNC_REVALIDATION, result); | |
| 450 cache_->DeleteAsyncValidation(cache_->GenerateCacheKey(&request_)); | |
| 451 // |this| is deleted. | |
| 452 } | |
| 453 | |
| 454 //----------------------------------------------------------------------------- | |
| 455 HttpCache::HttpCache(const net::HttpNetworkSession::Params& params, | |
| 456 BackendFactory* backend_factory) | |
| 457 : net_log_(params.net_log), | |
| 458 backend_factory_(backend_factory), | |
| 459 building_backend_(false), | |
| 460 bypass_lock_for_test_(false), | |
| 461 fail_conditionalization_for_test_(false), | |
| 462 use_stale_while_revalidate_(params.use_stale_while_revalidate), | |
| 463 mode_(NORMAL), | |
| 464 network_layer_(new HttpNetworkLayer(new HttpNetworkSession(params))), | |
| 465 clock_(new base::DefaultClock()), | |
| 466 weak_factory_(this) { | |
| 467 SetupQuicServerInfoFactory(network_layer_->GetSession()); | |
| 468 } | |
| 469 | |
| 470 | |
| 471 // This call doesn't change the shared |session|'s QuicServerInfoFactory because | |
| 472 // |session| is shared. | |
| 473 HttpCache::HttpCache(HttpNetworkSession* session, | |
| 474 BackendFactory* backend_factory) | |
| 475 : net_log_(session->net_log()), | |
| 476 backend_factory_(backend_factory), | |
| 477 building_backend_(false), | |
| 478 bypass_lock_for_test_(false), | |
| 479 fail_conditionalization_for_test_(false), | |
| 480 use_stale_while_revalidate_(session->params().use_stale_while_revalidate), | |
| 481 mode_(NORMAL), | |
| 482 network_layer_(new HttpNetworkLayer(session)), | |
| 483 clock_(new base::DefaultClock()), | |
| 484 weak_factory_(this) { | |
| 485 } | |
| 486 | |
| 487 HttpCache::HttpCache(HttpTransactionFactory* network_layer, | |
| 488 NetLog* net_log, | |
| 489 BackendFactory* backend_factory) | |
| 490 : net_log_(net_log), | |
| 491 backend_factory_(backend_factory), | |
| 492 building_backend_(false), | |
| 493 bypass_lock_for_test_(false), | |
| 494 fail_conditionalization_for_test_(false), | |
| 495 use_stale_while_revalidate_(false), | |
| 496 mode_(NORMAL), | |
| 497 network_layer_(network_layer), | |
| 498 clock_(new base::DefaultClock()), | |
| 499 weak_factory_(this) { | |
| 500 SetupQuicServerInfoFactory(network_layer_->GetSession()); | |
| 501 HttpNetworkSession* session = network_layer_->GetSession(); | |
| 502 if (session) | |
| 503 use_stale_while_revalidate_ = session->params().use_stale_while_revalidate; | |
| 504 } | |
| 505 | |
| 506 HttpCache::~HttpCache() { | |
| 507 // Transactions should see an invalid cache after this point; otherwise they | |
| 508 // could see an inconsistent object (half destroyed). | |
| 509 weak_factory_.InvalidateWeakPtrs(); | |
| 510 | |
| 511 // If we have any active entries remaining, then we need to deactivate them. | |
| 512 // We may have some pending calls to OnProcessPendingQueue, but since those | |
| 513 // won't run (due to our destruction), we can simply ignore the corresponding | |
| 514 // will_process_pending_queue flag. | |
| 515 while (!active_entries_.empty()) { | |
| 516 ActiveEntry* entry = active_entries_.begin()->second; | |
| 517 entry->will_process_pending_queue = false; | |
| 518 entry->pending_queue.clear(); | |
| 519 entry->readers.clear(); | |
| 520 entry->writer = NULL; | |
| 521 DeactivateEntry(entry); | |
| 522 } | |
| 523 | |
| 524 STLDeleteElements(&doomed_entries_); | |
| 525 STLDeleteValues(&async_validations_); | |
| 526 | |
| 527 // Before deleting pending_ops_, we have to make sure that the disk cache is | |
| 528 // done with said operations, or it will attempt to use deleted data. | |
| 529 cert_cache_.reset(); | |
| 530 disk_cache_.reset(); | |
| 531 | |
| 532 PendingOpsMap::iterator pending_it = pending_ops_.begin(); | |
| 533 for (; pending_it != pending_ops_.end(); ++pending_it) { | |
| 534 // We are not notifying the transactions about the cache going away, even | |
| 535 // though they are waiting for a callback that will never fire. | |
| 536 PendingOp* pending_op = pending_it->second; | |
| 537 delete pending_op->writer; | |
| 538 bool delete_pending_op = true; | |
| 539 if (building_backend_) { | |
| 540 // If we don't have a backend, when its construction finishes it will | |
| 541 // deliver the callbacks. | |
| 542 if (!pending_op->callback.is_null()) { | |
| 543 // If not null, the callback will delete the pending operation later. | |
| 544 delete_pending_op = false; | |
| 545 } | |
| 546 } else { | |
| 547 pending_op->callback.Reset(); | |
| 548 } | |
| 549 | |
| 550 STLDeleteElements(&pending_op->pending_queue); | |
| 551 if (delete_pending_op) | |
| 552 delete pending_op; | |
| 553 } | |
| 554 } | |
| 555 | |
| 556 int HttpCache::GetBackend(disk_cache::Backend** backend, | |
| 557 const CompletionCallback& callback) { | |
| 558 DCHECK(!callback.is_null()); | |
| 559 | |
| 560 if (disk_cache_.get()) { | |
| 561 *backend = disk_cache_.get(); | |
| 562 return OK; | |
| 563 } | |
| 564 | |
| 565 return CreateBackend(backend, callback); | |
| 566 } | |
| 567 | |
| 568 disk_cache::Backend* HttpCache::GetCurrentBackend() const { | |
| 569 return disk_cache_.get(); | |
| 570 } | |
| 571 | |
| 572 // static | |
| 573 bool HttpCache::ParseResponseInfo(const char* data, int len, | |
| 574 HttpResponseInfo* response_info, | |
| 575 bool* response_truncated) { | |
| 576 Pickle pickle(data, len); | |
| 577 return response_info->InitFromPickle(pickle, response_truncated); | |
| 578 } | |
| 579 | |
| 580 void HttpCache::WriteMetadata(const GURL& url, | |
| 581 RequestPriority priority, | |
| 582 double expected_response_time, | |
| 583 IOBuffer* buf, | |
| 584 int buf_len) { | |
| 585 if (!buf_len) | |
| 586 return; | |
| 587 | |
| 588 // Do lazy initialization of disk cache if needed. | |
| 589 if (!disk_cache_.get()) { | |
| 590 // We don't care about the result. | |
| 591 CreateBackend(NULL, net::CompletionCallback()); | |
| 592 } | |
| 593 | |
| 594 HttpCache::Transaction* trans = | |
| 595 new HttpCache::Transaction(priority, this); | |
| 596 MetadataWriter* writer = new MetadataWriter(trans); | |
| 597 | |
| 598 // The writer will self destruct when done. | |
| 599 writer->Write(url, expected_response_time, buf, buf_len); | |
| 600 } | |
| 601 | |
| 602 void HttpCache::CloseAllConnections() { | |
| 603 HttpNetworkSession* session = GetSession(); | |
| 604 if (session) | |
| 605 session->CloseAllConnections(); | |
| 606 } | |
| 607 | |
| 608 void HttpCache::CloseIdleConnections() { | |
| 609 HttpNetworkSession* session = GetSession(); | |
| 610 if (session) | |
| 611 session->CloseIdleConnections(); | |
| 612 } | |
| 613 | |
| 614 void HttpCache::OnExternalCacheHit(const GURL& url, | |
| 615 const std::string& http_method) { | |
| 616 if (!disk_cache_.get() || mode_ == DISABLE) | |
| 617 return; | |
| 618 | |
| 619 HttpRequestInfo request_info; | |
| 620 request_info.url = url; | |
| 621 request_info.method = http_method; | |
| 622 std::string key = GenerateCacheKey(&request_info); | |
| 623 disk_cache_->OnExternalCacheHit(key); | |
| 624 } | |
| 625 | |
| 626 void HttpCache::InitializeInfiniteCache(const base::FilePath& path) { | |
| 627 if (base::FieldTrialList::FindFullName("InfiniteCache") != "Yes") | |
| 628 return; | |
| 629 base::WorkerPool::PostTask(FROM_HERE, base::Bind(&DeletePath, path), true); | |
| 630 } | |
| 631 | |
| 632 int HttpCache::CreateTransaction(RequestPriority priority, | |
| 633 scoped_ptr<HttpTransaction>* trans) { | |
| 634 // Do lazy initialization of disk cache if needed. | |
| 635 if (!disk_cache_.get()) { | |
| 636 // We don't care about the result. | |
| 637 CreateBackend(NULL, net::CompletionCallback()); | |
| 638 } | |
| 639 | |
| 640 HttpCache::Transaction* transaction = | |
| 641 new HttpCache::Transaction(priority, this); | |
| 642 if (bypass_lock_for_test_) | |
| 643 transaction->BypassLockForTest(); | |
| 644 if (fail_conditionalization_for_test_) | |
| 645 transaction->FailConditionalizationForTest(); | |
| 646 | |
| 647 trans->reset(transaction); | |
| 648 return OK; | |
| 649 } | |
| 650 | |
| 651 HttpCache* HttpCache::GetCache() { | |
| 652 return this; | |
| 653 } | |
| 654 | |
| 655 HttpNetworkSession* HttpCache::GetSession() { | |
| 656 return network_layer_->GetSession(); | |
| 657 } | |
| 658 | |
| 659 scoped_ptr<HttpTransactionFactory> | |
| 660 HttpCache::SetHttpNetworkTransactionFactoryForTesting( | |
| 661 scoped_ptr<HttpTransactionFactory> new_network_layer) { | |
| 662 scoped_ptr<HttpTransactionFactory> old_network_layer(network_layer_.Pass()); | |
| 663 network_layer_ = new_network_layer.Pass(); | |
| 664 return old_network_layer.Pass(); | |
| 665 } | |
| 666 | |
| 667 //----------------------------------------------------------------------------- | |
| 668 | |
| 669 int HttpCache::CreateBackend(disk_cache::Backend** backend, | |
| 670 const net::CompletionCallback& callback) { | |
| 671 if (!backend_factory_.get()) | |
| 672 return ERR_FAILED; | |
| 673 | |
| 674 building_backend_ = true; | |
| 675 | |
| 676 scoped_ptr<WorkItem> item(new WorkItem(WI_CREATE_BACKEND, NULL, callback, | |
| 677 backend)); | |
| 678 | |
| 679 // This is the only operation that we can do that is not related to any given | |
| 680 // entry, so we use an empty key for it. | |
| 681 PendingOp* pending_op = GetPendingOp(std::string()); | |
| 682 if (pending_op->writer) { | |
| 683 if (!callback.is_null()) | |
| 684 pending_op->pending_queue.push_back(item.release()); | |
| 685 return ERR_IO_PENDING; | |
| 686 } | |
| 687 | |
| 688 DCHECK(pending_op->pending_queue.empty()); | |
| 689 | |
| 690 pending_op->writer = item.release(); | |
| 691 pending_op->callback = base::Bind(&HttpCache::OnPendingOpComplete, | |
| 692 GetWeakPtr(), pending_op); | |
| 693 | |
| 694 int rv = backend_factory_->CreateBackend(net_log_, &pending_op->backend, | |
| 695 pending_op->callback); | |
| 696 if (rv != ERR_IO_PENDING) { | |
| 697 pending_op->writer->ClearCallback(); | |
| 698 pending_op->callback.Run(rv); | |
| 699 } | |
| 700 | |
| 701 return rv; | |
| 702 } | |
| 703 | |
| 704 int HttpCache::GetBackendForTransaction(Transaction* trans) { | |
| 705 if (disk_cache_.get()) | |
| 706 return OK; | |
| 707 | |
| 708 if (!building_backend_) | |
| 709 return ERR_FAILED; | |
| 710 | |
| 711 WorkItem* item = new WorkItem( | |
| 712 WI_CREATE_BACKEND, trans, net::CompletionCallback(), NULL); | |
| 713 PendingOp* pending_op = GetPendingOp(std::string()); | |
| 714 DCHECK(pending_op->writer); | |
| 715 pending_op->pending_queue.push_back(item); | |
| 716 return ERR_IO_PENDING; | |
| 717 } | |
| 718 | |
| 719 // Generate a key that can be used inside the cache. | |
| 720 std::string HttpCache::GenerateCacheKey(const HttpRequestInfo* request) { | |
| 721 // Strip out the reference, username, and password sections of the URL. | |
| 722 std::string url = HttpUtil::SpecForRequest(request->url); | |
| 723 | |
| 724 DCHECK(mode_ != DISABLE); | |
| 725 if (mode_ == NORMAL) { | |
| 726 // No valid URL can begin with numerals, so we should not have to worry | |
| 727 // about collisions with normal URLs. | |
| 728 if (request->upload_data_stream && | |
| 729 request->upload_data_stream->identifier()) { | |
| 730 url.insert(0, base::StringPrintf( | |
| 731 "%" PRId64 "/", request->upload_data_stream->identifier())); | |
| 732 } | |
| 733 return url; | |
| 734 } | |
| 735 | |
| 736 // In playback and record mode, we cache everything. | |
| 737 | |
| 738 // Lazily initialize. | |
| 739 if (playback_cache_map_ == NULL) | |
| 740 playback_cache_map_.reset(new PlaybackCacheMap()); | |
| 741 | |
| 742 // Each time we request an item from the cache, we tag it with a | |
| 743 // generation number. During playback, multiple fetches for the same | |
| 744 // item will use the same generation number and pull the proper | |
| 745 // instance of an URL from the cache. | |
| 746 int generation = 0; | |
| 747 DCHECK(playback_cache_map_ != NULL); | |
| 748 if (playback_cache_map_->find(url) != playback_cache_map_->end()) | |
| 749 generation = (*playback_cache_map_)[url]; | |
| 750 (*playback_cache_map_)[url] = generation + 1; | |
| 751 | |
| 752 // The key into the cache is GENERATION # + METHOD + URL. | |
| 753 std::string result = base::IntToString(generation); | |
| 754 result.append(request->method); | |
| 755 result.append(url); | |
| 756 return result; | |
| 757 } | |
| 758 | |
| 759 void HttpCache::DoomActiveEntry(const std::string& key) { | |
| 760 ActiveEntriesMap::iterator it = active_entries_.find(key); | |
| 761 if (it == active_entries_.end()) | |
| 762 return; | |
| 763 | |
| 764 // This is not a performance critical operation, this is handling an error | |
| 765 // condition so it is OK to look up the entry again. | |
| 766 int rv = DoomEntry(key, NULL); | |
| 767 DCHECK_EQ(OK, rv); | |
| 768 } | |
| 769 | |
| 770 int HttpCache::DoomEntry(const std::string& key, Transaction* trans) { | |
| 771 // Need to abandon the ActiveEntry, but any transaction attached to the entry | |
| 772 // should not be impacted. Dooming an entry only means that it will no | |
| 773 // longer be returned by FindActiveEntry (and it will also be destroyed once | |
| 774 // all consumers are finished with the entry). | |
| 775 ActiveEntriesMap::iterator it = active_entries_.find(key); | |
| 776 if (it == active_entries_.end()) { | |
| 777 DCHECK(trans); | |
| 778 return AsyncDoomEntry(key, trans); | |
| 779 } | |
| 780 | |
| 781 ActiveEntry* entry = it->second; | |
| 782 active_entries_.erase(it); | |
| 783 | |
| 784 // We keep track of doomed entries so that we can ensure that they are | |
| 785 // cleaned up properly when the cache is destroyed. | |
| 786 doomed_entries_.insert(entry); | |
| 787 | |
| 788 entry->disk_entry->Doom(); | |
| 789 entry->doomed = true; | |
| 790 | |
| 791 DCHECK(entry->writer || !entry->readers.empty() || | |
| 792 entry->will_process_pending_queue); | |
| 793 return OK; | |
| 794 } | |
| 795 | |
| 796 int HttpCache::AsyncDoomEntry(const std::string& key, Transaction* trans) { | |
| 797 WorkItem* item = new WorkItem(WI_DOOM_ENTRY, trans, NULL); | |
| 798 PendingOp* pending_op = GetPendingOp(key); | |
| 799 if (pending_op->writer) { | |
| 800 pending_op->pending_queue.push_back(item); | |
| 801 return ERR_IO_PENDING; | |
| 802 } | |
| 803 | |
| 804 DCHECK(pending_op->pending_queue.empty()); | |
| 805 | |
| 806 pending_op->writer = item; | |
| 807 pending_op->callback = base::Bind(&HttpCache::OnPendingOpComplete, | |
| 808 GetWeakPtr(), pending_op); | |
| 809 | |
| 810 int rv = disk_cache_->DoomEntry(key, pending_op->callback); | |
| 811 if (rv != ERR_IO_PENDING) { | |
| 812 item->ClearTransaction(); | |
| 813 pending_op->callback.Run(rv); | |
| 814 } | |
| 815 | |
| 816 return rv; | |
| 817 } | |
| 818 | |
| 819 void HttpCache::DoomMainEntryForUrl(const GURL& url) { | |
| 820 if (!disk_cache_) | |
| 821 return; | |
| 822 | |
| 823 HttpRequestInfo temp_info; | |
| 824 temp_info.url = url; | |
| 825 temp_info.method = "GET"; | |
| 826 std::string key = GenerateCacheKey(&temp_info); | |
| 827 | |
| 828 // Defer to DoomEntry if there is an active entry, otherwise call | |
| 829 // AsyncDoomEntry without triggering a callback. | |
| 830 if (active_entries_.count(key)) | |
| 831 DoomEntry(key, NULL); | |
| 832 else | |
| 833 AsyncDoomEntry(key, NULL); | |
| 834 } | |
| 835 | |
| 836 void HttpCache::FinalizeDoomedEntry(ActiveEntry* entry) { | |
| 837 DCHECK(entry->doomed); | |
| 838 DCHECK(!entry->writer); | |
| 839 DCHECK(entry->readers.empty()); | |
| 840 DCHECK(entry->pending_queue.empty()); | |
| 841 | |
| 842 ActiveEntriesSet::iterator it = doomed_entries_.find(entry); | |
| 843 DCHECK(it != doomed_entries_.end()); | |
| 844 doomed_entries_.erase(it); | |
| 845 | |
| 846 delete entry; | |
| 847 } | |
| 848 | |
| 849 HttpCache::ActiveEntry* HttpCache::FindActiveEntry(const std::string& key) { | |
| 850 ActiveEntriesMap::const_iterator it = active_entries_.find(key); | |
| 851 return it != active_entries_.end() ? it->second : NULL; | |
| 852 } | |
| 853 | |
| 854 HttpCache::ActiveEntry* HttpCache::ActivateEntry( | |
| 855 disk_cache::Entry* disk_entry) { | |
| 856 DCHECK(!FindActiveEntry(disk_entry->GetKey())); | |
| 857 ActiveEntry* entry = new ActiveEntry(disk_entry); | |
| 858 active_entries_[disk_entry->GetKey()] = entry; | |
| 859 return entry; | |
| 860 } | |
| 861 | |
| 862 void HttpCache::DeactivateEntry(ActiveEntry* entry) { | |
| 863 DCHECK(!entry->will_process_pending_queue); | |
| 864 DCHECK(!entry->doomed); | |
| 865 DCHECK(!entry->writer); | |
| 866 DCHECK(entry->disk_entry); | |
| 867 DCHECK(entry->readers.empty()); | |
| 868 DCHECK(entry->pending_queue.empty()); | |
| 869 | |
| 870 std::string key = entry->disk_entry->GetKey(); | |
| 871 if (key.empty()) | |
| 872 return SlowDeactivateEntry(entry); | |
| 873 | |
| 874 ActiveEntriesMap::iterator it = active_entries_.find(key); | |
| 875 DCHECK(it != active_entries_.end()); | |
| 876 DCHECK(it->second == entry); | |
| 877 | |
| 878 active_entries_.erase(it); | |
| 879 delete entry; | |
| 880 } | |
| 881 | |
| 882 // We don't know this entry's key so we have to find it without it. | |
| 883 void HttpCache::SlowDeactivateEntry(ActiveEntry* entry) { | |
| 884 for (ActiveEntriesMap::iterator it = active_entries_.begin(); | |
| 885 it != active_entries_.end(); ++it) { | |
| 886 if (it->second == entry) { | |
| 887 active_entries_.erase(it); | |
| 888 delete entry; | |
| 889 break; | |
| 890 } | |
| 891 } | |
| 892 } | |
| 893 | |
| 894 HttpCache::PendingOp* HttpCache::GetPendingOp(const std::string& key) { | |
| 895 DCHECK(!FindActiveEntry(key)); | |
| 896 | |
| 897 PendingOpsMap::const_iterator it = pending_ops_.find(key); | |
| 898 if (it != pending_ops_.end()) | |
| 899 return it->second; | |
| 900 | |
| 901 PendingOp* operation = new PendingOp(); | |
| 902 pending_ops_[key] = operation; | |
| 903 return operation; | |
| 904 } | |
| 905 | |
| 906 void HttpCache::DeletePendingOp(PendingOp* pending_op) { | |
| 907 std::string key; | |
| 908 if (pending_op->disk_entry) | |
| 909 key = pending_op->disk_entry->GetKey(); | |
| 910 | |
| 911 if (!key.empty()) { | |
| 912 PendingOpsMap::iterator it = pending_ops_.find(key); | |
| 913 DCHECK(it != pending_ops_.end()); | |
| 914 pending_ops_.erase(it); | |
| 915 } else { | |
| 916 for (PendingOpsMap::iterator it = pending_ops_.begin(); | |
| 917 it != pending_ops_.end(); ++it) { | |
| 918 if (it->second == pending_op) { | |
| 919 pending_ops_.erase(it); | |
| 920 break; | |
| 921 } | |
| 922 } | |
| 923 } | |
| 924 DCHECK(pending_op->pending_queue.empty()); | |
| 925 | |
| 926 delete pending_op; | |
| 927 } | |
| 928 | |
| 929 int HttpCache::OpenEntry(const std::string& key, ActiveEntry** entry, | |
| 930 Transaction* trans) { | |
| 931 ActiveEntry* active_entry = FindActiveEntry(key); | |
| 932 if (active_entry) { | |
| 933 *entry = active_entry; | |
| 934 return OK; | |
| 935 } | |
| 936 | |
| 937 WorkItem* item = new WorkItem(WI_OPEN_ENTRY, trans, entry); | |
| 938 PendingOp* pending_op = GetPendingOp(key); | |
| 939 if (pending_op->writer) { | |
| 940 pending_op->pending_queue.push_back(item); | |
| 941 return ERR_IO_PENDING; | |
| 942 } | |
| 943 | |
| 944 DCHECK(pending_op->pending_queue.empty()); | |
| 945 | |
| 946 pending_op->writer = item; | |
| 947 pending_op->callback = base::Bind(&HttpCache::OnPendingOpComplete, | |
| 948 GetWeakPtr(), pending_op); | |
| 949 | |
| 950 int rv = disk_cache_->OpenEntry(key, &(pending_op->disk_entry), | |
| 951 pending_op->callback); | |
| 952 if (rv != ERR_IO_PENDING) { | |
| 953 item->ClearTransaction(); | |
| 954 pending_op->callback.Run(rv); | |
| 955 } | |
| 956 | |
| 957 return rv; | |
| 958 } | |
| 959 | |
| 960 int HttpCache::CreateEntry(const std::string& key, ActiveEntry** entry, | |
| 961 Transaction* trans) { | |
| 962 if (FindActiveEntry(key)) { | |
| 963 return ERR_CACHE_RACE; | |
| 964 } | |
| 965 | |
| 966 WorkItem* item = new WorkItem(WI_CREATE_ENTRY, trans, entry); | |
| 967 PendingOp* pending_op = GetPendingOp(key); | |
| 968 if (pending_op->writer) { | |
| 969 pending_op->pending_queue.push_back(item); | |
| 970 return ERR_IO_PENDING; | |
| 971 } | |
| 972 | |
| 973 DCHECK(pending_op->pending_queue.empty()); | |
| 974 | |
| 975 pending_op->writer = item; | |
| 976 pending_op->callback = base::Bind(&HttpCache::OnPendingOpComplete, | |
| 977 GetWeakPtr(), pending_op); | |
| 978 | |
| 979 int rv = disk_cache_->CreateEntry(key, &(pending_op->disk_entry), | |
| 980 pending_op->callback); | |
| 981 if (rv != ERR_IO_PENDING) { | |
| 982 item->ClearTransaction(); | |
| 983 pending_op->callback.Run(rv); | |
| 984 } | |
| 985 | |
| 986 return rv; | |
| 987 } | |
| 988 | |
| 989 void HttpCache::DestroyEntry(ActiveEntry* entry) { | |
| 990 if (entry->doomed) { | |
| 991 FinalizeDoomedEntry(entry); | |
| 992 } else { | |
| 993 DeactivateEntry(entry); | |
| 994 } | |
| 995 } | |
| 996 | |
| 997 int HttpCache::AddTransactionToEntry(ActiveEntry* entry, Transaction* trans) { | |
| 998 DCHECK(entry); | |
| 999 DCHECK(entry->disk_entry); | |
| 1000 | |
| 1001 // We implement a basic reader/writer lock for the disk cache entry. If | |
| 1002 // there is already a writer, then everyone has to wait for the writer to | |
| 1003 // finish before they can access the cache entry. There can be multiple | |
| 1004 // readers. | |
| 1005 // | |
| 1006 // NOTE: If the transaction can only write, then the entry should not be in | |
| 1007 // use (since any existing entry should have already been doomed). | |
| 1008 | |
| 1009 if (entry->writer || entry->will_process_pending_queue) { | |
| 1010 entry->pending_queue.push_back(trans); | |
| 1011 return ERR_IO_PENDING; | |
| 1012 } | |
| 1013 | |
| 1014 if (trans->mode() & Transaction::WRITE) { | |
| 1015 // transaction needs exclusive access to the entry | |
| 1016 if (entry->readers.empty()) { | |
| 1017 entry->writer = trans; | |
| 1018 } else { | |
| 1019 entry->pending_queue.push_back(trans); | |
| 1020 return ERR_IO_PENDING; | |
| 1021 } | |
| 1022 } else { | |
| 1023 // transaction needs read access to the entry | |
| 1024 entry->readers.push_back(trans); | |
| 1025 } | |
| 1026 | |
| 1027 // We do this before calling EntryAvailable to force any further calls to | |
| 1028 // AddTransactionToEntry to add their transaction to the pending queue, which | |
| 1029 // ensures FIFO ordering. | |
| 1030 if (!entry->writer && !entry->pending_queue.empty()) | |
| 1031 ProcessPendingQueue(entry); | |
| 1032 | |
| 1033 return OK; | |
| 1034 } | |
| 1035 | |
| 1036 void HttpCache::DoneWithEntry(ActiveEntry* entry, Transaction* trans, | |
| 1037 bool cancel) { | |
| 1038 // If we already posted a task to move on to the next transaction and this was | |
| 1039 // the writer, there is nothing to cancel. | |
| 1040 if (entry->will_process_pending_queue && entry->readers.empty()) | |
| 1041 return; | |
| 1042 | |
| 1043 if (entry->writer) { | |
| 1044 DCHECK(trans == entry->writer); | |
| 1045 | |
| 1046 // Assume there was a failure. | |
| 1047 bool success = false; | |
| 1048 if (cancel) { | |
| 1049 DCHECK(entry->disk_entry); | |
| 1050 // This is a successful operation in the sense that we want to keep the | |
| 1051 // entry. | |
| 1052 success = trans->AddTruncatedFlag(); | |
| 1053 // The previous operation may have deleted the entry. | |
| 1054 if (!trans->entry()) | |
| 1055 return; | |
| 1056 } | |
| 1057 DoneWritingToEntry(entry, success); | |
| 1058 } else { | |
| 1059 DoneReadingFromEntry(entry, trans); | |
| 1060 } | |
| 1061 } | |
| 1062 | |
| 1063 void HttpCache::DoneWritingToEntry(ActiveEntry* entry, bool success) { | |
| 1064 DCHECK(entry->readers.empty()); | |
| 1065 | |
| 1066 entry->writer = NULL; | |
| 1067 | |
| 1068 if (success) { | |
| 1069 ProcessPendingQueue(entry); | |
| 1070 } else { | |
| 1071 DCHECK(!entry->will_process_pending_queue); | |
| 1072 | |
| 1073 // We failed to create this entry. | |
| 1074 TransactionList pending_queue; | |
| 1075 pending_queue.swap(entry->pending_queue); | |
| 1076 | |
| 1077 entry->disk_entry->Doom(); | |
| 1078 DestroyEntry(entry); | |
| 1079 | |
| 1080 // We need to do something about these pending entries, which now need to | |
| 1081 // be added to a new entry. | |
| 1082 while (!pending_queue.empty()) { | |
| 1083 // ERR_CACHE_RACE causes the transaction to restart the whole process. | |
| 1084 pending_queue.front()->io_callback().Run(ERR_CACHE_RACE); | |
| 1085 pending_queue.pop_front(); | |
| 1086 } | |
| 1087 } | |
| 1088 } | |
| 1089 | |
| 1090 void HttpCache::DoneReadingFromEntry(ActiveEntry* entry, Transaction* trans) { | |
| 1091 DCHECK(!entry->writer); | |
| 1092 | |
| 1093 TransactionList::iterator it = | |
| 1094 std::find(entry->readers.begin(), entry->readers.end(), trans); | |
| 1095 DCHECK(it != entry->readers.end()); | |
| 1096 | |
| 1097 entry->readers.erase(it); | |
| 1098 | |
| 1099 ProcessPendingQueue(entry); | |
| 1100 } | |
| 1101 | |
| 1102 void HttpCache::ConvertWriterToReader(ActiveEntry* entry) { | |
| 1103 DCHECK(entry->writer); | |
| 1104 DCHECK(entry->writer->mode() == Transaction::READ_WRITE); | |
| 1105 DCHECK(entry->readers.empty()); | |
| 1106 | |
| 1107 Transaction* trans = entry->writer; | |
| 1108 | |
| 1109 entry->writer = NULL; | |
| 1110 entry->readers.push_back(trans); | |
| 1111 | |
| 1112 ProcessPendingQueue(entry); | |
| 1113 } | |
| 1114 | |
| 1115 LoadState HttpCache::GetLoadStateForPendingTransaction( | |
| 1116 const Transaction* trans) { | |
| 1117 ActiveEntriesMap::const_iterator i = active_entries_.find(trans->key()); | |
| 1118 if (i == active_entries_.end()) { | |
| 1119 // If this is really a pending transaction, and it is not part of | |
| 1120 // active_entries_, we should be creating the backend or the entry. | |
| 1121 return LOAD_STATE_WAITING_FOR_CACHE; | |
| 1122 } | |
| 1123 | |
| 1124 Transaction* writer = i->second->writer; | |
| 1125 return writer ? writer->GetWriterLoadState() : LOAD_STATE_WAITING_FOR_CACHE; | |
| 1126 } | |
| 1127 | |
| 1128 void HttpCache::RemovePendingTransaction(Transaction* trans) { | |
| 1129 ActiveEntriesMap::const_iterator i = active_entries_.find(trans->key()); | |
| 1130 bool found = false; | |
| 1131 if (i != active_entries_.end()) | |
| 1132 found = RemovePendingTransactionFromEntry(i->second, trans); | |
| 1133 | |
| 1134 if (found) | |
| 1135 return; | |
| 1136 | |
| 1137 if (building_backend_) { | |
| 1138 PendingOpsMap::const_iterator j = pending_ops_.find(std::string()); | |
| 1139 if (j != pending_ops_.end()) | |
| 1140 found = RemovePendingTransactionFromPendingOp(j->second, trans); | |
| 1141 | |
| 1142 if (found) | |
| 1143 return; | |
| 1144 } | |
| 1145 | |
| 1146 PendingOpsMap::const_iterator j = pending_ops_.find(trans->key()); | |
| 1147 if (j != pending_ops_.end()) | |
| 1148 found = RemovePendingTransactionFromPendingOp(j->second, trans); | |
| 1149 | |
| 1150 if (found) | |
| 1151 return; | |
| 1152 | |
| 1153 ActiveEntriesSet::iterator k = doomed_entries_.begin(); | |
| 1154 for (; k != doomed_entries_.end() && !found; ++k) | |
| 1155 found = RemovePendingTransactionFromEntry(*k, trans); | |
| 1156 | |
| 1157 DCHECK(found) << "Pending transaction not found"; | |
| 1158 } | |
| 1159 | |
| 1160 bool HttpCache::RemovePendingTransactionFromEntry(ActiveEntry* entry, | |
| 1161 Transaction* trans) { | |
| 1162 TransactionList& pending_queue = entry->pending_queue; | |
| 1163 | |
| 1164 TransactionList::iterator j = | |
| 1165 find(pending_queue.begin(), pending_queue.end(), trans); | |
| 1166 if (j == pending_queue.end()) | |
| 1167 return false; | |
| 1168 | |
| 1169 pending_queue.erase(j); | |
| 1170 return true; | |
| 1171 } | |
| 1172 | |
| 1173 bool HttpCache::RemovePendingTransactionFromPendingOp(PendingOp* pending_op, | |
| 1174 Transaction* trans) { | |
| 1175 if (pending_op->writer->Matches(trans)) { | |
| 1176 pending_op->writer->ClearTransaction(); | |
| 1177 pending_op->writer->ClearEntry(); | |
| 1178 return true; | |
| 1179 } | |
| 1180 WorkItemList& pending_queue = pending_op->pending_queue; | |
| 1181 | |
| 1182 WorkItemList::iterator it = pending_queue.begin(); | |
| 1183 for (; it != pending_queue.end(); ++it) { | |
| 1184 if ((*it)->Matches(trans)) { | |
| 1185 delete *it; | |
| 1186 pending_queue.erase(it); | |
| 1187 return true; | |
| 1188 } | |
| 1189 } | |
| 1190 return false; | |
| 1191 } | |
| 1192 | |
| 1193 void HttpCache::SetupQuicServerInfoFactory(HttpNetworkSession* session) { | |
| 1194 if (session && | |
| 1195 !session->quic_stream_factory()->has_quic_server_info_factory()) { | |
| 1196 DCHECK(!quic_server_info_factory_); | |
| 1197 quic_server_info_factory_.reset(new QuicServerInfoFactoryAdaptor(this)); | |
| 1198 session->quic_stream_factory()->set_quic_server_info_factory( | |
| 1199 quic_server_info_factory_.get()); | |
| 1200 } | |
| 1201 } | |
| 1202 | |
| 1203 void HttpCache::ProcessPendingQueue(ActiveEntry* entry) { | |
| 1204 // Multiple readers may finish with an entry at once, so we want to batch up | |
| 1205 // calls to OnProcessPendingQueue. This flag also tells us that we should | |
| 1206 // not delete the entry before OnProcessPendingQueue runs. | |
| 1207 if (entry->will_process_pending_queue) | |
| 1208 return; | |
| 1209 entry->will_process_pending_queue = true; | |
| 1210 | |
| 1211 base::MessageLoop::current()->PostTask( | |
| 1212 FROM_HERE, | |
| 1213 base::Bind(&HttpCache::OnProcessPendingQueue, GetWeakPtr(), entry)); | |
| 1214 } | |
| 1215 | |
| 1216 void HttpCache::PerformAsyncValidation(const HttpRequestInfo& original_request, | |
| 1217 const BoundNetLog& net_log) { | |
| 1218 DCHECK(use_stale_while_revalidate_); | |
| 1219 std::string key = GenerateCacheKey(&original_request); | |
| 1220 AsyncValidation* async_validation = | |
| 1221 new AsyncValidation(original_request, this); | |
| 1222 typedef AsyncValidationMap::value_type AsyncValidationKeyValue; | |
| 1223 bool insert_ok = | |
| 1224 async_validations_.insert(AsyncValidationKeyValue(key, async_validation)) | |
| 1225 .second; | |
| 1226 if (!insert_ok) { | |
| 1227 DVLOG(1) << "Harmless race condition detected on URL " | |
| 1228 << original_request.url << "; discarding redundant revalidation."; | |
| 1229 delete async_validation; | |
| 1230 return; | |
| 1231 } | |
| 1232 HttpNetworkSession* network_session = GetSession(); | |
| 1233 NetworkDelegate* network_delegate = NULL; | |
| 1234 if (network_session) | |
| 1235 network_delegate = network_session->network_delegate(); | |
| 1236 scoped_ptr<HttpTransaction> transaction; | |
| 1237 CreateTransaction(IDLE, &transaction); | |
| 1238 scoped_ptr<Transaction> downcast_transaction( | |
| 1239 static_cast<Transaction*>(transaction.release())); | |
| 1240 async_validation->Start( | |
| 1241 net_log, downcast_transaction.Pass(), network_delegate); | |
| 1242 // |async_validation| may have been deleted here. | |
| 1243 } | |
| 1244 | |
| 1245 void HttpCache::DeleteAsyncValidation(const std::string& url) { | |
| 1246 AsyncValidationMap::iterator it = async_validations_.find(url); | |
| 1247 CHECK(it != async_validations_.end()); // security-critical invariant | |
| 1248 AsyncValidation* async_validation = it->second; | |
| 1249 async_validations_.erase(it); | |
| 1250 delete async_validation; | |
| 1251 } | |
| 1252 | |
| 1253 void HttpCache::OnProcessPendingQueue(ActiveEntry* entry) { | |
| 1254 entry->will_process_pending_queue = false; | |
| 1255 DCHECK(!entry->writer); | |
| 1256 | |
| 1257 // If no one is interested in this entry, then we can deactivate it. | |
| 1258 if (entry->pending_queue.empty()) { | |
| 1259 if (entry->readers.empty()) | |
| 1260 DestroyEntry(entry); | |
| 1261 return; | |
| 1262 } | |
| 1263 | |
| 1264 // Promote next transaction from the pending queue. | |
| 1265 Transaction* next = entry->pending_queue.front(); | |
| 1266 if ((next->mode() & Transaction::WRITE) && !entry->readers.empty()) | |
| 1267 return; // Have to wait. | |
| 1268 | |
| 1269 entry->pending_queue.erase(entry->pending_queue.begin()); | |
| 1270 | |
| 1271 int rv = AddTransactionToEntry(entry, next); | |
| 1272 if (rv != ERR_IO_PENDING) { | |
| 1273 next->io_callback().Run(rv); | |
| 1274 } | |
| 1275 } | |
| 1276 | |
| 1277 void HttpCache::OnIOComplete(int result, PendingOp* pending_op) { | |
| 1278 WorkItemOperation op = pending_op->writer->operation(); | |
| 1279 | |
| 1280 // Completing the creation of the backend is simpler than the other cases. | |
| 1281 if (op == WI_CREATE_BACKEND) | |
| 1282 return OnBackendCreated(result, pending_op); | |
| 1283 | |
| 1284 scoped_ptr<WorkItem> item(pending_op->writer); | |
| 1285 bool fail_requests = false; | |
| 1286 | |
| 1287 ActiveEntry* entry = NULL; | |
| 1288 std::string key; | |
| 1289 if (result == OK) { | |
| 1290 if (op == WI_DOOM_ENTRY) { | |
| 1291 // Anything after a Doom has to be restarted. | |
| 1292 fail_requests = true; | |
| 1293 } else if (item->IsValid()) { | |
| 1294 key = pending_op->disk_entry->GetKey(); | |
| 1295 entry = ActivateEntry(pending_op->disk_entry); | |
| 1296 } else { | |
| 1297 // The writer transaction is gone. | |
| 1298 if (op == WI_CREATE_ENTRY) | |
| 1299 pending_op->disk_entry->Doom(); | |
| 1300 pending_op->disk_entry->Close(); | |
| 1301 pending_op->disk_entry = NULL; | |
| 1302 fail_requests = true; | |
| 1303 } | |
| 1304 } | |
| 1305 | |
| 1306 // We are about to notify a bunch of transactions, and they may decide to | |
| 1307 // re-issue a request (or send a different one). If we don't delete | |
| 1308 // pending_op, the new request will be appended to the end of the list, and | |
| 1309 // we'll see it again from this point before it has a chance to complete (and | |
| 1310 // we'll be messing out the request order). The down side is that if for some | |
| 1311 // reason notifying request A ends up cancelling request B (for the same key), | |
| 1312 // we won't find request B anywhere (because it would be in a local variable | |
| 1313 // here) and that's bad. If there is a chance for that to happen, we'll have | |
| 1314 // to move the callback used to be a CancelableCallback. By the way, for this | |
| 1315 // to happen the action (to cancel B) has to be synchronous to the | |
| 1316 // notification for request A. | |
| 1317 WorkItemList pending_items; | |
| 1318 pending_items.swap(pending_op->pending_queue); | |
| 1319 DeletePendingOp(pending_op); | |
| 1320 | |
| 1321 item->NotifyTransaction(result, entry); | |
| 1322 | |
| 1323 while (!pending_items.empty()) { | |
| 1324 item.reset(pending_items.front()); | |
| 1325 pending_items.pop_front(); | |
| 1326 | |
| 1327 if (item->operation() == WI_DOOM_ENTRY) { | |
| 1328 // A queued doom request is always a race. | |
| 1329 fail_requests = true; | |
| 1330 } else if (result == OK) { | |
| 1331 entry = FindActiveEntry(key); | |
| 1332 if (!entry) | |
| 1333 fail_requests = true; | |
| 1334 } | |
| 1335 | |
| 1336 if (fail_requests) { | |
| 1337 item->NotifyTransaction(ERR_CACHE_RACE, NULL); | |
| 1338 continue; | |
| 1339 } | |
| 1340 | |
| 1341 if (item->operation() == WI_CREATE_ENTRY) { | |
| 1342 if (result == OK) { | |
| 1343 // A second Create request, but the first request succeeded. | |
| 1344 item->NotifyTransaction(ERR_CACHE_CREATE_FAILURE, NULL); | |
| 1345 } else { | |
| 1346 if (op != WI_CREATE_ENTRY) { | |
| 1347 // Failed Open followed by a Create. | |
| 1348 item->NotifyTransaction(ERR_CACHE_RACE, NULL); | |
| 1349 fail_requests = true; | |
| 1350 } else { | |
| 1351 item->NotifyTransaction(result, entry); | |
| 1352 } | |
| 1353 } | |
| 1354 } else { | |
| 1355 if (op == WI_CREATE_ENTRY && result != OK) { | |
| 1356 // Failed Create followed by an Open. | |
| 1357 item->NotifyTransaction(ERR_CACHE_RACE, NULL); | |
| 1358 fail_requests = true; | |
| 1359 } else { | |
| 1360 item->NotifyTransaction(result, entry); | |
| 1361 } | |
| 1362 } | |
| 1363 } | |
| 1364 } | |
| 1365 | |
| 1366 // static | |
| 1367 void HttpCache::OnPendingOpComplete(const base::WeakPtr<HttpCache>& cache, | |
| 1368 PendingOp* pending_op, | |
| 1369 int rv) { | |
| 1370 // TODO(vadimt): Remove ScopedTracker below once crbug.com/422516 is fixed. | |
| 1371 tracked_objects::ScopedTracker tracking_profile( | |
| 1372 FROM_HERE_WITH_EXPLICIT_FUNCTION( | |
| 1373 "422516 HttpCache::OnPendingOpComplete")); | |
| 1374 | |
| 1375 if (cache.get()) { | |
| 1376 cache->OnIOComplete(rv, pending_op); | |
| 1377 } else { | |
| 1378 // The callback was cancelled so we should delete the pending_op that | |
| 1379 // was used with this callback. | |
| 1380 delete pending_op; | |
| 1381 } | |
| 1382 } | |
| 1383 | |
| 1384 void HttpCache::OnBackendCreated(int result, PendingOp* pending_op) { | |
| 1385 scoped_ptr<WorkItem> item(pending_op->writer); | |
| 1386 WorkItemOperation op = item->operation(); | |
| 1387 DCHECK_EQ(WI_CREATE_BACKEND, op); | |
| 1388 | |
| 1389 // We don't need the callback anymore. | |
| 1390 pending_op->callback.Reset(); | |
| 1391 | |
| 1392 if (backend_factory_.get()) { | |
| 1393 // We may end up calling OnBackendCreated multiple times if we have pending | |
| 1394 // work items. The first call saves the backend and releases the factory, | |
| 1395 // and the last call clears building_backend_. | |
| 1396 backend_factory_.reset(); // Reclaim memory. | |
| 1397 if (result == OK) { | |
| 1398 disk_cache_ = pending_op->backend.Pass(); | |
| 1399 if (UseCertCache()) | |
| 1400 cert_cache_.reset(new DiskBasedCertCache(disk_cache_.get())); | |
| 1401 } | |
| 1402 } | |
| 1403 | |
| 1404 if (!pending_op->pending_queue.empty()) { | |
| 1405 WorkItem* pending_item = pending_op->pending_queue.front(); | |
| 1406 pending_op->pending_queue.pop_front(); | |
| 1407 DCHECK_EQ(WI_CREATE_BACKEND, pending_item->operation()); | |
| 1408 | |
| 1409 // We want to process a single callback at a time, because the cache may | |
| 1410 // go away from the callback. | |
| 1411 pending_op->writer = pending_item; | |
| 1412 | |
| 1413 base::MessageLoop::current()->PostTask( | |
| 1414 FROM_HERE, | |
| 1415 base::Bind(&HttpCache::OnBackendCreated, GetWeakPtr(), | |
| 1416 result, pending_op)); | |
| 1417 } else { | |
| 1418 building_backend_ = false; | |
| 1419 DeletePendingOp(pending_op); | |
| 1420 } | |
| 1421 | |
| 1422 // The cache may be gone when we return from the callback. | |
| 1423 if (!item->DoCallback(result, disk_cache_.get())) | |
| 1424 item->NotifyTransaction(result, NULL); | |
| 1425 } | |
| 1426 | |
| 1427 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master