Combine and make const RequiresValidation() and ConditionalizeRequest().

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 226 matching lines @@
   // in the middle.
   enum ValidationCause {
     VALIDATION_CAUSE_UNDEFINED,
     VALIDATION_CAUSE_VARY_MISMATCH,
     VALIDATION_CAUSE_VALIDATE_FLAG,
     VALIDATION_CAUSE_STALE,
     VALIDATION_CAUSE_ZERO_FRESHNESS,
     VALIDATION_CAUSE_MAX
   };
 
+  // What, if any, network confirmation for a cache entry is required.
+  enum EntryValidationStatus {
+    USABLE,                             // Can be used without server ok.
+    REQUIRES_VALIDATION,                // Need to check with server.
+    REQUIRES_VALIDATION_VARY_MISMATCH,  // Vary mismatch allows last-modified.
+    REQUIRES_REFETCH                    // Entry needs to be fetched.

[shivanisha, 2017/05/02 16:03:26]

nit: prefer enum class for type safety.

+  };
+
   // 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.
   int DoGetBackend();
   int DoGetBackendComplete(int result);
   int DoInitEntry();
@@ skipping 74 matching lines @@
 
   // Called to restart a network transaction with a client certificate.
   // Returns network error code.
   int RestartNetworkRequestWithCertificate(X509Certificate* client_cert,
                                            SSLPrivateKey* client_private_key);
 
   // Called to restart a network transaction with authentication credentials.
   // Returns network error code.
   int RestartNetworkRequestWithAuth(const AuthCredentials& credentials);
 
-  // Called to determine if we need to validate the cache entry before using it.
-  bool RequiresValidation();
+  // Helper function for GetEntryValidationStatus(). |*vary_mismatch| will
+  // be set to false unless validation is required because of a vary mismatch.
+  bool RequiresValidation(bool* vary_mismatch) const;
 
-  // Called to make the request conditional (to ask the server if the cached
-  // copy is valid).  Returns true if able to make the request conditional.
-  bool ConditionalizeRequest();
+  // Return the type of network validation required by the entry.
+  EntryValidationStatus GetEntryValidationStatus() const;
 
   // Makes sure that a 206 response is expected.  Returns true on success.
   // On success, handling_206_ will be set to true if we are processing a
   // partial entry.
   bool ValidatePartialResponse();
 
   // Handles a response validation error by bypassing the cache.
   void IgnoreRangeRequest();
 
   // Fixes the response headers to match expectations for a HEAD request.
@@ skipping 64 matching lines @@
   // 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();

[shivanisha, 2017/05/02 16:03:26]

Request: Can RecordHistograms be made const as well? (Not related to your
change, but since this CL is making change to histogram related fields)

 
   // Called to signal completion of asynchronous IO.
   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_;
@@ skipping 15 matching lines @@
   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 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.
   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.
+  // Members used to track data for histograms.  The state of these fields
+  // do not affect the behavior of the transaction, and hence can be changed
+  // in const methods.
   // This cache_entry_status_ takes precedence over
   // response_.cache_entry_status. In fact, response_.cache_entry_status must be
   // kept in sync with cache_entry_status_ (via SetResponse and
   // UpdateCacheEntryStatus).
   HttpResponseInfo::CacheEntryStatus cache_entry_status_;
-  ValidationCause validation_cause_;
+  mutable ValidationCause validation_cause_;
   base::TimeTicks entry_lock_waiting_since_;
   base::TimeTicks first_cache_access_since_;
   base::TimeTicks send_request_since_;
   base::Time open_entry_last_used_;
-  base::TimeDelta stale_entry_freshness_;
-  base::TimeDelta stale_entry_age_;
+  mutable base::TimeDelta stale_entry_freshness_;
+  mutable base::TimeDelta stale_entry_age_;
 
   int64_t total_received_bytes_;
   int64_t total_sent_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
   // before the caller requests load timing information.
   std::unique_ptr<LoadTimingInfo> old_network_trans_load_timing_;
 
   ConnectionAttempts old_connection_attempts_;
@@ skipping 13 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_