189     Transaction* transaction) const {  in TransactionInReaders()
190   return readers_.count(transaction) > 0;  in TransactionInReaders()
199     Transaction* transaction,  in AddTransactionToWriters()  argument
211   Writers::TransactionInfo info(transaction->partial(),  in AddTransactionToWriters()
212                                 transaction->is_truncated(),  in AddTransactionToWriters()
213                                 *(transaction->GetResponseInfo()));  in AddTransactionToWriters()
215   writers_->AddTransaction(transaction, parallel_writing_pattern,  in AddTransactionToWriters()
216                            transaction->priority(), info);  in AddTransactionToWriters()
231     Transaction* done_headers_transaction = *it;  in RestartHeadersPhaseTransactions()
238   Transaction* headers_transaction = headers_transaction_;  in RestartHeadersTransaction()
248   // In both cases, a transaction needs to wait since only one transaction can  in ProcessAddToEntryQueue()
253   Transaction* transaction = add_to_entry_queue_.front();  in ProcessAddToEntryQueue()  local
255   headers_transaction_ = transaction;  in ProcessAddToEntryQueue()
257   transaction->cache_io_callback().Run(OK);  in ProcessAddToEntryQueue()
261     Transaction* transaction) {  in RemovePendingTransaction()  argument
263       find(add_to_entry_queue_.begin(), add_to_entry_queue_.end(), transaction);  in RemovePendingTransaction()
283     Transaction* transaction,  in CanTransactionWriteResponseHeaders()  argument
286   // If |transaction| is the current writer, do nothing. This can happen for  in CanTransactionWriteResponseHeaders()
289   if (writers_ && writers_->HasTransaction(transaction)) {  in CanTransactionWriteResponseHeaders()
294   if (transaction != headers_transaction_) {  in CanTransactionWriteResponseHeaders()
298   if (!(transaction->mode() & Transaction::WRITE)) {  in CanTransactionWriteResponseHeaders()
302   // If its not a match then check if it is the transaction responsible for  in CanTransactionWriteResponseHeaders()
340            Transaction* transaction,  in WorkItem()  argument
342       : operation_(operation), transaction_(transaction), entry_(entry) {}  in WorkItem()
344            Transaction* transaction,  in WorkItem()  argument
347         transaction_(transaction),  in WorkItem()
352   // Calls back the transaction with the result of the operation.
376   bool Matches(Transaction* transaction) const {  in Matches()
377     return transaction == transaction_;  in Matches()
385   raw_ptr<Transaction, DanglingUntriaged> transaction_;
534     std::unique_ptr<HttpTransaction>* transaction) {  in CreateTransaction()  argument
542       std::make_unique<HttpCache::Transaction>(priority, this);  in CreateTransaction()
553   *transaction = std::move(new_transaction);  in CreateTransaction()
690                                            Transaction* transaction,  in CreateAndSetWorkItem()  argument
693   auto item = std::make_unique<WorkItem>(operation, transaction, entry);  in CreateAndSetWorkItem()
748 int HttpCache::GetBackendForTransaction(Transaction* transaction) {  in GetBackendForTransaction()  argument
758       WI_CREATE_BACKEND, transaction, CompletionOnceCallback());  in GetBackendForTransaction()
777 int HttpCache::DoomEntry(const std::string& key, Transaction* transaction) {  in DoomEntry()  argument
778   // Need to abandon the ActiveEntry, but any transaction attached to the entry  in DoomEntry()
784     DCHECK(transaction);  in DoomEntry()
785     return AsyncDoomEntry(key, transaction);  in DoomEntry()
803                               Transaction* transaction) {  in AsyncDoomEntry()  argument
806       CreateAndSetWorkItem(nullptr, transaction, WI_DOOM_ENTRY, pending_op);  in AsyncDoomEntry()
812       transaction ? transaction->priority() : net::LOWEST;  in AsyncDoomEntry()
913                                  Transaction* transaction) {  in OpenOrCreateEntry()  argument
917   int rv = CreateAndSetWorkItem(entry, transaction, WI_OPEN_OR_CREATE_ENTRY,  in OpenOrCreateEntry()
924       key, transaction->priority(),  in OpenOrCreateEntry()
941                          Transaction* transaction) {  in OpenEntry()  argument
945   int rv = CreateAndSetWorkItem(entry, transaction, WI_OPEN_ENTRY, pending_op);  in OpenEntry()
951       key, transaction->priority(),  in OpenEntry()
968                            Transaction* transaction) {  in CreateEntry()  argument
975       CreateAndSetWorkItem(entry, transaction, WI_CREATE_ENTRY, pending_op);  in CreateEntry()
981       key, transaction->priority(),  in CreateEntry()
997                                      Transaction* transaction) {  in AddTransactionToEntry()  argument
1000   // Always add a new transaction to the queue to maintain FIFO order.  in AddTransactionToEntry()
1001   entry->add_to_entry_queue().push_back(transaction);  in AddTransactionToEntry()
1002   // Don't process the transaction if the lock timeout handling is being tested.  in AddTransactionToEntry()
1010                                        Transaction* transaction,  in DoneWithResponseHeaders()  argument
1012   // If |transaction| is the current writer, do nothing. This can happen for  in DoneWithResponseHeaders()
1015   if (entry->HasWriters() && entry->writers()->HasTransaction(transaction)) {  in DoneWithResponseHeaders()
1020   DCHECK_EQ(entry->headers_transaction(), transaction);  in DoneWithResponseHeaders()
1024   // If transaction is responsible for writing the response body, then do not go  in DoneWithResponseHeaders()
1026   // writer transaction, the consumer sometimes depend on synchronous behaviour  in DoneWithResponseHeaders()
1028   if ((transaction->mode() & Transaction::WRITE) && !entry->HasWriters() &&  in DoneWithResponseHeaders()
1031         transaction, CanTransactionJoinExistingWriters(transaction));  in DoneWithResponseHeaders()
1036   entry->done_headers_queue().push_back(transaction);  in DoneWithResponseHeaders()
1042                               Transaction* transaction,  in DoneWithEntry()  argument
1045   bool is_mode_read_only = transaction->mode() == Transaction::READ;  in DoneWithEntry()
1051   // Transaction is waiting in the done_headers_queue.  in DoneWithEntry()
1052   auto it = base::ranges::find(entry->done_headers_queue(), transaction);  in DoneWithEntry()
1056     // Restart other transactions if this transaction could have written  in DoneWithEntry()
1064   // Transaction is removed in the headers phase.  in DoneWithEntry()
1065   if (transaction == entry->headers_transaction()) {  in DoneWithEntry()
1071       // Restart other transactions if this transaction could have written  in DoneWithEntry()
1078   // Transaction is removed in the writing phase.  in DoneWithEntry()
1079   if (entry->HasWriters() && entry->writers()->HasTransaction(transaction)) {  in DoneWithEntry()
1080     entry->writers()->RemoveTransaction(transaction,  in DoneWithEntry()
1085   // Transaction is reading from the entry.  in DoneWithEntry()
1087   auto readers_it = entry->readers().find(transaction);  in DoneWithEntry()
1123     for (Transaction* reader : make_readers) {  in WritersDoneWritingToEntry()
1128     // access the network transaction.  in WritersDoneWritingToEntry()
1138   // Validating transaction received a non-matching response.  in DoomEntryValidationNoMatch()
1146   // Post task here to avoid a race in creating the entry between |transaction|  in DoomEntryValidationNoMatch()
1147   // and the add_to_entry_queue transactions. Reset the queued transaction's  in DoomEntryValidationNoMatch()
1149   // for the transaction to not be found in this entry.  in DoomEntryValidationNoMatch()
1150   for (net::HttpCache::Transaction* transaction : entry->add_to_entry_queue()) {  in DoomEntryValidationNoMatch()
1151     transaction->ResetCachePendingState();  in DoomEntryValidationNoMatch()
1154         base::BindOnce(transaction->cache_io_callback(), net::ERR_CACHE_RACE));  in DoomEntryValidationNoMatch()
1171   // ERR_CACHE_RACE causes the transaction to restart the whole process.  in ProcessEntryFailure()
1172   for (Transaction* queued_transaction : list) {  in ProcessEntryFailure()
1187   // Post a task instead of invoking the io callback of another transaction here  in ProcessQueuedTransactions()
1213     Transaction* transaction) {  in CanTransactionJoinExistingWriters()  argument
1214   if (transaction->method() != "GET") {  in CanTransactionJoinExistingWriters()
1217   if (transaction->partial()) {  in CanTransactionJoinExistingWriters()
1220   if (transaction->mode() == Transaction::READ) {  in CanTransactionJoinExistingWriters()
1223   if (transaction->GetResponseInfo()->headers &&  in CanTransactionJoinExistingWriters()
1224       transaction->GetResponseInfo()->headers->GetContentLength() >  in CanTransactionJoinExistingWriters()
1237   Transaction* transaction = entry->done_headers_queue().front();  in ProcessDoneHeadersQueue()  local
1240       CanTransactionJoinExistingWriters(transaction);  in ProcessDoneHeadersQueue()
1244       // transaction in the queue because the FIFO order is maintained  in ProcessDoneHeadersQueue()
1251     entry->AddTransactionToWriters(transaction, parallel_writing_pattern);  in ProcessDoneHeadersQueue()
1253     if (transaction->mode() & Transaction::WRITE) {  in ProcessDoneHeadersQueue()
1254       if (transaction->partial()) {  in ProcessDoneHeadersQueue()
1256           entry->AddTransactionToWriters(transaction, parallel_writing_pattern);  in ProcessDoneHeadersQueue()
1261         // Add the transaction to readers since the response body should have  in ProcessDoneHeadersQueue()
1266         transaction->WriteModeTransactionAboutToBecomeReader();  in ProcessDoneHeadersQueue()
1267         auto return_val = entry->readers().insert(transaction);  in ProcessDoneHeadersQueue()
1271       auto return_val = entry->readers().insert(transaction);  in ProcessDoneHeadersQueue()
1277   // readers or another transaction to start parallel validation.  in ProcessDoneHeadersQueue()
1281   transaction->cache_io_callback().Run(OK);  in ProcessDoneHeadersQueue()
1285     const Transaction* transaction) {  in GetLoadStateForPendingTransaction()  argument
1286   auto i = active_entries_.find(transaction->key());  in GetLoadStateForPendingTransaction()
1288     // If this is really a pending transaction, and it is not part of  in GetLoadStateForPendingTransaction()
1297 void HttpCache::RemovePendingTransaction(Transaction* transaction) {  in RemovePendingTransaction()  argument
1298   auto i = active_entries_.find(transaction->key());  in RemovePendingTransaction()
1301     found = i->second->RemovePendingTransaction(transaction);  in RemovePendingTransaction()
1311       found = RemovePendingTransactionFromPendingOp(j->second, transaction);  in RemovePendingTransaction()
1319   auto j = pending_ops_.find(transaction->key());  in RemovePendingTransaction()
1321     found = RemovePendingTransactionFromPendingOp(j->second, transaction);  in RemovePendingTransaction()
1331     found = k->get().RemovePendingTransaction(transaction);  in RemovePendingTransaction()
1334   DCHECK(found) << "Pending transaction not found";  in RemovePendingTransaction()
1339     Transaction* transaction) {  in RemovePendingTransactionFromPendingOp()  argument
1340   if (pending_op->writer->Matches(transaction)) {  in RemovePendingTransactionFromPendingOp()
1348     if ((*it)->Matches(transaction)) {  in RemovePendingTransactionFromPendingOp()
1359   // Note that this function should only invoke one transaction's IO callback  in OnProcessQueuedTransactions()
1370   // If another transaction is writing the response, let validated transactions  in OnProcessQueuedTransactions()
1372   // done_headers_queue transaction should start writing it.  in OnProcessQueuedTransactions()
1408       // The writer transaction is gone.  in OnIOComplete()