[net] Better StopCaching() handling for HttpCache::Transaction.

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 192 matching lines @@
     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,
 
-    // These states are entered from Read/AddTruncatedFlag.
+    // These states are entered from Read.
+    STATE_SWITCH_TO_NETWORK,
     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
   };
 
   // Used for categorizing transactions for reporting in histograms. Patterns
   // cover relatively common use cases being measured and considered for
   // optimization. Many use cases that are more complex or uncommon are binned
   // as PATTERN_NOT_COVERED, and details are not reported.
   // NOTE: This enumeration is used in histograms, so please do not add entries
   // in the middle.
   enum TransactionPattern {
     PATTERN_UNDEFINED,
@@ skipping 43 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 DoSwitchToNetwork();
   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);
 
   // These functions are involved in a field trial testing storing certificates
   // in seperate entries from the HttpResponseInfo.
   void ReadCertChain();
   void WriteCertChain();
 
   // Sets request_ and fields derived from it.
   void SetRequest(const BoundNetLog& net_log, const HttpRequestInfo* request);
 
   // Returns true if the request should be handled exclusively by the network
@@ skipping 54 matching lines @@
   // Setups the transaction for reading from the cache entry.
   int SetupEntryForRead();
 
   // Called to write data to the cache entry.  If the write fails, then the
   // cache entry is destroyed.  Future calls to this function will just do
   // nothing without side-effect.  Returns a network error code.
   int WriteToEntry(int index, int offset, IOBuffer* data, int data_len,
                    const CompletionCallback& callback);
 
   // Called to write response_ to the cache entry. |truncated| indicates if the
-  // entry should be marked as incomplete.
-  int WriteResponseInfoToEntry(bool truncated);
+  // entry should be marked as incomplete. Returns ERR_IO_PENDING if an
+  // operation is pending. Once |callback| is invoked, the caller should call
+  // OnWriteResponseInfoToEntryComplete() with the result to complete the
+  // write operation.
+  int WriteResponseInfoToEntry(bool truncated,
+                               const CompletionCallback& callback);
 
   // 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".
+  // ERR_IO_PENDING). Calls ReleaseCacheEntry() to doom the entry if the number
+  // of bytes written is less than expected. 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);
 
+  // Releases the cache entry. The |entry_state| parameter specifies the state
+  // of the entry following the release.
+  void ReleaseCacheEntry(EntryState entry_state);
+
   // Called when we are done writing to the cache entry.
   void DoneWritingToEntry(bool success);
 
   // 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
   // the control object (partial_).
   void DoomPartialEntry(bool delete_object);
 
   // Performs the needed work after receiving data from the network, when
   // working with range requests.
   int DoPartialNetworkReadCompleted(int result);
 
   // Performs the needed work after receiving data from the cache, when
   // working with range requests.
   int DoPartialCacheReadCompleted(int result);
 
   // Restarts this transaction after deleting the cached data. It is meant to
   // be used when the current request cannot be fulfilled due to conflicts
   // between the byte range request and the cached entry.
   int DoRestartPartialRequest();
 
+  void OnCacheReleaseComplete(const base::Closure& closure, int result);
+
   // 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();
 
   // 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);
 
   void UpdateTransactionPattern(TransactionPattern new_transaction_pattern);
   void RecordHistograms();
 
   // Called to signal completion of asynchronous IO.
   void OnIOComplete(int result);
 
+  // Abandons a cache entry.
+  //
+  // This should be called when the transaction abnormally terminates writing to
+  // a cache entry. Once called, the cache entry could be either retained or
+  // truncated or destroyed depending on whether the full response entity was
+  // written to the cache or whether the partial cache entry can be fulfiled
+  // later by resuming the network request.
+  //
+  // If any asynchronous operations are pending, returns ERR_IO_PENDING and
+  // invokes |callback| when the opearations are complete. entry_ is always
+  // released upon completion.
+  //
+  // If |callback| is empty, then releases the cache entry synchronously. It is
+  // possible for the cache entry to be in an indeterminate state in this case.
+  int AbandonCacheEntry(const CompletionCallback& callback);
+
+  // Called to signal IO completion for AbandonCacheEntry().
+  void OnAbandonCacheEntryIOComplete(int result);
+
   State next_state_;
   const HttpRequestInfo* request_;
   RequestPriority priority_;
   BoundNetLog net_log_;
   scoped_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_;
   scoped_ptr<HttpTransaction> network_trans_;
   CompletionCallback callback_;  // Consumer's callback.
   HttpResponseInfo response_;
   HttpResponseInfo auth_response_;
   const HttpResponseInfo* new_response_;
   std::string cache_key_;
   Mode mode_;
   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 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 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 written to the cache entry.
+  bool vary_mismatch_;    // The request doesn't match the stored vary data.
   bool couldnt_conditionalize_request_;
+  bool stopped_caching_;       // Avoid further writes to the cache.
   bool bypass_lock_for_test_;  // A test is exercising the cache lock.
   bool fail_conditionalization_for_test_;  // Fail ConditionalizeRequest.
   scoped_refptr<IOBuffer> read_buf_;
+  int read_buf_len_;
   int io_buf_len_;
   int read_offset_;
   int effective_load_flags_;
   int write_len_;
   scoped_ptr<PartialData> partial_;  // We are dealing with range requests.
   UploadProgress final_upload_progress_;
   CompletionCallback io_callback_;
 
+  // Completion callback for AbandonCacheEntry().
+  CompletionCallback abandon_cache_entry_callback_;
+
   // Members used to track data for histograms.
   TransactionPattern transaction_pattern_;
   base::TimeTicks entry_lock_waiting_since_;
   base::TimeTicks first_cache_access_since_;
   base::TimeTicks send_request_since_;
 
   int64 total_received_bytes_;
 
   // Load timing information for the last network request, if any.  Set in the
   // 304 and 206 response cases, as the network transaction may be destroyed
@@ skipping 13 matching lines @@
   BeforeProxyHeadersSentCallback before_proxy_headers_sent_callback_;
 
   base::WeakPtrFactory<Transaction> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Transaction);
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_CACHE_TRANSACTION_H_