Fixes the cache lock issue.

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 89 matching lines @@
   int WriteMetadata(IOBuffer* buf,
                     int buf_len,
                     const CompletionCallback& callback);
 
   // This transaction is being deleted and we are not done writing to the cache.
   // We need to indicate that the response data was truncated.  Returns true on
   // success. Keep in mind that this operation may have side effects, such as
   // deleting the active entry.
   bool AddTruncatedFlag();
 
-  HttpCache::ActiveEntry* entry() { return entry_; }
+  HttpCache::ActiveEntry* entry() const { return entry_; }
 
   // Returns the LoadState of the writer transaction of a given ActiveEntry. In
   // other words, returns the LoadState of this transaction without asking the
   // http cache, because this transaction should be the one currently writing
   // to the cache entry.
   LoadState GetWriterLoadState() const;
 
   const CompletionCallback& io_callback() { return io_callback_; }
 
   const NetLogWithSource& net_log() const;
@@ skipping 12 matching lines @@
   int Start(const HttpRequestInfo* request_info,
             const CompletionCallback& callback,
             const NetLogWithSource& net_log) override;
   int RestartIgnoringLastError(const CompletionCallback& callback) override;
   int RestartWithCertificate(X509Certificate* client_cert,
                              SSLPrivateKey* client_private_key,
                              const CompletionCallback& callback) override;
   int RestartWithAuth(const AuthCredentials& credentials,
                       const CompletionCallback& callback) override;
   bool IsReadyToRestartForAuth() override;
+  void Orphan(std::unique_ptr<HttpTransaction> trans) override;
   int Read(IOBuffer* buf,
            int buf_len,
            const CompletionCallback& callback) override;
   void StopCaching() override;
   bool GetFullRequestHeaders(HttpRequestHeaders* headers) const override;
   int64_t GetTotalReceivedBytes() const override;
   int64_t GetTotalSentBytes() const override;
   void DoneReading() override;
   const HttpResponseInfo* GetResponseInfo() const override;
   LoadState GetLoadState() const override;
   void SetQuicServerInfo(QuicServerInfo* quic_server_info) override;
   bool GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const override;
   bool GetRemoteEndpoint(IPEndPoint* endpoint) const override;
   void PopulateNetErrorDetails(NetErrorDetails* details) const override;
   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;
+  // Returns true if the transaction is eligible for reading from the
+  // network and writing to the cache along with other transactions.
+  // It is eligible if any of the following conditions are true:
+  // - Request’s mode is READ_WRITE. If mode is only READ then this
+  // transaction should wait till the whole response is in the cache.

[jkarlin, 2016/12/06 18:08:18]

s/till/until/

[shivanisha, 2016/12/06 21:53:35]

done.

+  // - Method is GET.
+  // - It is not a range request.
+  // - todo: Is this required: It is not a no-store data or data that must not

[jkarlin, 2016/12/06 18:08:18]

s/todo:/TODO(shivanisha):/

[shivanisha, 2016/12/06 21:53:35]

todo comment not needed, removed.

+  // be stored in the cache
+  // due to any other reason.
+  bool IsEligibleForSharedWriting() const;
+  void ProcessForSharedWriting();
+  void SetShared();
+  void ResetShared(bool continue_network_reading = false,
+                   bool continue_cache_reading = false);
+  bool shared() const;
+  bool validating_shared() const;
+  void SetSharedWritingFailState();
+  void ContinueWithoutSharedWriting();
+  void SetFinalizeDoomed();
 
  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) {}
 
     std::string values[kNumValidationHeaders];
     bool initialized;
@@ skipping 32 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,
+    // Update the value if another state becomes the last states of the start
+    // state machine.
+    STATE_START_STATE_MACHINE_FINAL = STATE_CACHE_READ_METADATA_COMPLETE,
 
+    // Start states should always be before Read states.
     // These states are entered from Read/AddTruncatedFlag.
     STATE_NETWORK_READ,
     STATE_NETWORK_READ_COMPLETE,
