Fixes the cache lock issue.

net/http/http_cache.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/http/http_cache.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 17 matching lines @@
 #include "base/threading/worker_pool.h"
 #include "base/time/default_clock.h"
 #include "base/time/time.h"
 #include "net/base/cache_type.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/base/upload_data_stream.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/http/disk_cache_based_quic_server_info.h"
+#include "net/http/http_cache_shared_writers.h"
 #include "net/http/http_cache_transaction.h"
 #include "net/http/http_network_layer.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_util.h"
 #include "net/log/net_log_with_source.h"
 #include "net/quic/chromium/quic_server_info.h"
 
@@ skipping 284 matching lines @@
 
   // If we have any active entries remaining, then we need to deactivate them.
   // We may have some pending calls to OnProcessPendingQueue, but since those
   // won't run (due to our destruction), we can simply ignore the corresponding
   // will_process_pending_queue flag.
   while (!active_entries_.empty()) {
     ActiveEntry* entry = active_entries_.begin()->second.get();
     entry->will_process_pending_queue = false;
     entry->pending_queue.clear();
     entry->readers.clear();
-    entry->writer = NULL;
+    entry->writer = nullptr;
+    entry->shared_writers.reset();
     DeactivateEntry(entry);
   }
 
   doomed_entries_.clear();
 
   // Before deleting pending_ops_, we have to make sure that the disk cache is
   // done with said operations, or it will attempt to use deleted data.
   disk_cache_.reset();
 
   for (auto pending_it = pending_ops_.begin(); pending_it != pending_ops_.end();
@@ skipping 91 matching lines @@
 }
 
 int HttpCache::CreateTransaction(RequestPriority priority,
                                  std::unique_ptr<HttpTransaction>* trans) {
   // Do lazy initialization of disk cache if needed.
   if (!disk_cache_.get()) {
     // We don't care about the result.
     CreateBackend(NULL, CompletionCallback());
   }
 
-   HttpCache::Transaction* transaction =
+  HttpCache::Transaction* transaction =
       new HttpCache::Transaction(priority, this);
-   if (bypass_lock_for_test_)
+  if (bypass_lock_for_test_)
     transaction->BypassLockForTest();
-   if (fail_conditionalization_for_test_)
-     transaction->FailConditionalizationForTest();
+  if (fail_conditionalization_for_test_)
+    transaction->FailConditionalizationForTest();
 
   trans->reset(transaction);
   return OK;
 }
 
 HttpCache* HttpCache::GetCache() {
   return this;
 }
 
 HttpNetworkSession* HttpCache::GetSession() {
@@ skipping 105 matching lines @@
 
   // We keep track of doomed entries so that we can ensure that they are
   // cleaned up properly when the cache is destroyed.
   ActiveEntry* entry_ptr = entry.get();
   DCHECK_EQ(0u, doomed_entries_.count(entry_ptr));
   doomed_entries_[entry_ptr] = std::move(entry);
 
   entry_ptr->disk_entry->Doom();
   entry_ptr->doomed = true;
 
-  DCHECK(entry_ptr->writer || !entry_ptr->readers.empty() ||
-         entry_ptr->will_process_pending_queue);
+  DCHECK(entry_ptr->writer || entry_ptr->shared_writers ||
+         !entry_ptr->readers.empty() || entry_ptr->will_process_pending_queue);
   return OK;
 }
 
 int HttpCache::AsyncDoomEntry(const std::string& key, Transaction* trans) {
   std::unique_ptr<WorkItem> item =
       base::MakeUnique<WorkItem>(WI_DOOM_ENTRY, trans, nullptr);
   PendingOp* pending_op = GetPendingOp(key);
   if (pending_op->writer) {
     pending_op->pending_queue.push_back(std::move(item));
     return ERR_IO_PENDING;
@@ skipping 26 matching lines @@
   // Defer to DoomEntry if there is an active entry, otherwise call
   // AsyncDoomEntry without triggering a callback.
   if (active_entries_.count(key))
     DoomEntry(key, NULL);
   else
     AsyncDoomEntry(key, NULL);
 }
 
 void HttpCache::FinalizeDoomedEntry(ActiveEntry* entry) {
   DCHECK(entry->doomed);
-  DCHECK(!entry->writer);
+  DCHECK(!entry->writer && !entry->shared_writers);
   DCHECK(entry->readers.empty());
   DCHECK(entry->pending_queue.empty());
 
   auto it = doomed_entries_.find(entry);
   DCHECK(it != doomed_entries_.end());
   doomed_entries_.erase(it);
 }
 
 HttpCache::ActiveEntry* HttpCache::FindActiveEntry(const std::string& key) {
   auto it = active_entries_.find(key);
   return it != active_entries_.end() ? it->second.get() : NULL;
 }
 
 HttpCache::ActiveEntry* HttpCache::ActivateEntry(
     disk_cache::Entry* disk_entry) {
   DCHECK(!FindActiveEntry(disk_entry->GetKey()));
   ActiveEntry* entry = new ActiveEntry(disk_entry);
   active_entries_[disk_entry->GetKey()] = base::WrapUnique(entry);
   return entry;
 }
 
 void HttpCache::DeactivateEntry(ActiveEntry* entry) {
   DCHECK(!entry->will_process_pending_queue);
   DCHECK(!entry->doomed);
-  DCHECK(!entry->writer);
+  DCHECK(!entry->writer && !entry->shared_writers);
   DCHECK(entry->disk_entry);
   DCHECK(entry->readers.empty());
   DCHECK(entry->pending_queue.empty());
 
   std::string key = entry->disk_entry->GetKey();
   if (key.empty())
     return SlowDeactivateEntry(entry);
 
   auto it = active_entries_.find(key);
   DCHECK(it != active_entries_.end());
@@ skipping 113 matching lines @@
     FinalizeDoomedEntry(entry);
   } else {
     DeactivateEntry(entry);
   }
 }
 
 int HttpCache::AddTransactionToEntry(ActiveEntry* entry, Transaction* trans) {
   DCHECK(entry);
   DCHECK(entry->disk_entry);
 
-  // We implement a basic reader/writer lock for the disk cache entry.  If
-  // there is already a writer, then everyone has to wait for the writer to
-  // finish before they can access the cache entry.  There can be multiple
-  // readers.
+  // If a writer is in the validation stage, all other transactions need to wait
+  // before they can access the cache entry. Once the validation stage is over
+  // and if the writer creates a SharedWriters object, other eligible
+  // transactions will become equally privileged to be able to read from the
+  // network and write to the cache.
   //
   // NOTE: If the transaction can only write, then the entry should not be in
   // use (since any existing entry should have already been doomed).
-
   if (entry->writer || entry->will_process_pending_queue) {
     entry->pending_queue.push_back(trans);
     return ERR_IO_PENDING;
   }
 
-  if (trans->mode() & Transaction::WRITE) {
+  if (entry->shared_writers) {
+    DCHECK(!entry->writer);
+    if (!trans->IsEligibleForSharedWriting()) {
+      entry->pending_queue.push_back(trans);
+      return ERR_IO_PENDING;
+    } else {
+      if (entry->shared_writers->AddTransaction(trans)) {
+        return OK;
+      } else {
+        // Another transaction is in the process of validation, wait for it and
+        // any other transactions already in the queue to complete.
+        return ERR_IO_PENDING;
+      }
+    }
+  } else if (trans->mode() & Transaction::WRITE) {  // No SharedWriters.
     // transaction needs exclusive access to the entry
     if (entry->readers.empty()) {
       entry->writer = trans;
     } else {
       entry->pending_queue.push_back(trans);
       return ERR_IO_PENDING;
     }
   } else {
     // transaction needs read access to the entry
-    entry->readers.push_back(trans);
+    entry->readers.insert(trans);
   }
 
   // We do this before calling EntryAvailable to force any further calls to
   // AddTransactionToEntry to add their transaction to the pending queue, which
   // ensures FIFO ordering.
   if (!entry->writer && !entry->pending_queue.empty())
     ProcessPendingQueue(entry);
 
   return OK;
 }
 
 void HttpCache::DoneWithEntry(ActiveEntry* entry, Transaction* trans,
                               bool cancel) {
+  // This is not expected to be called for shared writing transactions.
+  DCHECK(!trans->shared());
+
   // If we already posted a task to move on to the next transaction and this was
   // the writer, there is nothing to cancel.
   if (entry->will_process_pending_queue && entry->readers.empty())
     return;
 
   if (entry->writer) {
     DCHECK(trans == entry->writer);
-
     // Assume there was a failure.
     bool success = false;
     if (cancel) {
       DCHECK(entry->disk_entry);
       // This is a successful operation in the sense that we want to keep the
       // entry.
       success = trans->AddTruncatedFlag();
       // The previous operation may have deleted the entry.
       if (!trans->entry())
         return;
     }
     DoneWritingToEntry(entry, success);
   } else {
     DoneReadingFromEntry(entry, trans);
   }
 }
 
 void HttpCache::DoneWritingToEntry(ActiveEntry* entry, bool success) {
   DCHECK(entry->readers.empty());
+  DCHECK(!entry->shared_writers);
 
   entry->writer = NULL;
 
   if (success) {
     ProcessPendingQueue(entry);
   } else {
-    DCHECK(!entry->will_process_pending_queue);
+    DestroyEntryAndRestartPendingQueueTransactions(entry);
+  }
+}
 
-    // We failed to create this entry.
-    TransactionList pending_queue;
-    pending_queue.swap(entry->pending_queue);
+void HttpCache::DestroyEntryAndRestartPendingQueueTransactions(
+    ActiveEntry* entry) {
+  DCHECK(!entry->will_process_pending_queue);
 
-    entry->disk_entry->Doom();
-    DestroyEntry(entry);
+  // We failed to create this entry.
+  TransactionList pending_queue;
+  pending_queue.swap(entry->pending_queue);
 
-    // We need to do something about these pending entries, which now need to
-    // be added to a new entry.
-    while (!pending_queue.empty()) {
-      // ERR_CACHE_RACE causes the transaction to restart the whole process.
-      pending_queue.front()->io_callback().Run(ERR_CACHE_RACE);
-      pending_queue.pop_front();
-    }
+  entry->disk_entry->Doom();
+
+  DestroyEntry(entry);
+
+  // We need to do something about these pending entries, which now need to
+  // be added to a new entry.
+  while (!pending_queue.empty()) {
+    // ERR_CACHE_RACE causes the transaction to restart the whole process.
+    pending_queue.front()->io_callback().Run(ERR_CACHE_RACE);
+    pending_queue.pop_front();
   }
 }
 
 void HttpCache::DoneReadingFromEntry(ActiveEntry* entry, Transaction* trans) {
-  DCHECK(!entry->writer);
+  DCHECK(!entry->writer && !entry->shared_writers);
 
-  auto it = std::find(entry->readers.begin(), entry->readers.end(), trans);
+  auto it = entry->readers.find(trans);
   DCHECK(it != entry->readers.end());
 
   entry->readers.erase(it);
 
   ProcessPendingQueue(entry);
 }
 
 void HttpCache::ConvertWriterToReader(ActiveEntry* entry) {
   DCHECK(entry->writer);
   DCHECK(entry->writer->mode() == Transaction::READ_WRITE);
   DCHECK(entry->readers.empty());
 
   Transaction* trans = entry->writer;
 
   entry->writer = NULL;
-  entry->readers.push_back(trans);
+  entry->readers.insert(trans);
 
   ProcessPendingQueue(entry);
 }
 
 LoadState HttpCache::GetLoadStateForPendingTransaction(
       const Transaction* trans) {
   auto i = active_entries_.find(trans->key());
   if (i == active_entries_.end()) {
     // If this is really a pending transaction, and it is not part of
     // active_entries_, we should be creating the backend or the entry.
     return LOAD_STATE_WAITING_FOR_CACHE;
   }
 
   Transaction* writer = i->second->writer;
   return writer ? writer->GetWriterLoadState() : LOAD_STATE_WAITING_FOR_CACHE;
 }
 
 void HttpCache::RemovePendingTransaction(Transaction* trans) {
+  bool found = false;
+
   auto i = active_entries_.find(trans->key());
-  bool found = false;
   if (i != active_entries_.end())
     found = RemovePendingTransactionFromEntry(i->second.get(), trans);
 
   if (found)
     return;
 
   if (building_backend_) {
     auto j = pending_ops_.find(std::string());
     if (j != pending_ops_.end())
       found = RemovePendingTransactionFromPendingOp(j->second, trans);
@@ skipping 12 matching lines @@
   for (auto k = doomed_entries_.begin(); k != doomed_entries_.end() && !found;
        ++k) {
     found = RemovePendingTransactionFromEntry(k->first, trans);
   }
 
   DCHECK(found) << "Pending transaction not found";
 }
 
 bool HttpCache::RemovePendingTransactionFromEntry(ActiveEntry* entry,
                                                   Transaction* trans) {
+  if (trans->shared())
+    return entry->shared_writers->RemoveWaitingTransaction(trans);
+
   TransactionList& pending_queue = entry->pending_queue;
-
   auto j = find(pending_queue.begin(), pending_queue.end(), trans);
   if (j == pending_queue.end())
     return false;
-
   pending_queue.erase(j);
   return true;
 }
 
 bool HttpCache::RemovePendingTransactionFromPendingOp(PendingOp* pending_op,
                                                       Transaction* trans) {
   if (pending_op->writer->Matches(trans)) {
     pending_op->writer->ClearTransaction();
     pending_op->writer->ClearEntry();
     return true;
@@ skipping 17 matching lines @@
     return;
   entry->will_process_pending_queue = true;
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&HttpCache::OnProcessPendingQueue, GetWeakPtr(), entry));
 }
 
 void HttpCache::OnProcessPendingQueue(ActiveEntry* entry) {
   entry->will_process_pending_queue = false;
-  DCHECK(!entry->writer);
+  DCHECK(!entry->writer && !entry->shared_writers);
 
   // If no one is interested in this entry, then we can deactivate it.
   if (entry->pending_queue.empty()) {
     if (entry->readers.empty())
       DestroyEntry(entry);
     return;
   }
 
   // Promote next transaction from the pending queue.
   Transaction* next = entry->pending_queue.front();
@@ skipping 144 matching lines @@
   } else {
     building_backend_ = false;
     DeletePendingOp(pending_op);
   }
 
   // The cache may be gone when we return from the callback.
   if (!item->DoCallback(result, disk_cache_.get()))
     item->NotifyTransaction(result, NULL);
 }
 
