Add components/network_session_configurator.

components/network_session_configurator/network_session_configurator_unittest.cc

Index: components/network_session_configurator/network_session_configurator_unittest.cc
diff --git a/chrome/browser/io_thread_unittest.cc b/components/network_session_configurator/network_session_configurator_unittest.cc
similarity index 68%
copy from chrome/browser/io_thread_unittest.cc
copy to components/network_session_configurator/network_session_configurator_unittest.cc
index c1bfd0f91cfc9c241b9146afb1123dd4cdeaaaf6..389158985d7e6984c6ec853584016e8e01096f42 100644
--- a/chrome/browser/io_thread_unittest.cc
+++ b/components/network_session_configurator/network_session_configurator_unittest.cc
@@ -1,91 +1,64 @@
-// Copyright 2014 The Chromium Authors. All rights reserved.
+// Copyright (c) 2016 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 <stddef.h>
+#include "components/network_session_configurator/network_session_configurator.h"

[Ryan Hamilton, 2016/04/21 21:15:25]

Ditto. I wonder if we could shrink the name in some way?

+
+#include <map>
+#include <memory>
 
-#include "base/at_exit.h"
-#include "base/command_line.h"
-#include "base/macros.h"
 #include "base/metrics/field_trial.h"
-#include "base/run_loop.h"
 #include "base/test/mock_entropy_provider.h"
-#include "build/build_config.h"
-#include "chrome/browser/io_thread.h"
-#include "chrome/common/chrome_switches.h"
-#include "chrome/common/pref_names.h"
-#include "components/data_reduction_proxy/core/common/data_reduction_proxy_params.h"
-#include "components/policy/core/common/mock_policy_service.h"
-#include "components/prefs/pref_registry_simple.h"
-#include "components/prefs/pref_service.h"
-#include "components/prefs/testing_pref_service.h"
-#include "components/proxy_config/pref_proxy_config_tracker_impl.h"
-#include "components/proxy_config/proxy_config_pref_names.h"
+#include "components/network_session_configurator/switches.h"
 #include "components/variations/variations_associated_data.h"
-#include "content/public/browser/browser_thread.h"
-#include "content/public/test/test_browser_thread_bundle.h"
-#include "net/cert_net/nss_ocsp.h"
-#include "net/http/http_auth_preferences.h"
-#include "net/http/http_auth_scheme.h"
-#include "net/http/http_network_session.h"
+#include "net/http/http_stream_factory.h"
 #include "net/quic/quic_protocol.h"