+    STATE_SHARED_NETWORK_READ,
+    STATE_SHARED_NETWORK_READ_COMPLETE,
+    STATE_SHARED_NETWORK_READ_WAIT_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
+    STATE_CACHE_WRITE_TRUNCATED_RESPONSE_COMPLETE,
+
+    // This state is reached when this transaction is idle waiting for Read to
+    // be invoked and Shared Writing failed.
+    STATE_SHARED_READ_WRITE_FAILED
   };
 
   // Used for categorizing validation triggers in histograms.
   // NOTE: This enumeration is used in histograms, so please do not add entries
   // in the middle.
   enum ValidationCause {
     VALIDATION_CAUSE_UNDEFINED,
     VALIDATION_CAUSE_VARY_MISMATCH,
     VALIDATION_CAUSE_VALIDATE_FLAG,
     VALIDATION_CAUSE_STALE,
@@ skipping 40 matching lines @@
   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 DoNetworkRead();
   int DoNetworkReadComplete(int result);
+  int DoSharedNetworkRead();
+  int DoSharedNetworkReadComplete(int result);
+  int DoSharedNetworkReadWaitComplete(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.
   void SetRequest(const NetLogWithSource& net_log,
                   const HttpRequestInfo* request);
@@ skipping 69 matching lines @@
 
   // Helper function, should be called with result of WriteResponseInfoToEntry
   // (or the result of the callback, when WriteResponseInfoToEntry returns
   // ERR_IO_PENDING). Calls DoneWritingToEntry if |result| is not the right
   // number of bytes. It is expected that the state that calls this will
   // return whatever net error code this function returns, which currently
   // is always "OK".
   int OnWriteResponseInfoToEntryComplete(int result);
 
   // Called when we are done writing to the cache entry.
-  void DoneWritingToEntry(bool success);
+  // In some case we just want to set the internal state of the transaction but
+  // do not want to invoke any cleanup operation on entry_ e.g. when it's
+  // already done by a SharedWriter callback function.
+  void DoneWritingToEntry(bool success, bool perform_entry_cleanup = true);
 
   // Returns an error to signal the caller that the current read failed. The
   // current operation |result| is also logged. If |restart| is true, the
   // transaction should be restarted.
   int OnCacheReadError(int result, bool restart);
 
   // Called when the cache lock timeout fires.
   void OnAddToEntryTimeout(base::TimeTicks start_time);
 
   // Deletes the current partial cache entry (sparse), and optionally removes
@@ skipping 14 matching lines @@
   int DoRestartPartialRequest();
 
   // Resets the relavant internal state to remove traces of internal processing
   // related to range requests. Deletes |partial_| if |delete_object| is true.
   void ResetPartialState(bool delete_object);
 
   // Resets |network_trans_|, which must be non-NULL.  Also updates
   // |old_network_trans_load_timing_|, which must be NULL when this is called.
   void ResetNetworkTransaction();
 
+  void SaveNetworkTransInfo();

[jkarlin, 2016/12/06 18:08:18]

s/Trans/Transaction/

[shivanisha, 2016/12/06 21:53:35]

done

+  void SaveSharedNetworkTransInfo();

[jkarlin, 2016/12/06 18:08:18]

ditto

[shivanisha, 2016/12/06 21:53:35]

done

+
   // Returns true if we should bother attempting to resume this request if it is
   // aborted while in progress. If |has_data| is true, the size of the stored
   // data is considered for the result.
   bool CanResume(bool has_data);
 
   // Setter for response_ and auth_response_. It updates its cache entry status,
   // if needed.
   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.
   void OnIOComplete(int result);
 
+  // Called when the transaction needs to be deleted after being orphaned.
+  void Delete();
+
   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_;
@@ skipping 11 matching lines @@
   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_;
   bool bypass_lock_for_test_;  // A test is exercising the cache lock.
   bool fail_conditionalization_for_test_;  // Fail ConditionalizeRequest.
+  // Reads from the network using a SharedWriters object.

[jkarlin, 2016/12/06 18:08:18]

empty line above comment missing.

[shivanisha, 2016/12/06 21:53:35]

Added. Also added comments for finalize_doomed_ and orphaned_.

+  bool shared_;
+  bool finalize_doomed_;
+  bool orphaned_;
   scoped_refptr<IOBuffer> read_buf_;
   int io_buf_len_;
   int read_offset_;
   int effective_load_flags_;
   int write_len_;
   std::unique_ptr<PartialData> partial_;  // We are dealing with range requests.
   CompletionCallback io_callback_;
 
   // Members used to track data for histograms.
   // This cache_entry_status_ takes precedence over
@@ skipping 23 matching lines @@
   // The helper object to use to create WebSocketHandshakeStreamBase
   // objects. Only relevant when establishing a WebSocket connection.
   // This is passed to the underlying network transaction. It is stored here in
   // case the transaction does not exist yet.
   WebSocketHandshakeStreamBase::CreateHelper*
       websocket_handshake_stream_base_create_helper_;
 
   BeforeNetworkStartCallback before_network_start_callback_;
   BeforeHeadersSentCallback before_headers_sent_callback_;
 
+  bool have_full_request_headers_;
+  HttpRequestHeaders full_request_headers_;
+
   base::WeakPtrFactory<Transaction> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Transaction);
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_CACHE_TRANSACTION_H_