+bool HttpCache::IsResponseCompleted(const ActiveEntry* entry,
+                                    const HttpResponseInfo* response_info) {
+  int current_size = entry->disk_entry->GetDataSize(kResponseContentIndex);
+  int64_t content_length = response_info->headers->GetContentLength();
+  if ((content_length >= 0 && content_length <= current_size) ||
+      content_length < 0)
+    return true;
+  return false;
+}
+
+int HttpCache::WriteResponseInfo(ActiveEntry* entry,
+                                 const HttpResponseInfo* response,
+                                 CompletionCallback& callback,
+                                 bool truncated,
+                                 int* io_buf_len) {
+  // When writing headers, we normally only write the non-transient headers.
+  bool skip_transient_headers = true;
+  scoped_refptr<PickledIOBuffer> data(new PickledIOBuffer());
+  response->Persist(data->pickle(), skip_transient_headers, truncated);
+  data->Done();
+
+  *io_buf_len = data->pickle()->size();
+  return entry->disk_entry->WriteData(kResponseInfoIndex, 0, data.get(),
+                                      *io_buf_len, callback, true);
+}
+
+// Histogram data from the end of 2010 show the following distribution of
+// response headers:
+//
+//   Content-Length............... 87%
+//   Date......................... 98%
+//   Last-Modified................ 49%
+//   Etag......................... 19%
+//   Accept-Ranges: bytes......... 25%
+//   Accept-Ranges: none.......... 0.4%
+//   Strong Validator............. 50%
+//   Strong Validator + ranges.... 24%
+//   Strong Validator + CL........ 49%
+//
+bool HttpCache::CanResumeEntry(bool has_data,
+                               const std::string& method,
+                               const HttpResponseInfo* response,
+                               ActiveEntry* entry) {
+  // Double check that there is something worth keeping.
+  if (has_data && !entry->disk_entry->GetDataSize(kResponseContentIndex))
+    return false;
+
+  if (method != "GET")
+    return false;
+
+  // Note that if this is a 206, content-length was already fixed after calling
+  // PartialData::ResponseHeadersOK().
+  if (response->headers->GetContentLength() <= 0 ||
+      response->headers->HasHeaderValue("Accept-Ranges", "none") ||
+      !response->headers->HasStrongValidators()) {
+    return false;
+  }
+
+  return true;
+}
+
+void HttpCache::CreateSharedWriters(
+    Transaction* cache_transaction,
+    std::unique_ptr<HttpTransaction> network_transaction,
+    RequestPriority priority) {
+  ActiveEntry* entry = cache_transaction->entry();
+  DCHECK(!entry->shared_writers);
+  DCHECK_EQ(entry->writer, cache_transaction);
+  DCHECK(entry->readers.empty());
+  entry->shared_writers.reset(
+      new HttpCache::SharedWriters(this, entry, cache_transaction, priority,
+                                   std::move(network_transaction)));
+
+  // entry->writer should no longer exist as it is moved to
+  // shared_writers.
+  entry->writer = nullptr;
+
+  // Add the eligible transactions to waiting_for_validation_ and process the
+  // first among them. After this, pending_queue will only contain transactions
+  // that are not eligible for shared writing.
+  entry->shared_writers->MoveFromPendingQueue();
+  entry->shared_writers->ProcessFirstWaitingValidation();
+}
+
+void HttpCache::ResponseCompleteSharedWriters(ActiveEntry* entry) {
+  DCHECK(entry->shared_writers->empty());
+  entry->shared_writers.release();
+  ProcessPendingQueue(entry);
+}
+
+void HttpCache::ResponseFailedSharedWriters(bool success, ActiveEntry* entry) {
+  DCHECK(entry->shared_writers->empty());
+  entry->shared_writers.release();
+
+  if (success)
+    ProcessPendingQueue(entry);
+  else
+    DestroyEntryAndRestartPendingQueueTransactions(entry);
+}
+
+void HttpCache::DoneReadingSharedWriters(Transaction* transaction,
+                                         ActiveEntry* entry) {
+  entry->shared_writers->DoneReading(transaction);
+
+  ResetSharedWritersProcessPendingQueue(entry);
+}
+
+void HttpCache::StopCachingSharedWriters(Transaction* transaction,
+                                         ActiveEntry* entry) {
+  bool stopped = entry->shared_writers->StopCaching(transaction);
+
+  if (stopped) {
+    DCHECK(entry->shared_writers->empty());
+    DCHECK_EQ(entry->writer, transaction);
+    entry->shared_writers.reset();
+  }
+}
+
+std::unique_ptr<HttpTransaction> HttpCache::ValidationNoMatchSharedWriters(
+    const std::string& key,
+    Transaction* transaction,
+    std::unique_ptr<HttpTransaction> network_transaction,
+    RequestPriority priority,
+    ActiveEntry* entry) {
+  // This will either return the ownership of the network transaction so that
+  // this transaction can continue reading from the network or not, if this is
+  // the only transaction in SharedWriters.
+  std::unique_ptr<HttpTransaction> nw_transaction =
+      entry->shared_writers->OnValidationNoMatch(
+          transaction, std::move(network_transaction), priority);
+  if (nw_transaction) {
+    DCHECK(!transaction->shared());
+    DoomActiveEntry(key);
+    // We need to do something about these pending entries, which now need to
+    // be added to a new entry.
+    while (!entry->pending_queue.empty()) {
+      // ERR_CACHE_RACE causes the transaction to restart the whole process.
+      entry->pending_queue.front()->io_callback().Run(ERR_CACHE_RACE);
+      entry->pending_queue.pop_front();
+    }
+  }
+  return nw_transaction;
+}
+
+void HttpCache::ResetSharedWritersProcessPendingQueue(ActiveEntry* entry) {
+  if (entry->shared_writers->empty()) {
+    ResetOrReleaseSharedWriters(entry);
+    DCHECK(!entry->writer);
+    ProcessPendingQueue(entry);
+  }
+}
+
+void HttpCache::RemoveCurrentSharedWriter(Transaction* transaction,
+                                          ActiveEntry* entry) {
+  entry->shared_writers->RemoveCurrentWriter(transaction);
+  ResetSharedWritersProcessPendingQueue(entry);
+}
+
+void HttpCache::ResetOrReleaseSharedWriters(ActiveEntry* entry) {
+  if (entry->shared_writers->CanReset())
+    entry->shared_writers.reset();
+  else
+    entry->shared_writers.release();
+}
+
+void HttpCache::RemoveIdleSharedWriter(Transaction* transaction,
+                                       ActiveEntry* entry) {
+  entry->shared_writers->RemoveIdleWriter(transaction);
+
+  if (entry->shared_writers->empty()) {
+    bool success = false;
+    success = transaction->AddTruncatedFlag();
+    if (success) {
+      ResetSharedWritersProcessPendingQueue(entry);
+    } else {
+      ResetOrReleaseSharedWriters(entry);
+      DestroyEntryAndRestartPendingQueueTransactions(entry);
+    }
+  }
+}
+
+void HttpCache::RemoveValidatingTransSharedWriters(Transaction* transaction,
+                                                   ActiveEntry* entry) {
+  entry->shared_writers->RemoveValidatingTransaction(transaction);
+  ResetSharedWritersProcessPendingQueue(entry);
+}
+
+void HttpCache::NotifyTransaction(base::WeakPtr<Transaction> transaction,
+                                  int result) {
+  if (transaction) {
+    transaction->io_callback().Run(result);
+  }
+}
+
 }  // namespace net