-#include "net/quic/quic_stream_factory.h"
-#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-#if defined(ENABLE_EXTENSIONS)
-#include "chrome/browser/extensions/event_router_forwarder.h"
-#endif
-
-#if defined(OS_CHROMEOS)
-#include "chromeos/dbus/dbus_thread_manager.h"
-#include "chromeos/network/network_handler.h"
-#endif
-
 namespace test {
 
-using ::testing::ReturnRef;
-
-// Class used for accessing IOThread methods (friend of IOThread).
-class IOThreadPeer {
- public:
-  static net::HttpAuthPreferences* GetAuthPreferences(IOThread* io_thread) {
-    return io_thread->globals()->http_auth_preferences.get();
-  }
-};
-
 class NetworkSessionConfiguratorTest : public testing::Test {
  public:
   NetworkSessionConfiguratorTest()
-      : is_spdy_allowed_by_policy_(true), is_quic_allowed_by_policy_(true) {
+      : is_spdy_allowed_by_policy_(true),
+        is_quic_allowed_by_policy_(true),
+        quic_user_agent_id_("Chrome/52.0.2709.0 Linux x86_64") {
     field_trial_list_.reset(
         new base::FieldTrialList(new base::MockEntropyProvider()));
     variations::testing::ClearAllVariationParams();
   }
 
   void ParseFieldTrials() {
-    network_session_configurator_.ParseFieldTrials(
-        is_spdy_allowed_by_policy_, is_quic_allowed_by_policy_, &params_);
+    network_session_configurator::ParseFieldTrials(
+        is_spdy_allowed_by_policy_, is_quic_allowed_by_policy_,
+        quic_user_agent_id_, &params_);
   }
 
   void ParseFieldTrialsAndCommandLine() {
-    network_session_configurator_.ParseFieldTrialsAndCommandLine(
-        is_spdy_allowed_by_policy_, is_quic_allowed_by_policy_, &params_);
+    network_session_configurator::ParseFieldTrialsAndCommandLine(
+        is_spdy_allowed_by_policy_, is_quic_allowed_by_policy_,
+        quic_user_agent_id_, &params_);
+  }
+
+  bool ShouldEnableQuicForDataReductionProxy() {
+    const base::CommandLine& command_line =
+        *base::CommandLine::ForCurrentProcess();
+    return network_session_configurator::ShouldEnableQuicForDataReductionProxy(
+        command_line);
   }
 
   bool is_spdy_allowed_by_policy_;
   bool is_quic_allowed_by_policy_;
+  std::string quic_user_agent_id_;
   std::unique_ptr<base::FieldTrialList> field_trial_list_;
   net::HttpNetworkSession::Params params_;
-
- private:
-  IOThread::NetworkSessionConfigurator network_session_configurator_;
 };
 
 TEST_F(NetworkSessionConfiguratorTest, Defaults) {
   ParseFieldTrialsAndCommandLine();
 
   EXPECT_FALSE(params_.ignore_certificate_errors);
+  EXPECT_EQ("Chrome/52.0.2709.0 Linux x86_64", params_.quic_user_agent_id);
   EXPECT_EQ(0u, params_.testing_fixed_http_port);
   EXPECT_EQ(0u, params_.testing_fixed_https_port);
   EXPECT_FALSE(params_.enable_spdy31);
@@ -97,7 +70,7 @@ TEST_F(NetworkSessionConfiguratorTest, Defaults) {
   EXPECT_TRUE(params_.enable_priority_dependencies);
   EXPECT_FALSE(params_.enable_quic);
   EXPECT_FALSE(params_.enable_quic_for_proxies);
-  EXPECT_FALSE(IOThread::ShouldEnableQuicForDataReductionProxy());
+  EXPECT_FALSE(ShouldEnableQuicForDataReductionProxy());
 }
 
 TEST_F(NetworkSessionConfiguratorTest, IgnoreCertificateErrors) {
@@ -262,7 +235,7 @@ TEST_F(NetworkSessionConfiguratorTest, EnableQuicFromFieldTrialGroup) {
   EXPECT_FALSE(params_.quic_disable_preconnect_if_0rtt);
   EXPECT_FALSE(params_.quic_migrate_sessions_on_network_change);
   EXPECT_FALSE(params_.quic_migrate_sessions_early);
-  EXPECT_FALSE(IOThread::ShouldEnableQuicForDataReductionProxy());
+  EXPECT_FALSE(ShouldEnableQuicForDataReductionProxy());
   EXPECT_TRUE(params_.quic_host_whitelist.empty());
 
   net::HttpNetworkSession::Params default_params;
@@ -270,6 +243,26 @@ TEST_F(NetworkSessionConfiguratorTest, EnableQuicFromFieldTrialGroup) {
             params_.quic_supported_versions);
 }
 
+TEST_F(NetworkSessionConfiguratorTest, DisableQuicFromCommandLine) {
+  base::FieldTrialList::CreateFieldTrial("QUIC", "Enabled");
+  base::CommandLine::ForCurrentProcess()->AppendSwitch("disable-quic");
+
+  ParseFieldTrialsAndCommandLine();
+
+  EXPECT_FALSE(params_.enable_quic);
+}
+
+TEST_F(NetworkSessionConfiguratorTest, EnableQuicForDataReductionProxy) {
+  base::FieldTrialList::CreateFieldTrial("QUIC", "Enabled");
+  base::FieldTrialList::CreateFieldTrial("DataReductionProxyUseQuic",
+                                         "Enabled");
+
+  ParseFieldTrialsAndCommandLine();
+
+  EXPECT_TRUE(params_.enable_quic);
+  EXPECT_TRUE(ShouldEnableQuicForDataReductionProxy());
+}
+
 TEST_F(NetworkSessionConfiguratorTest,
        DisableQuicWhenConnectionTimesOutWithOpenStreamsFromFieldTrialParams) {
   std::map<std::string, std::string> field_trial_params;
@@ -310,9 +303,8 @@ TEST_F(NetworkSessionConfiguratorTest, EnableQuicFromQuicProxyFieldTrialGroup) {
   field_trial_list_.reset();
   for (size_t i = 0; i < arraysize(tests); ++i) {
     base::FieldTrialList field_trial_list(new base::MockEntropyProvider());
-    base::FieldTrialList::CreateFieldTrial(
-        data_reduction_proxy::params::GetQuicFieldTrialName(),
-        tests[i].field_trial_group_name);
+    base::FieldTrialList::CreateFieldTrial("DataReductionProxyUseQuic",
+                                           tests[i].field_trial_group_name);
 
     ParseFieldTrials();
 
@@ -320,7 +312,7 @@ TEST_F(NetworkSessionConfiguratorTest, EnableQuicFromQuicProxyFieldTrialGroup) {
     EXPECT_EQ(tests[i].expect_enable_quic, params_.enable_quic_for_proxies)
         << i;
     EXPECT_EQ(tests[i].expect_enable_quic,
-              IOThread::ShouldEnableQuicForDataReductionProxy())
+              ShouldEnableQuicForDataReductionProxy())
         << i;
   }
 }
@@ -332,7 +324,7 @@ TEST_F(NetworkSessionConfiguratorTest, EnableQuicFromCommandLine) {
 
   EXPECT_TRUE(params_.enable_quic);
   EXPECT_TRUE(params_.enable_quic_for_proxies);
-  EXPECT_FALSE(IOThread::ShouldEnableQuicForDataReductionProxy());
+  EXPECT_FALSE(ShouldEnableQuicForDataReductionProxy());
 }
 
 TEST_F(NetworkSessionConfiguratorTest,
@@ -681,7 +673,7 @@ TEST_F(NetworkSessionConfiguratorTest, QuicWhitelistFromParams) {
 }
 
 TEST_F(NetworkSessionConfiguratorTest, QuicDisallowedByPolicy) {
-  base::CommandLine::ForCurrentProcess()->AppendSwitch(switches::kEnableQuic);
+  base::CommandLine::ForCurrentProcess()->AppendSwitch("enable-quic");
   is_quic_allowed_by_policy_ = false;
 
   ParseFieldTrialsAndCommandLine();
@@ -697,189 +689,4 @@ TEST_F(NetworkSessionConfiguratorTest, TCPFastOpenHttpsEnabled) {
   EXPECT_TRUE(params_.enable_tcp_fast_open_for_ssl);
 }
 
-class IOThreadTestWithIOThreadObject : public testing::Test {
- public:
-  // These functions need to be public, since it is difficult to bind to
-  // protected functions in a test (the code would need to explicitly contain
-  // the name of the actual test class).
-  void CheckCnameLookup(bool expected) {
-    auto http_auth_preferences =
-        IOThreadPeer::GetAuthPreferences(io_thread_.get());
-    ASSERT_NE(nullptr, http_auth_preferences);
-    EXPECT_EQ(expected, http_auth_preferences->NegotiateDisableCnameLookup());
-  }
-
-  void CheckNegotiateEnablePort(bool expected) {
-    auto http_auth_preferences =
-        IOThreadPeer::GetAuthPreferences(io_thread_.get());
-    ASSERT_NE(nullptr, http_auth_preferences);
-    EXPECT_EQ(expected, http_auth_preferences->NegotiateEnablePort());
-  }
-
-#if defined(OS_ANDROID)
-  void CheckAuthAndroidNegoitateAccountType(std::string expected) {
-    auto http_auth_preferences =
-        IOThreadPeer::GetAuthPreferences(io_thread_.get());
-    ASSERT_NE(nullptr, http_auth_preferences);
-    EXPECT_EQ(expected,
-              http_auth_preferences->AuthAndroidNegotiateAccountType());
-  }
-#endif
-
-  void CheckCanUseDefaultCredentials(bool expected, const GURL& url) {
-    auto http_auth_preferences =
-        IOThreadPeer::GetAuthPreferences(io_thread_.get());
-    EXPECT_EQ(expected, http_auth_preferences->CanUseDefaultCredentials(url));
-  }
-
-  void CheckCanDelegate(bool expected, const GURL& url) {
-    auto http_auth_preferences =
-        IOThreadPeer::GetAuthPreferences(io_thread_.get());
-    EXPECT_EQ(expected, http_auth_preferences->CanDelegate(url));
-  }
-
- protected:
-  IOThreadTestWithIOThreadObject()
-      : thread_bundle_(content::TestBrowserThreadBundle::REAL_IO_THREAD |
-                       content::TestBrowserThreadBundle::DONT_START_THREADS) {
-#if defined(ENABLE_EXTENSIONS)
-    event_router_forwarder_ = new extensions::EventRouterForwarder;
-#endif
-    PrefRegistrySimple* pref_registry = pref_service_.registry();
-    IOThread::RegisterPrefs(pref_registry);
-    PrefProxyConfigTrackerImpl::RegisterPrefs(pref_registry);
-    ssl_config::SSLConfigServiceManager::RegisterPrefs(pref_registry);
-
-    // Set up default function behaviour.
-    EXPECT_CALL(policy_service_,
-                GetPolicies(policy::PolicyNamespace(
-                    policy::POLICY_DOMAIN_CHROME, std::string())))
-        .WillRepeatedly(ReturnRef(policy_map_));
-
-#if defined(OS_CHROMEOS)
-    // Needed by IOThread constructor.
-    chromeos::DBusThreadManager::Initialize();
-    chromeos::NetworkHandler::Initialize();
-#endif
-    // The IOThread constructor registers the IOThread object with as the
-    // BrowserThreadDelegate for the io thread.
-    io_thread_.reset(new IOThread(&pref_service_, &policy_service_, nullptr,
-#if defined(ENABLE_EXTENSIONS)
-                                  event_router_forwarder_.get()
-#else
-                                  nullptr
-#endif
-                                      ));
-    // Now that IOThread object is registered starting the threads will
-    // call the IOThread::Init(). This sets up the environment needed for
-    // these tests.
-    thread_bundle_.Start();
-  }
-
-  ~IOThreadTestWithIOThreadObject() override {
-#if defined(USE_NSS_CERTS)
-    // Reset OCSPIOLoop thread checks, so that the test runner can run
-    // futher tests in the same process.
-    RunOnIOThreadBlocking(base::Bind(&net::ResetNSSHttpIOForTesting));
-#endif
-#if defined(OS_CHROMEOS)
-    chromeos::NetworkHandler::Shutdown();
-    chromeos::DBusThreadManager::Shutdown();
-#endif
-  }
-  TestingPrefServiceSimple* pref_service() { return &pref_service_; }
-
-  void RunOnIOThreadBlocking(const base::Closure& task) {
-    base::RunLoop run_loop;
-    content::BrowserThread::PostTaskAndReply(
-        content::BrowserThread::IO, FROM_HERE, task, run_loop.QuitClosure());
-    run_loop.Run();
-  }
-
- private:
-  base::ShadowingAtExitManager at_exit_manager_;
-  TestingPrefServiceSimple pref_service_;
-#if defined(ENABLE_EXTENSIONS)
-  scoped_refptr<extensions::EventRouterForwarder> event_router_forwarder_;
-#endif
-  policy::PolicyMap policy_map_;
-  policy::MockPolicyService policy_service_;
-  // The ordering of the declarations of |io_thread_object_| and
-  // |thread_bundle_| matters. An IOThread cannot be deleted until all of
-  // the globals have been reset to their initial state via CleanUp. As
-  // TestBrowserThreadBundle's destructor is responsible for calling
-  // CleanUp(), the IOThread must be declared before the bundle, so that
-  // the bundle is deleted first.
-  std::unique_ptr<IOThread> io_thread_;
-  content::TestBrowserThreadBundle thread_bundle_;
-};
-
-TEST_F(IOThreadTestWithIOThreadObject, UpdateNegotiateDisableCnameLookup) {
-  // This test uses the kDisableAuthNegotiateCnameLookup to check that
-  // the HttpAuthPreferences are correctly initialized and running on the
-  // IO thread. The other preferences are tested by the HttpAuthPreferences
-  // unit tests.
-  pref_service()->SetBoolean(prefs::kDisableAuthNegotiateCnameLookup, false);
-  RunOnIOThreadBlocking(
-      base::Bind(&IOThreadTestWithIOThreadObject::CheckCnameLookup,
-                 base::Unretained(this), false));
-  pref_service()->SetBoolean(prefs::kDisableAuthNegotiateCnameLookup, true);
-  RunOnIOThreadBlocking(
-      base::Bind(&IOThreadTestWithIOThreadObject::CheckCnameLookup,
-                 base::Unretained(this), true));
-}
-
-TEST_F(IOThreadTestWithIOThreadObject, UpdateEnableAuthNegotiatePort) {
-  pref_service()->SetBoolean(prefs::kEnableAuthNegotiatePort, false);
-  RunOnIOThreadBlocking(
-      base::Bind(&IOThreadTestWithIOThreadObject::CheckNegotiateEnablePort,
-                 base::Unretained(this), false));
-  pref_service()->SetBoolean(prefs::kEnableAuthNegotiatePort, true);
-  RunOnIOThreadBlocking(
-      base::Bind(&IOThreadTestWithIOThreadObject::CheckNegotiateEnablePort,
-                 base::Unretained(this), true));
-}
-
-TEST_F(IOThreadTestWithIOThreadObject, UpdateServerWhitelist) {
-  GURL url("http://test.example.com");
-
-  pref_service()->SetString(prefs::kAuthServerWhitelist, "xxx");
-  RunOnIOThreadBlocking(
-      base::Bind(&IOThreadTestWithIOThreadObject::CheckCanUseDefaultCredentials,
-                 base::Unretained(this), false, url));
-
-  pref_service()->SetString(prefs::kAuthServerWhitelist, "*");
-  RunOnIOThreadBlocking(
-      base::Bind(&IOThreadTestWithIOThreadObject::CheckCanUseDefaultCredentials,
-                 base::Unretained(this), true, url));
-}
-
-TEST_F(IOThreadTestWithIOThreadObject, UpdateDelegateWhitelist) {
-  GURL url("http://test.example.com");
-
-  pref_service()->SetString(prefs::kAuthNegotiateDelegateWhitelist, "");
-  RunOnIOThreadBlocking(
-      base::Bind(&IOThreadTestWithIOThreadObject::CheckCanDelegate,
-                 base::Unretained(this), false, url));
-
-  pref_service()->SetString(prefs::kAuthNegotiateDelegateWhitelist, "*");
-  RunOnIOThreadBlocking(
-      base::Bind(&IOThreadTestWithIOThreadObject::CheckCanDelegate,
-                 base::Unretained(this), true, url));
-}
-
-#if defined(OS_ANDROID)
-// AuthAndroidNegotiateAccountType is only used on Android.
-TEST_F(IOThreadTestWithIOThreadObject, UpdateAuthAndroidNegotiateAccountType) {
-  pref_service()->SetString(prefs::kAuthAndroidNegotiateAccountType, "acc1");
-  RunOnIOThreadBlocking(base::Bind(
-      &IOThreadTestWithIOThreadObject::CheckAuthAndroidNegoitateAccountType,
-      base::Unretained(this), "acc1"));
-  pref_service()->SetString(prefs::kAuthAndroidNegotiateAccountType, "acc2");
-  RunOnIOThreadBlocking(base::Bind(
-      &IOThreadTestWithIOThreadObject::CheckAuthAndroidNegoitateAccountType,
-      base::Unretained(this), "acc2"));
-}
-#endif
-
 }  // namespace test