Remove network load flags not used in net/

net/http/http_cache_transaction.cc

 // 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.
 
 #include "net/http/http_cache_transaction.h"
 
 #include "build/build_config.h"
 
 #if defined(OS_POSIX)
 #include <unistd.h>
@@ skipping 153 matching lines @@
 }
 
 // From http://tools.ietf.org/html/draft-ietf-httpbis-p6-cache-21#section-6
 //      a "non-error response" is one with a 2xx (Successful) or 3xx
 //      (Redirection) status code.
 bool NonErrorResponse(int status_code) {
   int status_code_range = status_code / 100;
   return status_code_range == 2 || status_code_range == 3;
 }
 
-// Error codes that will be considered indicative of a page being offline/
-// unreachable for LOAD_FROM_CACHE_IF_OFFLINE.
-bool IsOfflineError(int error) {
-  return (error == net::ERR_NAME_NOT_RESOLVED ||
-          error == net::ERR_INTERNET_DISCONNECTED ||
-          error == net::ERR_ADDRESS_UNREACHABLE ||
-          error == net::ERR_CONNECTION_TIMED_OUT);
-}
-
-// Enum for UMA, indicating the status (with regard to offline mode) of
-// a particular request.
-enum RequestOfflineStatus {
-  // A cache transaction hit in cache (data was present and not stale)
-  // and returned it.
-  OFFLINE_STATUS_FRESH_CACHE,
-
-  // A network request was required for a cache entry, and it succeeded.
-  OFFLINE_STATUS_NETWORK_SUCCEEDED,
-
-  // A network request was required for a cache entry, and it failed with
-  // a non-offline error.
-  OFFLINE_STATUS_NETWORK_FAILED,
-
-  // A network request was required for a cache entry, it failed with an
-  // offline error, and we could serve stale data if
-  // LOAD_FROM_CACHE_IF_OFFLINE was set.
-  OFFLINE_STATUS_DATA_AVAILABLE_OFFLINE,
-
-  // A network request was required for a cache entry, it failed with
-  // an offline error, and there was no servable data in cache (even
-  // stale data).
-  OFFLINE_STATUS_DATA_UNAVAILABLE_OFFLINE,
-
-  OFFLINE_STATUS_MAX_ENTRIES
-};
-
-void RecordOfflineStatus(int load_flags, RequestOfflineStatus status) {
-  // Restrict to main frame to keep statistics close to
-  // "would have shown them something useful if offline mode was enabled".
-  if (load_flags & net::LOAD_MAIN_FRAME) {
-    UMA_HISTOGRAM_ENUMERATION("HttpCache.OfflineStatus", status,
-                              OFFLINE_STATUS_MAX_ENTRIES);
-  }
-}
-
 void RecordNoStoreHeaderHistogram(int load_flags,
                                   const net::HttpResponseInfo* response) {
   if (load_flags & net::LOAD_MAIN_FRAME) {
     UMA_HISTOGRAM_BOOLEAN(
         "Net.MainFrameNoStore",
         response->headers->HasHeaderValue("cache-control", "no-store"));
   }
 }
 
 base::Value* NetLogAsyncRevalidationInfoCallback(
@@ skipping 880 matching lines @@
 
   next_state_ = STATE_SEND_REQUEST_COMPLETE;
   rv = network_trans_->Start(request_, io_callback_, net_log_);
   return rv;
 }
 
 int HttpCache::Transaction::DoSendRequestComplete(int result) {
   if (!cache_.get())
     return ERR_UNEXPECTED;
 
-  // If requested, and we have a readable cache entry, and we have
-  // an error indicating that we're offline as opposed to in contact
-  // with a bad server, read from cache anyway.
-  if (IsOfflineError(result)) {
-    if (mode_ == READ_WRITE && entry_ && !partial_) {
-      RecordOfflineStatus(effective_load_flags_,
-                          OFFLINE_STATUS_DATA_AVAILABLE_OFFLINE);
-      if (effective_load_flags_ & LOAD_FROM_CACHE_IF_OFFLINE) {
-        UpdateTransactionPattern(PATTERN_NOT_COVERED);
-        response_.server_data_unavailable = true;
-        return SetupEntryForRead();

[kbalazs, 2015/04/24 20:54:55]

Are you sure you want to remove this? This seem to be a non-dead code that might
be quite useful.

[mmenke, 2015/04/24 21:02:52]

It's only set when LOAD_FROM_CACHE_IF_OFFLINE is set, and the flag is no longer
being set anywhere, so it is currently dead code.

Basically the problem is that we can't just show stale content without some sort
of notice that we're doing so, and after talking with the UI guys, a load from
cache button won out over just showing a stale content and some sort of infobar
warning the page was stale.

Thanks for the driveby comment, though - extra eyes on code are never a bad
thing.

-      }
-    } else {
-      RecordOfflineStatus(effective_load_flags_,
-                          OFFLINE_STATUS_DATA_UNAVAILABLE_OFFLINE);
-    }
-  } else {
-    RecordOfflineStatus(effective_load_flags_,
-                        (result == OK ? OFFLINE_STATUS_NETWORK_SUCCEEDED :
-                                        OFFLINE_STATUS_NETWORK_FAILED));
-  }
-
   // If we tried to conditionalize the request and failed, we know
   // we won't be reading from the cache after this point.
   if (couldnt_conditionalize_request_)
     mode_ = WRITE;
 
   if (result == OK) {
     next_state_ = STATE_SUCCESSFUL_SEND_REQUEST;
     return OK;
   }
 
@@ skipping 1068 matching lines @@
       (!partial_->IsCurrentRangeCached() || invalid_range_)) {
     // Force revalidation for sparse or truncated entries. Note that we don't
     // want to ignore the regular validation logic just because a byte range was
     // part of the request.
     skip_validation = false;
   }
 
   if (skip_validation) {
     // TODO(ricea): Is this pattern okay for asynchronous revalidations?
     UpdateTransactionPattern(PATTERN_ENTRY_USED);
-    RecordOfflineStatus(effective_load_flags_, OFFLINE_STATUS_FRESH_CACHE);
     return SetupEntryForRead();
   } else {
     // Make the network request conditional, to see if we may reuse our cached
     // response.  If we cannot do so, then we just resort to a normal fetch.
     // Our mode remains READ_WRITE for a conditional request.  Even if the
     // conditionalization fails, we don't switch to WRITE mode until we
     // know we won't be falling back to using the cache entry in the
     // LOAD_FROM_CACHE_IF_OFFLINE case.
     if (!ConditionalizeRequest()) {
       couldnt_conditionalize_request_ = true;
@@ skipping 792 matching lines @@
     default:
       NOTREACHED();
   }
 }
 
 void HttpCache::Transaction::OnIOComplete(int result) {
   DoLoop(result);
 }
 
 }  // namespace net