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