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

net/http/mock_http_cache.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/mock_http_cache.h"
 
 #include <limits>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 
+// During testing, we are going to limit the size of a cache entry to this many
+// bytes using DCHECKs in order to prevent a test from causing unbounded memory
+// growth. In practice cache entry shouldn't come anywhere near this limit for
+// tests that use the mock cache. If they do, that's likely a problem with the
+// test. If a test requires using massive cache entries, they should use a real
+// cache backend instead.
+const int kMaxMockCacheEntrySize = 100 * 1000 * 1000;
+
 // We can override the test mode for a given operation by setting this global
 // variable.
 int g_test_mode = 0;
 
 int GetTestModeForEntry(const std::string& key) {
   // 'key' is prefixed with an identifier if it corresponds to a cached POST.
   // Skip past that to locate the actual URL.
   //
   // TODO(darin): It breaks the abstraction a bit that we assume 'key' is an
   // URL corresponding to a registered MockTransaction.  It would be good to
@@ skipping 99 matching lines @@
   DCHECK(truncate);
 
   if (fail_requests_) {
     CallbackLater(callback, ERR_CACHE_READ_FAILURE);
     return ERR_IO_PENDING;
   }
 
   if (offset < 0 || offset > static_cast<int>(data_[index].size()))
     return ERR_FAILED;
 
+  DCHECK_LT(offset + buf_len, kMaxMockCacheEntrySize);
   data_[index].resize(offset + buf_len);
   if (buf_len)
     memcpy(&data_[index][offset], buf->data(), buf_len);
 
   if (MockHttpCache::GetTestMode(test_mode_) & TEST_MODE_SYNC_CACHE_WRITE)
     return buf_len;
 
   CallbackLater(callback, buf_len);
   return ERR_IO_PENDING;
 }
@@ skipping 49 matching lines @@
     return ERR_FAILED;
   if (!buf_len)
     return 0;
 
   if (fail_requests_)
     return ERR_CACHE_READ_FAILURE;
 
   DCHECK(offset < std::numeric_limits<int32_t>::max());
   int real_offset = static_cast<int>(offset);
 
-  if (static_cast<int>(data_[1].size()) < real_offset + buf_len)
+  if (static_cast<int>(data_[1].size()) < real_offset + buf_len) {
+    DCHECK_LT(real_offset + buf_len, kMaxMockCacheEntrySize);
     data_[1].resize(real_offset + buf_len);
+  }
 
   memcpy(&data_[1][real_offset], buf->data(), buf_len);
   if (MockHttpCache::GetTestMode(test_mode_) & TEST_MODE_SYNC_CACHE_WRITE)
     return buf_len;
 
   CallbackLater(callback, buf_len);
   return ERR_IO_PENDING;
 }
 
 int MockDiskEntry::GetAvailableRange(int64_t offset,
@@ skipping 449 matching lines @@
   if (!callback_.is_null()) {
     if (!fail_)
       backend_->reset(new MockDiskCache());
     CompletionCallback cb = callback_;
     callback_.Reset();
     cb.Run(Result());  // This object can be deleted here.
   }
 }
 
 }  // namespace net