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 176 matching lines @@
   // 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
 };

[mmenke, 2015/04/23 14:41:28]

You can remove this entire enum.

[mmenke, 2015/04/24 12:14:01]

It's possible you're making the changes now, just wanted to make sure you saw
this comment.

[g.mehndiratt, 2015/04/24 12:58:18]

On 2015/04/23 14:41:28, mmenke (Out 4-27 to 5-1) wrote:

Acknowledged.

[g.mehndiratt, 2015/04/24 12:58:18]

On 2015/04/24 12:14:01, mmenke (Out 4-27 to 5-1) wrote:

Acknowledged.

 
-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();
-      }
-    } 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