net/http/http_cache.cc

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