HttpCache::Transaction layer allowing parallel validation

net/http/http_cache_transaction.h

 // 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.
 
 // This file declares HttpCache::Transaction, a private class of HttpCache so
 // it should only be included by http_cache.cc
 
 #ifndef NET_HTTP_HTTP_CACHE_TRANSACTION_H_
 #define NET_HTTP_HTTP_CACHE_TRANSACTION_H_
 
@@ skipping 146 matching lines @@
   void SetPriority(RequestPriority priority) override;
   void SetWebSocketHandshakeStreamCreateHelper(
       WebSocketHandshakeStreamBase::CreateHelper* create_helper) override;
   void SetBeforeNetworkStartCallback(
       const BeforeNetworkStartCallback& callback) override;
   void SetBeforeHeadersSentCallback(
       const BeforeHeadersSentCallback& callback) override;
   int ResumeNetworkStart() override;
   void GetConnectionAttempts(ConnectionAttempts* out) const override;
 
+  // Invoked when parallel validation cannot proceed due to response failure
+  // and this transaction needs to be restarted.
+  void SetValidatingCannotProceed();
+
   // Returns the estimate of dynamically allocated memory in bytes.
   size_t EstimateMemoryUsage() const;
 
  private:
   static const size_t kNumValidationHeaders = 2;
   // Helper struct to pair a header name with its value, for
   // headers used to validate cache entries.
   struct ValidationHeaders {
     ValidationHeaders() : initialized(false) {}
 
@@ skipping 36 matching lines @@
     STATE_OVERWRITE_CACHED_RESPONSE,
     STATE_CACHE_WRITE_RESPONSE,
     STATE_CACHE_WRITE_RESPONSE_COMPLETE,
     STATE_TRUNCATE_CACHED_DATA,
     STATE_TRUNCATE_CACHED_DATA_COMPLETE,
     STATE_TRUNCATE_CACHED_METADATA,
     STATE_TRUNCATE_CACHED_METADATA_COMPLETE,
     STATE_PARTIAL_HEADERS_RECEIVED,
     STATE_CACHE_READ_METADATA,
     STATE_CACHE_READ_METADATA_COMPLETE,
+    STATE_HEADERS_PHASE_CANNOT_PROCEED,
+    STATE_FINISH_HEADERS,
+    STATE_FINISH_HEADERS_COMPLETE,
 
     // These states are entered from Read/AddTruncatedFlag.
     STATE_NETWORK_READ,
     STATE_NETWORK_READ_COMPLETE,
     STATE_CACHE_READ_DATA,
     STATE_CACHE_READ_DATA_COMPLETE,
     STATE_CACHE_WRITE_DATA,
     STATE_CACHE_WRITE_DATA_COMPLETE,
     STATE_CACHE_WRITE_TRUNCATED_RESPONSE,
     STATE_CACHE_WRITE_TRUNCATED_RESPONSE_COMPLETE
@@ skipping 11 matching lines @@
     VALIDATION_CAUSE_MAX
   };
 
   // Runs the state transition loop. Resets and calls |callback_| on exit,
   // unless the return value is ERR_IO_PENDING.
   int DoLoop(int result);
 
   // Each of these methods corresponds to a State value.  If there is an
   // argument, the value corresponds to the return of the previous state or
   // corresponding callback.
+  //
+  // Note that since headers and response body phases might be going on in

[jkarlin, 2017/04/20 15:05:29]

s/might be going on in parallel/can occur in parallel/

[shivanisha, 2017/04/21 23:06:00]

N/A now that this comment is not needed here.

+  // parallel for two transactions, a transaction in one phase should not be
+  // accessing disk entry fields of the other index as that might lead to data

[Randy Smith (Not in Mondays), 2017/04/19 17:26:34]

I'm not sure what "of the other index" means in this context?

[shivanisha, 2017/04/21 23:06:00]

N/A.

+  // races in some backends (like block file cache).

[Randy Smith (Not in Mondays), 2017/04/19 17:26:34]

I'd rephrase this with to talk about what the cache backend API contract does or
does not guarantee, with a comment that the disk cache backend appears not to
guarantee it and a pointer to the new bug.

I'd also suggest that this comment probably belongs somewhere else; at least, I
don't see the conceptual linkage to this area of the source.  Maybe try to make
the summary as pithy as possible (with a reference to the bug) and include it at
both places IsWritingInProgress is used?

[jkarlin, 2017/04/20 15:05:29]

I think what we really need is a DCHECK in the entry that verifies that there
are no ongoing write operations when a synchronous method is called.

[shivanisha, 2017/04/21 23:06:00]

