Switch the TCP reads on Windows to use non-blocking/non-async I/O.

chrome/browser/chrome_browser_field_trials.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/chrome_browser_field_trials.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
@@ skipping 15 matching lines @@
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/metrics/variations/variations_util.h"
 #include "net/http/http_stream_factory.h"
 #include "net/socket/client_socket_pool_base.h"
 #include "net/socket/client_socket_pool_manager.h"
 #include "net/spdy/spdy_session.h"
 #include "net/spdy/spdy_session_pool.h"
 #include "ui/base/layout.h"
 
 #if defined(OS_WIN)
+#include "net/socket/tcp_client_socket_win.h"
 #include "ui/base/win/dpi.h"  // For DisableNewTabFieldTrialIfNecesssary.
 #endif  // defined(OS_WIN)
 
 namespace {
 
 // Set up a uniformity field trial. |one_time_randomized| indicates if the
 // field trial is one-time randomized or session-randomized. |trial_name_string|
 // must contain a "%d" since the percentage of the group will be inserted in
 // the trial name. |num_trial_groups| must be a divisor of 100 (e.g. 5, 20)
 void SetupSingleUniformityFieldTrial(
@@ skipping 11 matching lines @@
   const int group_percent = 100 / num_trial_groups;
   const std::string trial_name = StringPrintf(trial_name_string.c_str(),
                                               group_percent);
 
   DVLOG(1) << "Trial name = " << trial_name;
 
   scoped_refptr<base::FieldTrial> trial(
       base::FieldTrialList::FactoryGetFieldTrial(
           trial_name, divisor, kDefaultGroupName, 2015, 1, 1, NULL));
   if (one_time_randomized)
-      trial->UseOneTimeRandomization();
+    trial->UseOneTimeRandomization();
   chrome_variations::AssociateGoogleVariationID(trial_name, kDefaultGroupName,
       trial_base_id);
   // Loop starts with group 1 because the field trial automatically creates a
   // default group, which would be group 0.
   for (int group_number = 1; group_number < num_trial_groups; ++group_number) {
     const std::string group_name = StringPrintf("group_%02d", group_number);
     DVLOG(1) << "    Group name = " << group_name;
     trial->AppendGroup(group_name, kProbabilityPerGroup);
     chrome_variations::AssociateGoogleVariationID(trial_name, group_name,
         static_cast<chrome_variations::VariationID>(trial_base_id +
@@ skipping 44 matching lines @@
   DefaultAppsFieldTrial();
   AutoLaunchChromeFieldTrial();
   gpu_util::InitializeCompositingFieldTrial();
   gpu_util::InitializeStage3DFieldTrial();
   SetupUniformityFieldTrials();
   AutocompleteFieldTrial::Activate();
   DisableNewTabFieldTrialIfNecesssary();
   SetUpSafeBrowsingInterstitialFieldTrial();
   SetUpInfiniteCacheFieldTrial();
   SetUpCacheSensitivityAnalysisFieldTrial();
+  WindowsOverlappedTCPReadsFieldTrial();
 #if defined(ENABLE_ONE_CLICK_SIGNIN)
   OneClickSigninHelper::InitializeFieldTrial();
 #endif
 }
 
 // This is an A/B test for the maximum number of persistent connections per
 // host. Currently Chrome, Firefox, and IE8 have this value set at 6. Safari
 // uses 4, and Fasterfox (a plugin for Firefox that supposedly configures it to
 // run faster) uses 8. We would like to see how much of an effect this value has
 // on browsing. Too large a value might cause us to run into SYN flood detection
@@ skipping 438 matching lines @@
                                                  2012, 12, 31, NULL));
   trial->AppendGroup("ControlA", sensitivity_analysis_probability);
   trial->AppendGroup("ControlB", sensitivity_analysis_probability);
   trial->AppendGroup("100A", sensitivity_analysis_probability);
   trial->AppendGroup("100B", sensitivity_analysis_probability);
   trial->AppendGroup("200A", sensitivity_analysis_probability);
   trial->AppendGroup("200B", sensitivity_analysis_probability);
   trial->AppendGroup("400A", sensitivity_analysis_probability);
   trial->AppendGroup("400B", sensitivity_analysis_probability);
 }
+
+void ChromeBrowserFieldTrials::WindowsOverlappedTCPReadsFieldTrial() {
+#if defined(OS_WIN)
+  if (parsed_command_line_.HasSwitch(switches::kOverlappedRead)) {
+    std::string option =
+        parsed_command_line_.GetSwitchValueASCII(switches::kOverlappedRead);
+    if (LowerCaseEqualsASCII(option, "off"))
+      net::TCPClientSocketWin::DisableOverlappedReads();
+  } else {
+    const base::FieldTrial::Probability kDivisor = 2;  // 1 in 2 chance
+    const base::FieldTrial::Probability kOverlappedReadProbability = 1;
+    scoped_refptr<base::FieldTrial> overlapped_reads_trial(
+        base::FieldTrialList::FactoryGetFieldTrial("OverlappedReadImpact",
+            kDivisor, "OverlappedReadEnabled", 2013, 6, 1, NULL));
+    int overlapped_reads_disabled_group =
+        overlapped_reads_trial->AppendGroup("OverlappedReadDisabled",
+                                            kOverlappedReadProbability);
+    int assigned_group = overlapped_reads_trial->group();
+    if (assigned_group == overlapped_reads_disabled_group)
+      net::TCPClientSocketWin::DisableOverlappedReads();
+  }
+#endif
+}
+