Add components/network_session_configurator.

components/network_session_configurator/network_session_configurator_unittest.cc

-// 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"
 
-#include "base/at_exit.h"
-#include "base/command_line.h"
-#include "base/macros.h"
+#include <map>
+#include <memory>
+
 #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/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 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);
   EXPECT_TRUE(params_.enable_http2);
   EXPECT_FALSE(params_.enable_tcp_fast_open_for_ssl);
   EXPECT_TRUE(params_.parse_alternative_services);
   EXPECT_FALSE(params_.enable_alternative_service_with_different_host);
   EXPECT_FALSE(params_.enable_npn);
   EXPECT_TRUE(params_.enable_priority_dependencies);
   EXPECT_FALSE(params_.enable_quic);
@@ skipping 146 matching lines @@
   EXPECT_FALSE(params_.quic_disable_connection_pooling);
   EXPECT_EQ(0.25f, params_.quic_load_server_info_timeout_srtt_multiplier);
   EXPECT_FALSE(params_.quic_enable_connection_racing);
   EXPECT_FALSE(params_.quic_enable_non_blocking_io);
   EXPECT_FALSE(params_.quic_disable_disk_cache);
   EXPECT_FALSE(params_.quic_prefer_aes);
   EXPECT_TRUE(params_.parse_alternative_services);
   EXPECT_FALSE(params_.enable_alternative_service_with_different_host);
   EXPECT_EQ(0, params_.quic_max_number_of_lossy_connections);
   EXPECT_EQ(1.0f, params_.quic_packet_loss_threshold);
-  EXPECT_FALSE(params_.quic_delay_tcp_race);
   EXPECT_FALSE(params_.quic_close_sessions_on_ip_change);
   EXPECT_EQ(net::kIdleConnectionTimeoutSeconds,
             params_.quic_idle_connection_timeout_seconds);
   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_TRUE(params_.quic_host_whitelist.empty());
 
   net::HttpNetworkSession::Params default_params;
   EXPECT_EQ(default_params.quic_supported_versions,
             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);
+}
+
 TEST_F(NetworkSessionConfiguratorTest,
        DisableQuicWhenConnectionTimesOutWithOpenStreamsFromFieldTrialParams) {
   std::map<std::string, std::string> field_trial_params;
   field_trial_params["disable_quic_on_timeout_with_open_streams"] = "true";
   variations::AssociateVariationParams("QUIC", "Enabled", field_trial_params);
   base::FieldTrialList::CreateFieldTrial("QUIC", "Enabled");
 
   ParseFieldTrials();
 
   EXPECT_TRUE(params_.disable_quic_on_timeout_with_open_streams);
@@ skipping 292 matching lines @@
   std::map<std::string, std::string> field_trial_params;
   field_trial_params["receive_buffer_size"] = "2097152";
   variations::AssociateVariationParams("QUIC", "Enabled", field_trial_params);
   base::FieldTrialList::CreateFieldTrial("QUIC", "Enabled");
 
   ParseFieldTrials();
 
   EXPECT_EQ(2097152, params_.quic_socket_receive_buffer_size);
 }
 
-TEST_F(NetworkSessionConfiguratorTest, QuicDelayTcpConnection) {
-  std::map<std::string, std::string> field_trial_params;
-  field_trial_params["delay_tcp_race"] = "true";
-  variations::AssociateVariationParams("QUIC", "Enabled", field_trial_params);
-  base::FieldTrialList::CreateFieldTrial("QUIC", "Enabled");
-
-  ParseFieldTrials();
-
-  EXPECT_TRUE(params_.quic_delay_tcp_race);
-}
-
 TEST_F(NetworkSessionConfiguratorTest, QuicOriginsToForceQuicOn) {
   base::CommandLine::ForCurrentProcess()->AppendSwitch("enable-quic");
   base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       "origin-to-force-quic-on", "www.example.com:443, www.example.org:443");
 
   ParseFieldTrialsAndCommandLine();
 
   EXPECT_EQ(2u, params_.origins_to_force_quic_on.size());
   EXPECT_TRUE(
       ContainsKey(params_.origins_to_force_quic_on,
@@ skipping 23 matching lines @@
   base::FieldTrialList::CreateFieldTrial("QUIC", "Enabled");
 
   ParseFieldTrials();
 
   EXPECT_EQ(2u, params_.quic_host_whitelist.size());
   EXPECT_TRUE(ContainsKey(params_.quic_host_whitelist, "www.example.org"));
   EXPECT_TRUE(ContainsKey(params_.quic_host_whitelist, "www.example.com"));
 }
 
 TEST_F(NetworkSessionConfiguratorTest, QuicDisallowedByPolicy) {
-  base::CommandLine::ForCurrentProcess()->AppendSwitch(switches::kEnableQuic);
+  base::CommandLine::ForCurrentProcess()->AppendSwitch("enable-quic");
   is_quic_allowed_by_policy_ = false;
 
   ParseFieldTrialsAndCommandLine();
 
   EXPECT_FALSE(params_.enable_quic);
 }
 
 TEST_F(NetworkSessionConfiguratorTest, TCPFastOpenHttpsEnabled) {
   base::FieldTrialList::CreateFieldTrial("TCPFastOpen", "HttpsEnabled");
 
   ParseFieldTrials();
 
   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