predictors: Remove ResourcePrefetchPredictorConfig from ResourcePrefetcher.

chrome/browser/predictors/resource_prefetcher.cc

 // Copyright 2014 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 "chrome/browser/predictors/resource_prefetcher.h"
 
 #include <algorithm>
 #include <iterator>
 #include <utility>
 
@@ skipping 30 matching lines @@
     : url(url) {}
 
 ResourcePrefetcher::PrefetcherStats::~PrefetcherStats() {}
 
 ResourcePrefetcher::PrefetcherStats::PrefetcherStats(
     const PrefetcherStats& other)
     : url(other.url),
       start_time(other.start_time),
       requests_stats(other.requests_stats) {}
 
-ResourcePrefetcher::ResourcePrefetcher(
-    Delegate* delegate,
-    const ResourcePrefetchPredictorConfig& config,
-    const GURL& main_frame_url,
-    const std::vector<GURL>& urls)
+ResourcePrefetcher::ResourcePrefetcher(Delegate* delegate,
+                                       size_t max_concurrent_requests,
+                                       size_t max_concurrent_requests_per_host,
+                                       const GURL& main_frame_url,
+                                       const std::vector<GURL>& urls)
     : state_(INITIALIZED),
       delegate_(delegate),
-      config_(config),
+      max_concurrent_requests_(max_concurrent_requests),
+      max_concurrent_requests_per_host_(max_concurrent_requests_per_host),
       main_frame_url_(main_frame_url),
       prefetched_count_(0),
       prefetched_bytes_(0),
       stats_(base::MakeUnique<PrefetcherStats>(main_frame_url)) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   std::copy(urls.begin(), urls.end(), std::back_inserter(request_queue_));
 }
 
 ResourcePrefetcher::~ResourcePrefetcher() {}
@@ skipping 23 matching lines @@
   CHECK(state_ == RUNNING || state_ == STOPPED);
 
   // Try to launch new requests if the state is RUNNING.
   if (state_ == RUNNING) {
     bool request_available = true;
 
     // Loop through the requests while we are under the
     // max_prefetches_inflight_per_host_per_navigation limit, looking for a URL
     // for which the max_prefetches_inflight_per_host_per_navigation limit has
     // not been reached. Try to launch as many requests as possible.
-    while ((inflight_requests_.size() <
-                config_.max_prefetches_inflight_per_navigation) &&
+    while ((inflight_requests_.size() < max_concurrent_requests_) &&
            request_available) {
       auto request_it = request_queue_.begin();
       for (; request_it != request_queue_.end(); ++request_it) {
         const std::string& host = request_it->host();
 
         std::map<std::string, size_t>::iterator host_it =
             host_inflight_counts_.find(host);
         if (host_it == host_inflight_counts_.end() ||
-            host_it->second <
-                config_.max_prefetches_inflight_per_host_per_navigation)
+            host_it->second < max_concurrent_requests_per_host_)
           break;
       }
       request_available = request_it != request_queue_.end();
 
       if (request_available) {
         SendRequest(*request_it);
         request_queue_.erase(request_it);
       }
     }
   }
@@ skipping 132 matching lines @@
   if (bytes_read <= 0) {
     FinishRequest(request);
     return;
   }
 
   if (bytes_read > 0)
     ReadFullResponse(request);
 }
 
 }  // namespace predictors