OLD | NEW |
---|---|
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/http/http_cache.h" | 5 #include "net/http/http_cache.h" |
6 | 6 |
7 #include <algorithm> | 7 #include <algorithm> |
8 | 8 |
9 #include "base/compiler_specific.h" | 9 #include "base/compiler_specific.h" |
10 | 10 |
11 #if defined(OS_POSIX) | 11 #if defined(OS_POSIX) |
12 #include <unistd.h> | 12 #include <unistd.h> |
13 #endif | 13 #endif |
14 | 14 |
15 #include "base/bind.h" | 15 #include "base/bind.h" |
16 #include "base/bind_helpers.h" | 16 #include "base/bind_helpers.h" |
17 #include "base/callback.h" | 17 #include "base/callback.h" |
18 #include "base/file_util.h" | 18 #include "base/file_util.h" |
19 #include "base/format_macros.h" | 19 #include "base/format_macros.h" |
20 #include "base/location.h" | 20 #include "base/location.h" |
21 #include "base/memory/ref_counted.h" | 21 #include "base/memory/ref_counted.h" |
22 #include "base/message_loop/message_loop.h" | 22 #include "base/message_loop/message_loop.h" |
23 #include "base/metrics/field_trial.h" | 23 #include "base/metrics/field_trial.h" |
24 #include "base/metrics/histogram.h" | |
24 #include "base/pickle.h" | 25 #include "base/pickle.h" |
25 #include "base/stl_util.h" | 26 #include "base/stl_util.h" |
26 #include "base/strings/string_number_conversions.h" | 27 #include "base/strings/string_number_conversions.h" |
27 #include "base/strings/string_util.h" | 28 #include "base/strings/string_util.h" |
28 #include "base/strings/stringprintf.h" | 29 #include "base/strings/stringprintf.h" |
29 #include "base/threading/worker_pool.h" | 30 #include "base/threading/worker_pool.h" |
31 #include "base/time/time.h" | |
30 #include "net/base/cache_type.h" | 32 #include "net/base/cache_type.h" |
31 #include "net/base/io_buffer.h" | 33 #include "net/base/io_buffer.h" |
32 #include "net/base/load_flags.h" | 34 #include "net/base/load_flags.h" |
33 #include "net/base/net_errors.h" | 35 #include "net/base/net_errors.h" |
36 #include "net/base/network_delegate.h" | |
34 #include "net/base/upload_data_stream.h" | 37 #include "net/base/upload_data_stream.h" |
35 #include "net/disk_cache/disk_cache.h" | 38 #include "net/disk_cache/disk_cache.h" |
36 #include "net/http/disk_based_cert_cache.h" | 39 #include "net/http/disk_based_cert_cache.h" |
37 #include "net/http/disk_cache_based_quic_server_info.h" | 40 #include "net/http/disk_cache_based_quic_server_info.h" |
38 #include "net/http/http_cache_transaction.h" | 41 #include "net/http/http_cache_transaction.h" |
39 #include "net/http/http_network_layer.h" | 42 #include "net/http/http_network_layer.h" |
40 #include "net/http/http_network_session.h" | 43 #include "net/http/http_network_session.h" |
41 #include "net/http/http_request_info.h" | 44 #include "net/http/http_request_info.h" |
42 #include "net/http/http_response_headers.h" | 45 #include "net/http/http_response_headers.h" |
43 #include "net/http/http_response_info.h" | 46 #include "net/http/http_response_info.h" |
(...skipping 241 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
285 virtual QuicServerInfo* GetForServer( | 288 virtual QuicServerInfo* GetForServer( |
286 const QuicServerId& server_id) OVERRIDE { | 289 const QuicServerId& server_id) OVERRIDE { |
287 return new DiskCacheBasedQuicServerInfo(server_id, http_cache_); | 290 return new DiskCacheBasedQuicServerInfo(server_id, http_cache_); |
288 } | 291 } |
289 | 292 |
290 private: | 293 private: |
291 HttpCache* const http_cache_; | 294 HttpCache* const http_cache_; |
292 }; | 295 }; |
293 | 296 |
294 //----------------------------------------------------------------------------- | 297 //----------------------------------------------------------------------------- |
298 | |
299 class HttpCache::AsyncValidation { | |
300 public: | |
301 AsyncValidation(const HttpRequestInfo& original_request, HttpCache* cache) | |
302 : request_(original_request), cache_(cache) {} | |
303 ~AsyncValidation() {} | |
304 | |
305 void Start(const BoundNetLog& net_log, NetworkDelegate* network_delegate); | |
306 | |
307 private: | |
308 void OnStarted(int result); | |
309 void DoRead(); | |
310 void OnRead(int result); | |
311 | |
312 // Terminate this request with net error code |result|. Logs the transaction | |
313 // result and asks HttpCache to delete this object. | |
314 // If there was a client or server certificate error, it cannot be recovered | |
315 // asynchronously, so we need to prevent futures attempts to asynchronously | |
316 // fetch the resource. In this case, the cache entry is doomed. | |
317 void Terminate(int result); | |
318 | |
319 HttpRequestInfo request_; | |
320 scoped_refptr<IOBuffer> buf_; | |
321 CompletionCallback read_callback_; | |
322 scoped_ptr<Transaction> transaction_; | |
323 base::Time start_time_; | |
324 | |
325 // The HttpCache object owns this object. This object is always deleted before | |
326 // the pointer to the cache becomes invalid. | |
327 HttpCache* cache_; | |
328 | |
329 DISALLOW_COPY_AND_ASSIGN(AsyncValidation); | |
330 }; | |
331 | |
332 void HttpCache::AsyncValidation::Start(const BoundNetLog& net_log, | |
333 NetworkDelegate* network_delegate) { | |
334 scoped_ptr<HttpTransaction> transaction; | |
335 cache_->CreateTransaction(IDLE, &transaction); | |
336 if (network_delegate) { | |
337 // This code is necessary to enable async transactions to pass over the | |
338 // data-reduction proxy. This is a violation of the "once-and-only-once" | |
339 // principle, since it copies code from URLRequestHttpJob. We cannot use the | |
340 // original callback passed to HttpCache::Transaction by URLRequestHttpJob | |
341 // as it will only be valid as long as the URLRequestHttpJob object is | |
342 // alive, and that object will be deleted as soon as the synchronous request | |
343 // completes. | |
344 // | |
345 // This code is also an encapsulation violation. We are exploiting the fact | |
346 // that the |request| parameter to NotifyBeforeSendProxyHeaders() is never | |
347 // actually used for anything, and so can be NULL. | |
348 // | |
349 // TODO(ricea): Do this better. | |
350 transaction->SetBeforeProxyHeadersSentCallback( | |
351 base::Bind(&NetworkDelegate::NotifyBeforeSendProxyHeaders, | |
352 base::Unretained(network_delegate), | |
353 static_cast<URLRequest*>(NULL))); | |
354 // The above use of base::Unretained is safe because the NetworkDelegate has | |
355 // to live at least as long as the HttpNetworkSession which has to live as | |
356 // least as long as the HttpNetworkLayer which has to live at least as long | |
357 // this HttpCache object. | |
358 } | |
359 | |
360 transaction_.reset(static_cast<Transaction*>(transaction.release())); | |
rvargas (doing something else)
2014/09/05 22:52:39
... or, pass the transaction at construction...
Adam Rice
2014/09/09 12:36:45
DoomEntry() requires an HttpCache::Transaction. We
rvargas (doing something else)
2014/09/11 02:33:05
yes, I was thinking that the cache could pass an H
Adam Rice
2014/09/12 01:46:48
I like this idea. Done.
| |
361 DCHECK_EQ(0, request_.load_flags & LOAD_ASYNC_REVALIDATION); | |
362 request_.load_flags |= LOAD_ASYNC_REVALIDATION; | |
363 start_time_ = base::Time::Now(); | |
364 // This use of base::Unretained is safe because |transaction_| is owned by | |
365 // this object. | |
366 read_callback_ = base::Bind(&AsyncValidation::OnRead, base::Unretained(this)); | |
367 // This use of base::Unretained is safe as above. | |
368 int rv = transaction_->Start( | |
369 &request_, | |
370 base::Bind(&AsyncValidation::OnStarted, base::Unretained(this)), | |
371 net_log); | |
372 | |
373 if (rv == ERR_IO_PENDING) | |
374 return; | |
375 | |
376 OnStarted(rv); | |
377 } | |
378 | |
379 void HttpCache::AsyncValidation::OnStarted(int result) { | |
380 if (result != OK) { | |
381 DVLOG(1) << "Asynchronous transaction start failed for " << request_.url; | |
382 Terminate(result); | |
383 return; | |
384 } | |
385 | |
386 DoRead(); | |
387 } | |
388 | |
389 void HttpCache::AsyncValidation::DoRead() { | |
390 const size_t kBufSize = 4096; | |
391 if (!buf_) | |
392 buf_ = new IOBuffer(kBufSize); | |
393 | |
394 int rv = 0; | |
395 do { | |
396 rv = transaction_->Read(buf_.get(), kBufSize, read_callback_); | |
397 } while (rv > 0); | |
398 | |
399 if (rv == ERR_IO_PENDING) | |
400 return; | |
401 | |
402 OnRead(rv); | |
403 } | |
404 | |
405 void HttpCache::AsyncValidation::OnRead(int result) { | |
406 if (result > 0) { | |
407 DoRead(); | |
408 return; | |
409 } | |
410 Terminate(result); | |
411 } | |
412 | |
413 void HttpCache::AsyncValidation::Terminate(int result) { | |
414 if (result == ERR_SSL_CLIENT_AUTH_CERT_NEEDED || IsCertificateError(result)) { | |
415 // We should not attempt to access this resource asynchronously again until | |
416 // the certificate problem has been resolved. | |
417 // TODO(ricea): Mark the entry as requiring synchronous revalidation rather | |
418 // than just deleting it. | |
419 cache_->DoomEntry(transaction_->key(), transaction_.get()); | |
420 } | |
421 base::TimeDelta duration = base::Time::Now() - start_time_; | |
422 UMA_HISTOGRAM_TIMES("HttpCache.AsyncValidationDuration", duration); | |
423 transaction_->net_log().EndEventWithNetErrorCode( | |
424 NetLog::TYPE_ASYNC_REVALIDATION, result); | |
425 cache_->DeleteAsyncValidation(this); | |
426 // |this| is deleted. | |
427 } | |
428 | |
429 //----------------------------------------------------------------------------- | |
295 HttpCache::HttpCache(const net::HttpNetworkSession::Params& params, | 430 HttpCache::HttpCache(const net::HttpNetworkSession::Params& params, |
296 BackendFactory* backend_factory) | 431 BackendFactory* backend_factory) |
297 : net_log_(params.net_log), | 432 : net_log_(params.net_log), |
298 backend_factory_(backend_factory), | 433 backend_factory_(backend_factory), |
299 building_backend_(false), | 434 building_backend_(false), |
300 bypass_lock_for_test_(false), | 435 bypass_lock_for_test_(false), |
436 use_stale_while_revalidate_(params.use_stale_while_revalidate), | |
301 mode_(NORMAL), | 437 mode_(NORMAL), |
302 network_layer_(new HttpNetworkLayer(new HttpNetworkSession(params))), | 438 network_layer_(new HttpNetworkLayer(new HttpNetworkSession(params))), |
303 weak_factory_(this) { | 439 weak_factory_(this) { |
304 SetupQuicServerInfoFactory(network_layer_->GetSession()); | 440 SetupQuicServerInfoFactory(network_layer_->GetSession()); |
305 } | 441 } |
306 | 442 |
307 | 443 |
308 // This call doesn't change the shared |session|'s QuicServerInfoFactory because | 444 // This call doesn't change the shared |session|'s QuicServerInfoFactory because |
309 // |session| is shared. | 445 // |session| is shared. |
310 HttpCache::HttpCache(HttpNetworkSession* session, | 446 HttpCache::HttpCache(HttpNetworkSession* session, |
311 BackendFactory* backend_factory) | 447 BackendFactory* backend_factory) |
312 : net_log_(session->net_log()), | 448 : net_log_(session->net_log()), |
313 backend_factory_(backend_factory), | 449 backend_factory_(backend_factory), |
314 building_backend_(false), | 450 building_backend_(false), |
315 bypass_lock_for_test_(false), | 451 bypass_lock_for_test_(false), |
452 use_stale_while_revalidate_(session->params().use_stale_while_revalidate), | |
316 mode_(NORMAL), | 453 mode_(NORMAL), |
317 network_layer_(new HttpNetworkLayer(session)), | 454 network_layer_(new HttpNetworkLayer(session)), |
318 weak_factory_(this) { | 455 weak_factory_(this) { |
319 } | 456 } |
320 | 457 |
321 HttpCache::HttpCache(HttpTransactionFactory* network_layer, | 458 HttpCache::HttpCache(HttpTransactionFactory* network_layer, |
322 NetLog* net_log, | 459 NetLog* net_log, |
323 BackendFactory* backend_factory) | 460 BackendFactory* backend_factory) |
324 : net_log_(net_log), | 461 : net_log_(net_log), |
325 backend_factory_(backend_factory), | 462 backend_factory_(backend_factory), |
326 building_backend_(false), | 463 building_backend_(false), |
327 bypass_lock_for_test_(false), | 464 bypass_lock_for_test_(false), |
465 use_stale_while_revalidate_(false), | |
328 mode_(NORMAL), | 466 mode_(NORMAL), |
329 network_layer_(network_layer), | 467 network_layer_(network_layer), |
330 weak_factory_(this) { | 468 weak_factory_(this) { |
331 SetupQuicServerInfoFactory(network_layer_->GetSession()); | 469 SetupQuicServerInfoFactory(network_layer_->GetSession()); |
470 HttpNetworkSession* session = network_layer_->GetSession(); | |
471 if (session) | |
472 use_stale_while_revalidate_ = session->params().use_stale_while_revalidate; | |
332 } | 473 } |
333 | 474 |
334 HttpCache::~HttpCache() { | 475 HttpCache::~HttpCache() { |
335 // Transactions should see an invalid cache after this point; otherwise they | 476 // Transactions should see an invalid cache after this point; otherwise they |
336 // could see an inconsistent object (half destroyed). | 477 // could see an inconsistent object (half destroyed). |
337 weak_factory_.InvalidateWeakPtrs(); | 478 weak_factory_.InvalidateWeakPtrs(); |
338 | 479 |
339 // If we have any active entries remaining, then we need to deactivate them. | 480 // If we have any active entries remaining, then we need to deactivate them. |
340 // We may have some pending calls to OnProcessPendingQueue, but since those | 481 // We may have some pending calls to OnProcessPendingQueue, but since those |
341 // won't run (due to our destruction), we can simply ignore the corresponding | 482 // won't run (due to our destruction), we can simply ignore the corresponding |
342 // will_process_pending_queue flag. | 483 // will_process_pending_queue flag. |
343 while (!active_entries_.empty()) { | 484 while (!active_entries_.empty()) { |
344 ActiveEntry* entry = active_entries_.begin()->second; | 485 ActiveEntry* entry = active_entries_.begin()->second; |
345 entry->will_process_pending_queue = false; | 486 entry->will_process_pending_queue = false; |
346 entry->pending_queue.clear(); | 487 entry->pending_queue.clear(); |
347 entry->readers.clear(); | 488 entry->readers.clear(); |
348 entry->writer = NULL; | 489 entry->writer = NULL; |
349 DeactivateEntry(entry); | 490 DeactivateEntry(entry); |
350 } | 491 } |
351 | 492 |
352 STLDeleteElements(&doomed_entries_); | 493 STLDeleteElements(&doomed_entries_); |
494 STLDeleteElements(&async_validations_); | |
353 | 495 |
354 // Before deleting pending_ops_, we have to make sure that the disk cache is | 496 // Before deleting pending_ops_, we have to make sure that the disk cache is |
355 // done with said operations, or it will attempt to use deleted data. | 497 // done with said operations, or it will attempt to use deleted data. |
356 cert_cache_.reset(); | 498 cert_cache_.reset(); |
357 disk_cache_.reset(); | 499 disk_cache_.reset(); |
358 | 500 |
359 PendingOpsMap::iterator pending_it = pending_ops_.begin(); | 501 PendingOpsMap::iterator pending_it = pending_ops_.begin(); |
360 for (; pending_it != pending_ops_.end(); ++pending_it) { | 502 for (; pending_it != pending_ops_.end(); ++pending_it) { |
361 // We are not notifying the transactions about the cache going away, even | 503 // We are not notifying the transactions about the cache going away, even |
362 // though they are waiting for a callback that will never fire. | 504 // though they are waiting for a callback that will never fire. |
(...skipping 668 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1031 // not delete the entry before OnProcessPendingQueue runs. | 1173 // not delete the entry before OnProcessPendingQueue runs. |
1032 if (entry->will_process_pending_queue) | 1174 if (entry->will_process_pending_queue) |
1033 return; | 1175 return; |
1034 entry->will_process_pending_queue = true; | 1176 entry->will_process_pending_queue = true; |
1035 | 1177 |
1036 base::MessageLoop::current()->PostTask( | 1178 base::MessageLoop::current()->PostTask( |
1037 FROM_HERE, | 1179 FROM_HERE, |
1038 base::Bind(&HttpCache::OnProcessPendingQueue, GetWeakPtr(), entry)); | 1180 base::Bind(&HttpCache::OnProcessPendingQueue, GetWeakPtr(), entry)); |
1039 } | 1181 } |
1040 | 1182 |
1183 void HttpCache::PerformAsyncValidation(const HttpRequestInfo& original_request, | |
1184 const BoundNetLog& net_log) { | |
1185 DCHECK(use_stale_while_revalidate_); | |
1186 AsyncValidation* async_validation = | |
1187 new AsyncValidation(original_request, this); | |
1188 bool insert_ok = async_validations_.insert(async_validation).second; | |
1189 DCHECK(insert_ok); | |
1190 HttpNetworkSession* network_session = GetSession(); | |
1191 NetworkDelegate* network_delegate = NULL; | |
1192 if (network_session) | |
1193 network_delegate = network_session->network_delegate(); | |
1194 async_validation->Start(net_log, network_delegate); | |
1195 // |async_validation| may have been deleted here. | |
1196 } | |
1197 | |
1198 void HttpCache::DeleteAsyncValidation(AsyncValidation* async_validation) { | |
1199 size_t erased = async_validations_.erase(async_validation); | |
1200 DCHECK_EQ(1U, erased); | |
1201 delete async_validation; | |
1202 } | |
1203 | |
1041 void HttpCache::OnProcessPendingQueue(ActiveEntry* entry) { | 1204 void HttpCache::OnProcessPendingQueue(ActiveEntry* entry) { |
1042 entry->will_process_pending_queue = false; | 1205 entry->will_process_pending_queue = false; |
1043 DCHECK(!entry->writer); | 1206 DCHECK(!entry->writer); |
1044 | 1207 |
1045 // If no one is interested in this entry, then we can deactivate it. | 1208 // If no one is interested in this entry, then we can deactivate it. |
1046 if (entry->pending_queue.empty()) { | 1209 if (entry->pending_queue.empty()) { |
1047 if (entry->readers.empty()) | 1210 if (entry->readers.empty()) |
1048 DestroyEntry(entry); | 1211 DestroyEntry(entry); |
1049 return; | 1212 return; |
1050 } | 1213 } |
(...skipping 150 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1201 building_backend_ = false; | 1364 building_backend_ = false; |
1202 DeletePendingOp(pending_op); | 1365 DeletePendingOp(pending_op); |
1203 } | 1366 } |
1204 | 1367 |
1205 // The cache may be gone when we return from the callback. | 1368 // The cache may be gone when we return from the callback. |
1206 if (!item->DoCallback(result, disk_cache_.get())) | 1369 if (!item->DoCallback(result, disk_cache_.get())) |
1207 item->NotifyTransaction(result, NULL); | 1370 item->NotifyTransaction(result, NULL); |
1208 } | 1371 } |
1209 | 1372 |
1210 } // namespace net | 1373 } // namespace net |
OLD | NEW |