[net/cache] Avoid the cache for responses exceeding 2GB.

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"  // For OS_POSIX
 
 #if defined(OS_POSIX)
 #include <unistd.h>
@@ skipping 1155 matching lines @@
 }
 
 int HttpCache::Transaction::DoCacheReadResponseComplete(int result) {
   net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_CACHE_READ_INFO, result);
   if (result != io_buf_len_ ||
       !HttpCache::ParseResponseInfo(read_buf_->data(), io_buf_len_, &response_,
                                     &truncated_)) {
     return OnCacheReadError(result, true);
   }
 
+  const int current_size =
+      entry_->disk_entry->GetDataSize(kResponseContentIndex);
+  const int64_t full_response_length = response_.headers->GetContentLength();

[mmenke, 2016/06/22 15:50:26]

nit:  const is generally not used for runtime constants in chrome, except for
class members (x2).

[asanka, 2016/06/22 16:31:21]

Done.

+
   // Some resources may have slipped in as truncated when they're not.
-  int current_size = entry_->disk_entry->GetDataSize(kResponseContentIndex);
-  if (response_.headers->GetContentLength() == current_size)
+  if (full_response_length == current_size)
     truncated_ = false;
 
+  // The SM's handling of StopCaching unfortunately doesn't deal well with

[mmenke, 2016/06/22 15:50:26]

Please don't use uncommon abbreviations in comments (x2).  I assume "SM" means
"state machine", rather than "salty mackerel", but that wasn't immediately
obvious.

[asanka, 2016/06/22 16:31:21]

I was trying to be cool and use abbreviations found elsewhere in the source
file. :P Reworded.

+  // resources that are larger than 2GB when there is a truncated or sparse
+  // cache entry. While the SM is reworked to resolve this, the following logic
+  // is put in place to defer such requests to the network. The cache should not
+  // be storing multi gigabyte resources. See http://crbug.com/89567.
+  if ((truncated_ || response_.headers->response_code() == 206) &&
+      !range_requested_ &&
+      full_response_length > std::numeric_limits<int32_t>::max()) {
+    // Does not yield the cache lock. If another transaction starts for this

[mmenke, 2016/06/22 15:50:25]

"Does not yield the cache lock" -> "Does not yield to the cache lock"?

[asanka, 2016/06/22 16:31:21]

Reworded to say 'Does not release the cache entry'.

+    // cache entry while this transaction is active, the second transaction will
+    // fallback to the network after the timeout.

[mmenke, 2016/06/22 15:50:26]

fallback -> fall back ("fallback" is a noun)

[asanka, 2016/06/22 16:31:21]

Done.

+    DCHECK(!partial_.get());

[mmenke, 2016/06/22 15:50:26]

nit:  .get() not needed.

[asanka, 2016/06/22 16:31:21]

Done.

+    mode_ = NONE;
+    next_state_ = STATE_SEND_REQUEST;
+    return OK;
+  }
+
   if ((response_.unused_since_prefetch &&
        !(request_->load_flags & LOAD_PREFETCH)) ||
       (!response_.unused_since_prefetch &&
        (request_->load_flags & LOAD_PREFETCH))) {
     // Either this is the first use of an entry since it was prefetched or
     // this is a prefetch. The value of response.unused_since_prefetch is valid
     // for this transaction but the bit needs to be flipped in storage.
     next_state_ = STATE_TOGGLE_UNUSED_SINCE_PREFETCH;
     return OK;
   }
@@ skipping 1767 matching lines @@
     default:
       NOTREACHED();
   }
 }
 
 void HttpCache::Transaction::OnIOComplete(int result) {
   DoLoop(result);
 }
 
 }  // namespace net