Added new functions in ActiveEntry for data size, last used time and last
modified time that asserts the transaction's state with respect to other
transactions and used those functions in everywhere in the .cc file. Removed
this comment from here and included the explanation in the .cc file along with
the crbug number as to why we are checking if a writer is in progress.

[jkarlin, 2017/04/25 16:00:51]

Sorry, I meant meant putting the checks in the disk entry (e.g., EntryImpl). But
that can be for another CL.

   int DoGetBackend();
   int DoGetBackendComplete(int result);
   int DoInitEntry();
   int DoOpenEntry();
   int DoOpenEntryComplete(int result);
   int DoDoomEntry();
   int DoDoomEntryComplete(int result);
   int DoCreateEntry();
   int DoCreateEntryComplete(int result);
   int DoAddToEntry();
@@ skipping 17 matching lines @@
   int DoOverwriteCachedResponse();
   int DoCacheWriteResponse();
   int DoCacheWriteResponseComplete(int result);
   int DoTruncateCachedData();
   int DoTruncateCachedDataComplete(int result);
   int DoTruncateCachedMetadata();
   int DoTruncateCachedMetadataComplete(int result);
   int DoPartialHeadersReceived();
   int DoCacheReadMetadata();
   int DoCacheReadMetadataComplete(int result);
+  int DoHeadersPhaseCannotProceed();
+  int DoFinishHeaders(int result);
+  int DoFinishHeadersComplete(int result);
   int DoNetworkRead();
   int DoNetworkReadComplete(int result);
   int DoCacheReadData();
   int DoCacheReadDataComplete(int result);
   int DoCacheWriteData(int num_bytes);
   int DoCacheWriteDataComplete(int result);
   int DoCacheWriteTruncatedResponse();
   int DoCacheWriteTruncatedResponseComplete(int result);
 
   // Sets request_ and fields derived from it.
@@ skipping 122 matching lines @@
   void SetResponse(const HttpResponseInfo& new_response);
   void SetAuthResponse(const HttpResponseInfo& new_response);
 
   void UpdateCacheEntryStatus(
       HttpResponseInfo::CacheEntryStatus new_cache_entry_status);
 
   // Sets the response.cache_entry_status to the current cache_entry_status_.
   void SyncCacheEntryStatusToResponse();
   void RecordHistograms();
 
-  // Called to signal completion of asynchronous IO.
+  // Called to signal completion of asynchronous IO. Note that this callback is
+  // used in the conventional sense where one layer calls the callback of the
+  // layer above it e.g. this callback gets called from the network transaction
+  // layer. In addition, it is also used for HttpCache layer to let this
+  // transaction know when it is out of a queued state in ActiveEntry and can
+  // continue its processing.
   void OnIOComplete(int result);
 
   // When in a DoLoop, use this to set the next state as it verifies that the
   // state isn't set twice.
   void TransitionToState(State state);
 
   State next_state_;
   const HttpRequestInfo* request_;
   RequestPriority priority_;
   NetLogWithSource net_log_;
   std::unique_ptr<HttpRequestInfo> custom_request_;
   HttpRequestHeaders request_headers_copy_;
   // If extra_headers specified a "if-modified-since" or "if-none-match",
   // |external_validation_| contains the value of those headers.
   ValidationHeaders external_validation_;
   base::WeakPtr<HttpCache> cache_;
   HttpCache::ActiveEntry* entry_;
   HttpCache::ActiveEntry* new_entry_;
   std::unique_ptr<HttpTransaction> network_trans_;
   CompletionCallback callback_;  // Consumer's callback.
   HttpResponseInfo response_;
   HttpResponseInfo auth_response_;
   const HttpResponseInfo* new_response_;
   std::string cache_key_;
   Mode mode_;
+  Mode original_mode_;  // Used when restarting the transaction.
   bool reading_;  // We are already reading. Never reverts to false once set.
   bool invalid_range_;  // We may bypass the cache for this request.
   bool truncated_;  // We don't have all the response data.
   bool is_sparse_;  // The data is stored in sparse byte ranges.
   bool range_requested_;  // The user requested a byte range.
   bool handling_206_;  // We must deal with this 206 response.
   bool cache_pending_;  // We are waiting for the HttpCache.
   bool done_reading_;  // All available data was read.
   bool vary_mismatch_;  // The request doesn't match the stored vary data.
   bool couldnt_conditionalize_request_;
@@ skipping 46 matching lines @@
   bool in_do_loop_;
 
   base::WeakPtrFactory<Transaction> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Transaction);
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_CACHE_TRANSACTION_H_