Effectively disable the predictor's DNS queue for an experiment

chrome/browser/net/predictor.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 "chrome/browser/net/predictor.h"
 
 #include <algorithm>
 #include <cmath>
 #include <set>
 #include <sstream>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/containers/mru_cache.h"
+#include "base/feature_list.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/histogram.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
@@ skipping 24 matching lines @@
 #include "net/proxy/proxy_service.h"
 #include "net/ssl/ssl_config_service.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 
 using base::TimeDelta;
 using content::BrowserThread;
 
 namespace chrome_browser_net {
 
+namespace {
+const base::Feature kUsePredictorDNSQueue{"UsePredictorDNSQueue",
+                                          base::FEATURE_ENABLED_BY_DEFAULT};
+}
+
 // static
 const int Predictor::kPredictorReferrerVersion = 2;
 const double Predictor::kPreconnectWorthyExpectedValue = 0.8;
 const double Predictor::kDNSPreresolutionWorthyExpectedValue = 0.1;
 const double Predictor::kDiscardableExpectedValue = 0.05;
 // The goal is of trimming is to to reduce the importance (number of expected
 // subresources needed) by a factor of 2 after about 24 hours of uptime. We will
 // trim roughly once-an-hour of uptime.  The ratio to use in each trim operation
 // is then the 24th root of 0.5.  If a user only surfs for 4 hours a day, then
 // after about 6 days they will have halved all their estimates of subresource
@@ skipping 350 matching lines @@
   Results assignees;
   for (Results::iterator it = results_.begin(); results_.end() != it; ++it) {
     GURL url(it->first);
     UrlInfo* info = &it->second;
     DCHECK(info->HasUrl(url));
     if (info->is_assigned()) {
       info->SetPendingDeleteState();
       assignees[url] = *info;
     }
   }
-  DCHECK_LE(assignees.size(), max_concurrent_dns_lookups_);
+  DCHECK(!base::FeatureList::IsEnabled(kUsePredictorDNSQueue) ||
+         assignees.size() <= max_concurrent_dns_lookups_);
   results_.clear();
   // Put back in the names being worked on.
   for (Results::iterator it = assignees.begin(); assignees.end() != it; ++it) {
     DCHECK(it->second.is_marked_to_delete());
     results_[it->first] = it->second;
   }
 }
 
 // Overloaded Resolve() to take a vector of names.
 void Predictor::ResolveList(const UrlList& urls,
@@ skipping 639 matching lines @@
 
   info->SetQueuedState(motivation);
   work_queue_.Push(url, motivation);
 
   StartSomeQueuedResolutions();
   return info;
 }
 
 bool Predictor::CongestionControlPerformed(UrlInfo* info) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(base::FeatureList::IsEnabled(kUsePredictorDNSQueue));
   // Note: queue_duration is ONLY valid after we go to assigned state.
   if (info->queue_duration() < max_dns_queue_delay_)
     return false;
   // We need to discard all entries in our queue, as we're keeping them waiting
   // too long.  By doing this, we'll have a chance to quickly service urgent
   // resolutions, and not have a bogged down system.
   while (true) {
     info->RemoveFromQueue();
     if (work_queue_.IsEmpty())
       break;
     info = &results_[work_queue_.Pop()];
     info->SetAssignedState();
   }
   return true;
 }
 
 void Predictor::StartSomeQueuedResolutions() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
+  // If the queue is disabled, just make LookupRequests for all entries.
+  bool enable_queue = base::FeatureList::IsEnabled(kUsePredictorDNSQueue);
   while (!work_queue_.IsEmpty() &&
-         pending_lookups_.size() < max_concurrent_dns_lookups_) {
+         (!enable_queue ||
+          pending_lookups_.size() < max_concurrent_dns_lookups_)) {
     const GURL url(work_queue_.Pop());
     UrlInfo* info = &results_[url];
     DCHECK(info->HasUrl(url));
     info->SetAssignedState();
 
-    if (CongestionControlPerformed(info)) {
+    // Only perform congestion control if the queue is enabled.
+    if (enable_queue && CongestionControlPerformed(info)) {
       DCHECK(work_queue_.IsEmpty());
       return;
     }
 
     LookupRequest* request = new LookupRequest(this, host_resolver_, url);
 
     int status = request->Start();
     if (status == net::ERR_IO_PENDING) {
       // Will complete asynchronously.
       pending_lookups_.insert(request);
@@ skipping 209 matching lines @@
 }
 
 void SimplePredictor::ShutdownOnUIThread() {
   SetShutdown(true);
 }
 
 bool SimplePredictor::CanPrefetchAndPrerender() const { return true; }
 bool SimplePredictor::CanPreresolveAndPreconnect() const { return true; }
 
 }  // namespace chrome_browser_net