src/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/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   base::DeleteFile(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, scoped_ptr<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), writer(NULL) {}
 112   ~PendingOp() {}
 113
 114   disk_cache::Entry* disk_entry;
 115   scoped_ptr<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   if (!disk_cache_)
 599     return;
 600
 601   HttpRequestInfo temp_info;
 602   temp_info.url = url;
 603   temp_info.method = "GET";
 604   std::string key = GenerateCacheKey(&temp_info);
 605
 606   // Defer to DoomEntry if there is an active entry, otherwise call
 607   // AsyncDoomEntry without triggering a callback.
 608   if (active_entries_.count(key))
 609     DoomEntry(key, NULL);
 610   else
 611     AsyncDoomEntry(key, NULL);
 612 }
 613
 614 void HttpCache::FinalizeDoomedEntry(ActiveEntry* entry) {
 615   DCHECK(entry->doomed);
 616   DCHECK(!entry->writer);
 617   DCHECK(entry->readers.empty());
 618   DCHECK(entry->pending_queue.empty());
 619
 620   ActiveEntriesSet::iterator it = doomed_entries_.find(entry);
 621   DCHECK(it != doomed_entries_.end());
 622   doomed_entries_.erase(it);
 623
 624   delete entry;
 625 }
 626
 627 HttpCache::ActiveEntry* HttpCache::FindActiveEntry(const std::string& key) {
 628   ActiveEntriesMap::const_iterator it = active_entries_.find(key);
 629   return it != active_entries_.end() ? it->second : NULL;
 630 }
 631
 632 HttpCache::ActiveEntry* HttpCache::ActivateEntry(
 633     disk_cache::Entry* disk_entry) {
 634   DCHECK(!FindActiveEntry(disk_entry->GetKey()));
 635   ActiveEntry* entry = new ActiveEntry(disk_entry);
 636   active_entries_[disk_entry->GetKey()] = entry;
 637   return entry;
 638 }
 639
 640 void HttpCache::DeactivateEntry(ActiveEntry* entry) {
 641   DCHECK(!entry->will_process_pending_queue);
 642   DCHECK(!entry->doomed);
 643   DCHECK(!entry->writer);
 644   DCHECK(entry->disk_entry);
 645   DCHECK(entry->readers.empty());
 646   DCHECK(entry->pending_queue.empty());
 647
 648   std::string key = entry->disk_entry->GetKey();
 649   if (key.empty())
 650     return SlowDeactivateEntry(entry);
 651
 652   ActiveEntriesMap::iterator it = active_entries_.find(key);
 653   DCHECK(it != active_entries_.end());
 654   DCHECK(it->second == entry);
 655
 656   active_entries_.erase(it);
 657   delete entry;
 658 }
 659
 660 // We don't know this entry's key so we have to find it without it.
 661 void HttpCache::SlowDeactivateEntry(ActiveEntry* entry) {
 662   for (ActiveEntriesMap::iterator it = active_entries_.begin();
 663        it != active_entries_.end(); ++it) {
 664     if (it->second == entry) {
 665       active_entries_.erase(it);
 666       delete entry;
 667       break;
 668     }
 669   }
 670 }
 671
 672 HttpCache::PendingOp* HttpCache::GetPendingOp(const std::string& key) {
 673   DCHECK(!FindActiveEntry(key));
 674
 675   PendingOpsMap::const_iterator it = pending_ops_.find(key);
 676   if (it != pending_ops_.end())
 677     return it->second;
 678
 679   PendingOp* operation = new PendingOp();
 680   pending_ops_[key] = operation;
 681   return operation;
 682 }
 683
 684 void HttpCache::DeletePendingOp(PendingOp* pending_op) {
 685   std::string key;
 686   if (pending_op->disk_entry)
 687     key = pending_op->disk_entry->GetKey();
 688
 689   if (!key.empty()) {
 690     PendingOpsMap::iterator it = pending_ops_.find(key);
 691     DCHECK(it != pending_ops_.end());
 692     pending_ops_.erase(it);
 693   } else {
 694     for (PendingOpsMap::iterator it = pending_ops_.begin();
 695          it != pending_ops_.end(); ++it) {
 696       if (it->second == pending_op) {
 697         pending_ops_.erase(it);
 698         break;
 699       }
 700     }
 701   }
 702   DCHECK(pending_op->pending_queue.empty());
 703
 704   delete pending_op;
 705 }
 706
 707 int HttpCache::OpenEntry(const std::string& key, ActiveEntry** entry,
 708                          Transaction* trans) {
 709   ActiveEntry* active_entry = FindActiveEntry(key);
 710   if (active_entry) {
 711     *entry = active_entry;
 712     return OK;
 713   }
 714
 715   WorkItem* item = new WorkItem(WI_OPEN_ENTRY, trans, entry);
 716   PendingOp* pending_op = GetPendingOp(key);
 717   if (pending_op->writer) {
 718     pending_op->pending_queue.push_back(item);
 719     return ERR_IO_PENDING;
 720   }
 721
 722   DCHECK(pending_op->pending_queue.empty());
 723
 724   pending_op->writer = item;
 725   pending_op->callback = base::Bind(&HttpCache::OnPendingOpComplete,
 726                                     AsWeakPtr(), pending_op);
 727
 728   int rv = disk_cache_->OpenEntry(key, &(pending_op->disk_entry),
 729                                   pending_op->callback);
 730   if (rv != ERR_IO_PENDING) {
 731     item->ClearTransaction();
 732     pending_op->callback.Run(rv);
 733   }
 734
 735   return rv;
 736 }
 737
 738 int HttpCache::CreateEntry(const std::string& key, ActiveEntry** entry,
 739                            Transaction* trans) {
 740   if (FindActiveEntry(key)) {
 741     return ERR_CACHE_RACE;
 742   }
 743
 744   WorkItem* item = new WorkItem(WI_CREATE_ENTRY, trans, entry);
 745   PendingOp* pending_op = GetPendingOp(key);
 746   if (pending_op->writer) {
 747     pending_op->pending_queue.push_back(item);
 748     return ERR_IO_PENDING;
 749   }
 750
 751   DCHECK(pending_op->pending_queue.empty());
 752
 753   pending_op->writer = item;
 754   pending_op->callback = base::Bind(&HttpCache::OnPendingOpComplete,
 755                                     AsWeakPtr(), pending_op);
 756
 757   int rv = disk_cache_->CreateEntry(key, &(pending_op->disk_entry),
 758                                     pending_op->callback);
 759   if (rv != ERR_IO_PENDING) {
 760     item->ClearTransaction();
 761     pending_op->callback.Run(rv);
 762   }
 763
 764   return rv;
 765 }
 766
 767 void HttpCache::DestroyEntry(ActiveEntry* entry) {
 768   if (entry->doomed) {
 769     FinalizeDoomedEntry(entry);
 770   } else {
 771     DeactivateEntry(entry);
 772   }
 773 }
 774
 775 int HttpCache::AddTransactionToEntry(ActiveEntry* entry, Transaction* trans) {
 776   DCHECK(entry);
 777   DCHECK(entry->disk_entry);
 778
 779   // We implement a basic reader/writer lock for the disk cache entry.  If
 780   // there is already a writer, then everyone has to wait for the writer to
 781   // finish before they can access the cache entry.  There can be multiple
 782   // readers.
 783   //
 784   // NOTE: If the transaction can only write, then the entry should not be in
 785   // use (since any existing entry should have already been doomed).
 786
 787   if (entry->writer || entry->will_process_pending_queue) {
 788     entry->pending_queue.push_back(trans);
 789     return ERR_IO_PENDING;
 790   }
 791
 792   if (trans->mode() & Transaction::WRITE) {
 793     // transaction needs exclusive access to the entry
 794     if (entry->readers.empty()) {
 795       entry->writer = trans;
 796     } else {
 797       entry->pending_queue.push_back(trans);
 798       return ERR_IO_PENDING;
 799     }
 800   } else {
 801     // transaction needs read access to the entry
 802     entry->readers.push_back(trans);
 803   }
 804
 805   // We do this before calling EntryAvailable to force any further calls to
 806   // AddTransactionToEntry to add their transaction to the pending queue, which
 807   // ensures FIFO ordering.
 808   if (!entry->writer && !entry->pending_queue.empty())
 809     ProcessPendingQueue(entry);
 810
 811   return OK;
 812 }
 813
 814 void HttpCache::DoneWithEntry(ActiveEntry* entry, Transaction* trans,
 815                               bool cancel) {
 816   // If we already posted a task to move on to the next transaction and this was
 817   // the writer, there is nothing to cancel.
 818   if (entry->will_process_pending_queue && entry->readers.empty())
 819     return;
 820
 821   if (entry->writer) {
 822     DCHECK(trans == entry->writer);
 823
 824     // Assume there was a failure.
 825     bool success = false;
 826     if (cancel) {
 827       DCHECK(entry->disk_entry);
 828       // This is a successful operation in the sense that we want to keep the
 829       // entry.
 830       success = trans->AddTruncatedFlag();
 831       // The previous operation may have deleted the entry.
 832       if (!trans->entry())
 833         return;
 834     }
 835     DoneWritingToEntry(entry, success);
 836   } else {
 837     DoneReadingFromEntry(entry, trans);
 838   }
 839 }
 840
 841 void HttpCache::DoneWritingToEntry(ActiveEntry* entry, bool success) {
 842   DCHECK(entry->readers.empty());
 843
 844   entry->writer = NULL;
 845
 846   if (success) {
 847     ProcessPendingQueue(entry);
 848   } else {
 849     DCHECK(!entry->will_process_pending_queue);
 850
 851     // We failed to create this entry.
 852     TransactionList pending_queue;
 853     pending_queue.swap(entry->pending_queue);
 854
 855     entry->disk_entry->Doom();
 856     DestroyEntry(entry);
 857
 858     // We need to do something about these pending entries, which now need to
 859     // be added to a new entry.
 860     while (!pending_queue.empty()) {
 861       // ERR_CACHE_RACE causes the transaction to restart the whole process.
 862       pending_queue.front()->io_callback().Run(ERR_CACHE_RACE);
 863       pending_queue.pop_front();
 864     }
 865   }
 866 }
 867
 868 void HttpCache::DoneReadingFromEntry(ActiveEntry* entry, Transaction* trans) {
 869   DCHECK(!entry->writer);
 870
 871   TransactionList::iterator it =
 872       std::find(entry->readers.begin(), entry->readers.end(), trans);
 873   DCHECK(it != entry->readers.end());
 874
 875   entry->readers.erase(it);
 876
 877   ProcessPendingQueue(entry);
 878 }
 879
 880 void HttpCache::ConvertWriterToReader(ActiveEntry* entry) {
 881   DCHECK(entry->writer);
 882   DCHECK(entry->writer->mode() == Transaction::READ_WRITE);
 883   DCHECK(entry->readers.empty());
 884
 885   Transaction* trans = entry->writer;
 886
 887   entry->writer = NULL;
 888   entry->readers.push_back(trans);
 889
 890   ProcessPendingQueue(entry);
 891 }
 892
 893 LoadState HttpCache::GetLoadStateForPendingTransaction(
 894       const Transaction* trans) {
 895   ActiveEntriesMap::const_iterator i = active_entries_.find(trans->key());
 896   if (i == active_entries_.end()) {
 897     // If this is really a pending transaction, and it is not part of
 898     // active_entries_, we should be creating the backend or the entry.
 899     return LOAD_STATE_WAITING_FOR_CACHE;
 900   }
 901
 902   Transaction* writer = i->second->writer;
 903   return writer ? writer->GetWriterLoadState() : LOAD_STATE_WAITING_FOR_CACHE;
 904 }
 905
 906 void HttpCache::RemovePendingTransaction(Transaction* trans) {
 907   ActiveEntriesMap::const_iterator i = active_entries_.find(trans->key());
 908   bool found = false;
 909   if (i != active_entries_.end())
 910     found = RemovePendingTransactionFromEntry(i->second, trans);
 911
 912   if (found)
 913     return;
 914
 915   if (building_backend_) {
 916     PendingOpsMap::const_iterator j = pending_ops_.find(std::string());
 917     if (j != pending_ops_.end())
 918       found = RemovePendingTransactionFromPendingOp(j->second, trans);
 919
 920     if (found)
 921       return;
 922   }
 923
 924   PendingOpsMap::const_iterator j = pending_ops_.find(trans->key());
 925   if (j != pending_ops_.end())
 926     found = RemovePendingTransactionFromPendingOp(j->second, trans);
 927
 928   if (found)
 929     return;
 930
 931   ActiveEntriesSet::iterator k = doomed_entries_.begin();
 932   for (; k != doomed_entries_.end() && !found; ++k)
 933     found = RemovePendingTransactionFromEntry(*k, trans);
 934
 935   DCHECK(found) << "Pending transaction not found";
 936 }
 937
 938 bool HttpCache::RemovePendingTransactionFromEntry(ActiveEntry* entry,
 939                                                   Transaction* trans) {
 940   TransactionList& pending_queue = entry->pending_queue;
 941
 942   TransactionList::iterator j =
 943       find(pending_queue.begin(), pending_queue.end(), trans);
 944   if (j == pending_queue.end())
 945     return false;
 946
 947   pending_queue.erase(j);
 948   return true;
 949 }
 950
 951 bool HttpCache::RemovePendingTransactionFromPendingOp(PendingOp* pending_op,
 952                                                       Transaction* trans) {
 953   if (pending_op->writer->Matches(trans)) {
 954     pending_op->writer->ClearTransaction();
 955     pending_op->writer->ClearEntry();
 956     return true;
 957   }
 958   WorkItemList& pending_queue = pending_op->pending_queue;
 959
 960   WorkItemList::iterator it = pending_queue.begin();
 961   for (; it != pending_queue.end(); ++it) {
 962     if ((*it)->Matches(trans)) {
 963       delete *it;
 964       pending_queue.erase(it);
 965       return true;
 966     }
 967   }
 968   return false;
 969 }
 970
 971 void HttpCache::ProcessPendingQueue(ActiveEntry* entry) {
 972   // Multiple readers may finish with an entry at once, so we want to batch up
 973   // calls to OnProcessPendingQueue.  This flag also tells us that we should
 974   // not delete the entry before OnProcessPendingQueue runs.
 975   if (entry->will_process_pending_queue)
 976     return;
 977   entry->will_process_pending_queue = true;
 978
 979   base::MessageLoop::current()->PostTask(
 980       FROM_HERE,
 981       base::Bind(&HttpCache::OnProcessPendingQueue, AsWeakPtr(), entry));
 982 }
 983
 984 void HttpCache::OnProcessPendingQueue(ActiveEntry* entry) {
 985   entry->will_process_pending_queue = false;
 986   DCHECK(!entry->writer);
 987
 988   // If no one is interested in this entry, then we can deactivate it.
 989   if (entry->pending_queue.empty()) {
 990     if (entry->readers.empty())
 991       DestroyEntry(entry);
 992     return;
 993   }
 994
 995   // Promote next transaction from the pending queue.
 996   Transaction* next = entry->pending_queue.front();
 997   if ((next->mode() & Transaction::WRITE) && !entry->readers.empty())
 998     return;  // Have to wait.
 999
1000   entry->pending_queue.erase(entry->pending_queue.begin());
1001
1002   int rv = AddTransactionToEntry(entry, next);
1003   if (rv != ERR_IO_PENDING) {
1004     next->io_callback().Run(rv);
1005   }
1006 }
1007
1008 void HttpCache::OnIOComplete(int result, PendingOp* pending_op) {
1009   WorkItemOperation op = pending_op->writer->operation();
1010
1011   // Completing the creation of the backend is simpler than the other cases.
1012   if (op == WI_CREATE_BACKEND)
1013     return OnBackendCreated(result, pending_op);
1014
1015   scoped_ptr<WorkItem> item(pending_op->writer);
1016   bool fail_requests = false;
1017
1018   ActiveEntry* entry = NULL;
1019   std::string key;
1020   if (result == OK) {
1021     if (op == WI_DOOM_ENTRY) {
1022       // Anything after a Doom has to be restarted.
1023       fail_requests = true;
1024     } else if (item->IsValid()) {
1025       key = pending_op->disk_entry->GetKey();
1026       entry = ActivateEntry(pending_op->disk_entry);
1027     } else {
1028       // The writer transaction is gone.
1029       if (op == WI_CREATE_ENTRY)
1030         pending_op->disk_entry->Doom();
1031       pending_op->disk_entry->Close();
1032       pending_op->disk_entry = NULL;
1033       fail_requests = true;
1034     }
1035   }
1036
1037   // We are about to notify a bunch of transactions, and they may decide to
1038   // re-issue a request (or send a different one). If we don't delete
1039   // pending_op, the new request will be appended to the end of the list, and
1040   // we'll see it again from this point before it has a chance to complete (and
1041   // we'll be messing out the request order). The down side is that if for some
1042   // reason notifying request A ends up cancelling request B (for the same key),
1043   // we won't find request B anywhere (because it would be in a local variable
1044   // here) and that's bad. If there is a chance for that to happen, we'll have
1045   // to move the callback used to be a CancelableCallback. By the way, for this
1046   // to happen the action (to cancel B) has to be synchronous to the
1047   // notification for request A.
1048   WorkItemList pending_items;
1049   pending_items.swap(pending_op->pending_queue);
1050   DeletePendingOp(pending_op);
1051
1052   item->NotifyTransaction(result, entry);
1053
1054   while (!pending_items.empty()) {
1055     item.reset(pending_items.front());
1056     pending_items.pop_front();
1057
1058     if (item->operation() == WI_DOOM_ENTRY) {
1059       // A queued doom request is always a race.
1060       fail_requests = true;
1061     } else if (result == OK) {
1062       entry = FindActiveEntry(key);
1063       if (!entry)
1064         fail_requests = true;
1065     }
1066
1067     if (fail_requests) {
1068       item->NotifyTransaction(ERR_CACHE_RACE, NULL);
1069       continue;
1070     }
1071
1072     if (item->operation() == WI_CREATE_ENTRY) {
1073       if (result == OK) {
1074         // A second Create request, but the first request succeeded.
1075         item->NotifyTransaction(ERR_CACHE_CREATE_FAILURE, NULL);
1076       } else {
1077         if (op != WI_CREATE_ENTRY) {
1078           // Failed Open followed by a Create.
1079           item->NotifyTransaction(ERR_CACHE_RACE, NULL);
1080           fail_requests = true;
1081         } else {
1082           item->NotifyTransaction(result, entry);
1083         }
1084       }
1085     } else {
1086       if (op == WI_CREATE_ENTRY && result != OK) {
1087         // Failed Create followed by an Open.
1088         item->NotifyTransaction(ERR_CACHE_RACE, NULL);
1089         fail_requests = true;
1090       } else {
1091         item->NotifyTransaction(result, entry);
1092       }
1093     }
1094   }
1095 }
1096
1097 // static
1098 void HttpCache::OnPendingOpComplete(const base::WeakPtr<HttpCache>& cache,
1099                                     PendingOp* pending_op,
1100                                     int rv) {
1101   if (cache.get()) {
1102     cache->OnIOComplete(rv, pending_op);
1103   } else {
1104     // The callback was cancelled so we should delete the pending_op that
1105     // was used with this callback.
1106     delete pending_op;
1107   }
1108 }
1109
1110 void HttpCache::OnBackendCreated(int result, PendingOp* pending_op) {
1111   scoped_ptr<WorkItem> item(pending_op->writer);
1112   WorkItemOperation op = item->operation();
1113   DCHECK_EQ(WI_CREATE_BACKEND, op);
1114
1115   // We don't need the callback anymore.
1116   pending_op->callback.Reset();
1117
1118   if (backend_factory_.get()) {
1119     // We may end up calling OnBackendCreated multiple times if we have pending
1120     // work items. The first call saves the backend and releases the factory,
1121     // and the last call clears building_backend_.
1122     backend_factory_.reset();  // Reclaim memory.
1123     if (result == OK)
1124       disk_cache_ = pending_op->backend.Pass();
1125   }
1126
1127   if (!pending_op->pending_queue.empty()) {
1128     WorkItem* pending_item = pending_op->pending_queue.front();
1129     pending_op->pending_queue.pop_front();
1130     DCHECK_EQ(WI_CREATE_BACKEND, pending_item->operation());
1131
1132     // We want to process a single callback at a time, because the cache may
1133     // go away from the callback.
1134     pending_op->writer = pending_item;
1135
1136     base::MessageLoop::current()->PostTask(
1137         FROM_HERE,
1138         base::Bind(
1139             &HttpCache::OnBackendCreated, AsWeakPtr(), result, pending_op));
1140   } else {
1141     building_backend_ = false;
1142     DeletePendingOp(pending_op);
1143   }
1144
1145   // The cache may be gone when we return from the callback.
1146   if (!item->DoCallback(result, disk_cache_.get()))
1147     item->NotifyTransaction(result, NULL);
1148 }
1149
1150 }  // namespace net