Precache per-resource cap should be applied on network bytes used

net/url_request/url_fetcher_impl_unittest.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/url_request/url_fetcher_impl.h"
 
 #include <stdint.h>
 #include <string.h>
 
 #include <algorithm>
@@ skipping 109 matching lines @@
   void OnURLFetchComplete(const URLFetcher* source) override {
     EXPECT_FALSE(did_complete_);
     EXPECT_TRUE(fetcher_);
     EXPECT_EQ(fetcher_.get(), source);
     did_complete_ = true;
     run_loop_.Quit();
   }
 
   void OnURLFetchDownloadProgress(const URLFetcher* source,
                                   int64_t current,
-                                  int64_t total) override {
+                                  int64_t total,
+                                  int64_t current_network_bytes) override {
     // Note that the current progress may be greater than the previous progress,
     // in the case of retrying the request.
     EXPECT_FALSE(did_complete_);
     EXPECT_TRUE(fetcher_);
     EXPECT_EQ(source, fetcher_.get());
 
     EXPECT_LE(0, current);
     // If file size is not known, |total| is -1.
     if (total >= 0)
       EXPECT_LE(current, total);
@@ skipping 776 matching lines @@
 // Checks that download progress never decreases, never exceeds file size, and
 // that file size is correctly reported.
 class CheckDownloadProgressDelegate : public WaitingURLFetcherDelegate {
  public:
   CheckDownloadProgressDelegate(int64_t file_size)
       : file_size_(file_size), last_seen_progress_(0) {}
   ~CheckDownloadProgressDelegate() override {}
 
   void OnURLFetchDownloadProgress(const URLFetcher* source,
                                   int64_t current,
-                                  int64_t total) override {
+                                  int64_t total,
+                                  int64_t current_network_bytes) override {
     // Run default checks.
-    WaitingURLFetcherDelegate::OnURLFetchDownloadProgress(source, current,
-                                                          total);
+    WaitingURLFetcherDelegate::OnURLFetchDownloadProgress(
+        source, current, total, current_network_bytes);
 
     EXPECT_LE(last_seen_progress_, current);
     EXPECT_EQ(file_size_, total);
     last_seen_progress_ = current;
   }
 
  private:
   int64_t file_size_;
   int64_t last_seen_progress_;
 
@@ skipping 63 matching lines @@
   EXPECT_FALSE(delegate.fetcher());
 }
 
 class CancelOnDownloadProgressDelegate : public WaitingURLFetcherDelegate {
  public:
   CancelOnDownloadProgressDelegate() {}
   ~CancelOnDownloadProgressDelegate() override {}
 
   void OnURLFetchDownloadProgress(const URLFetcher* source,
                                   int64_t current,
-                                  int64_t total) override {
+                                  int64_t total,
+                                  int64_t current_network_bytes) override {
     CancelFetch();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CancelOnDownloadProgressDelegate);
 };
 
 // Check that a fetch can be safely cancelled/deleted during a download progress
 // callback.
 TEST_F(URLFetcherTest, CancelInDownloadProgressCallback) {
@@ skipping 511 matching lines @@
   EXPECT_EQ(-1, delegate.fetcher()->GetResponseCode());
   EXPECT_FALSE(delegate.fetcher()->GetResponseHeaders());
   std::string data;
   EXPECT_TRUE(delegate.fetcher()->GetResponseAsString(&data));
   EXPECT_TRUE(data.empty());
 }
 
 }  // namespace
 
 }  // namespace net