ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 1 | // Copyright 2014 The Chromium Authors. All rights reserved. |
| 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
| 5 | // End-to-end tests for WebSocket. |
| 6 | // |
| 7 | // A python server is (re)started for each test, which is moderately |
| 8 | // inefficient. However, it makes these tests a good fit for scenarios which |
| 9 | // require special server configurations. |
| 10 | |
tfarina | 8a2c66c2 | 2015-10-13 19:14:49 | [diff] [blame] | 11 | #include <stdint.h> |
ryansturm | 4bab0683 | 2016-03-03 23:41:07 | [diff] [blame] | 12 | |
danakj | 9c5cab5 | 2016-04-16 00:54:33 | [diff] [blame] | 13 | #include <memory> |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 14 | #include <string> |
Adam Rice | 5b4a3d8 | 2018-08-02 15:28:43 | [diff] [blame] | 15 | #include <utility> |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 16 | |
| 17 | #include "base/bind.h" |
| 18 | #include "base/bind_helpers.h" |
| 19 | #include "base/callback.h" |
skyostil | 4891b25b | 2015-06-11 11:43:45 | [diff] [blame] | 20 | #include "base/location.h" |
Avi Drissman | 13fc893 | 2015-12-20 04:40:46 | [diff] [blame] | 21 | #include "base/macros.h" |
danakj | 9c5cab5 | 2016-04-16 00:54:33 | [diff] [blame] | 22 | #include "base/memory/ptr_util.h" |
Bence Béky | 6562397 | 2018-03-05 15:31:56 | [diff] [blame] | 23 | #include "base/memory/scoped_refptr.h" |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 24 | #include "base/run_loop.h" |
skyostil | 4891b25b | 2015-06-11 11:43:45 | [diff] [blame] | 25 | #include "base/single_thread_task_runner.h" |
Adam Rice | 5b4a3d8 | 2018-08-02 15:28:43 | [diff] [blame] | 26 | #include "base/strings/strcat.h" |
Adam Rice | cb76ac6 | 2015-02-20 05:33:25 | [diff] [blame] | 27 | #include "base/strings/string_piece.h" |
Adam Rice | 5b4a3d8 | 2018-08-02 15:28:43 | [diff] [blame] | 28 | #include "base/strings/stringprintf.h" |
gab | f767595f | 2016-05-11 18:50:35 | [diff] [blame] | 29 | #include "base/threading/thread_task_runner_handle.h" |
Sergey Ulanov | a337dcd | 2017-09-08 20:53:14 | [diff] [blame] | 30 | #include "build/build_config.h" |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 31 | #include "net/base/auth.h" |
Adam Rice | 5b4a3d8 | 2018-08-02 15:28:43 | [diff] [blame] | 32 | #include "net/base/host_port_pair.h" |
Tsuyoshi Horo | 01faed6 | 2019-02-20 22:11:37 | [diff] [blame] | 33 | #include "net/base/ip_endpoint.h" |
ryansturm | 7de050c | 2016-02-23 00:10:21 | [diff] [blame] | 34 | #include "net/base/proxy_delegate.h" |
Adam Rice | 5b4a3d8 | 2018-08-02 15:28:43 | [diff] [blame] | 35 | #include "net/base/url_util.h" |
Yutaka Hirano | 2f65eec | 2018-05-23 01:58:22 | [diff] [blame] | 36 | #include "net/http/http_request_headers.h" |
Adam Rice | 5b4a3d8 | 2018-08-02 15:28:43 | [diff] [blame] | 37 | #include "net/log/net_log.h" |
Nicolas Arciniega | d2013f9 | 2020-02-07 23:00:56 | [diff] [blame^] | 38 | #include "net/proxy_resolution/configured_proxy_resolution_service.h" |
Adam Rice | 5b4a3d8 | 2018-08-02 15:28:43 | [diff] [blame] | 39 | #include "net/proxy_resolution/proxy_config.h" |
| 40 | #include "net/proxy_resolution/proxy_config_service.h" |
| 41 | #include "net/proxy_resolution/proxy_config_service_fixed.h" |
| 42 | #include "net/proxy_resolution/proxy_config_with_annotation.h" |
| 43 | #include "net/proxy_resolution/proxy_info.h" |
tommycli | 59a6343 | 2015-11-06 00:10:55 | [diff] [blame] | 44 | #include "net/test/embedded_test_server/embedded_test_server.h" |
Adam Rice | 5b4a3d8 | 2018-08-02 15:28:43 | [diff] [blame] | 45 | #include "net/test/embedded_test_server/http_request.h" |
| 46 | #include "net/test/embedded_test_server/http_response.h" |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 47 | #include "net/test/spawned_test_server/spawned_test_server.h" |
rsleevi | a69c79a | 2016-06-22 03:28:43 | [diff] [blame] | 48 | #include "net/test/test_data_directory.h" |
Gabriel Charette | c710874 | 2019-08-23 03:31:40 | [diff] [blame] | 49 | #include "net/test/test_with_task_environment.h" |
rhalavati | 9ebaba7e | 2017-04-27 06:16:29 | [diff] [blame] | 50 | #include "net/traffic_annotation/network_traffic_annotation_test_helper.h" |
Adam Rice | 5b4a3d8 | 2018-08-02 15:28:43 | [diff] [blame] | 51 | #include "net/url_request/url_request.h" |
| 52 | #include "net/url_request/url_request_context.h" |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 53 | #include "net/url_request/url_request_test_util.h" |
| 54 | #include "net/websockets/websocket_channel.h" |
| 55 | #include "net/websockets/websocket_event_interface.h" |
| 56 | #include "testing/gtest/include/gtest/gtest.h" |
Adam Rice | 5b4a3d8 | 2018-08-02 15:28:43 | [diff] [blame] | 57 | #include "url/gurl.h" |
mkwst | 4997ce8 | 2015-07-25 12:00:05 | [diff] [blame] | 58 | #include "url/origin.h" |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 59 | |
| 60 | namespace net { |
| 61 | |
yhirano | 4a59383 | 2016-10-24 18:58:22 | [diff] [blame] | 62 | class URLRequest; |
| 63 | |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 64 | namespace { |
| 65 | |
Adam Rice | 5b4a3d8 | 2018-08-02 15:28:43 | [diff] [blame] | 66 | using test_server::BasicHttpResponse; |
| 67 | using test_server::HttpRequest; |
| 68 | using test_server::HttpResponse; |
| 69 | |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 70 | static const char kEchoServer[] = "echo-with-no-extension"; |
| 71 | |
Adam Rice | cb76ac6 | 2015-02-20 05:33:25 | [diff] [blame] | 72 | // Simplify changing URL schemes. |
| 73 | GURL ReplaceUrlScheme(const GURL& in_url, const base::StringPiece& scheme) { |
| 74 | GURL::Replacements replacements; |
| 75 | replacements.SetSchemeStr(scheme); |
| 76 | return in_url.ReplaceComponents(replacements); |
| 77 | } |
| 78 | |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 79 | // An implementation of WebSocketEventInterface that waits for and records the |
| 80 | // results of the connect. |
| 81 | class ConnectTestingEventInterface : public WebSocketEventInterface { |
| 82 | public: |
| 83 | ConnectTestingEventInterface(); |
| 84 | |
| 85 | void WaitForResponse(); |
| 86 | |
| 87 | bool failed() const { return failed_; } |
| 88 | |
| 89 | // Only set if the handshake failed, otherwise empty. |
| 90 | std::string failure_message() const; |
| 91 | |
| 92 | std::string selected_subprotocol() const; |
| 93 | |
| 94 | std::string extensions() const; |
| 95 | |
| 96 | // Implementation of WebSocketEventInterface. |
yhirano | 4a59383 | 2016-10-24 18:58:22 | [diff] [blame] | 97 | void OnCreateURLRequest(URLRequest* request) override {} |
| 98 | |
Yoichi Osato | 1ead61a | 2020-01-06 04:52:57 | [diff] [blame] | 99 | void OnAddChannelResponse( |
| 100 | std::unique_ptr<WebSocketHandshakeResponseInfo> response, |
| 101 | const std::string& selected_subprotocol, |
| 102 | const std::string& extensions, |
| 103 | int64_t send_flow_control_quota) override; |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 104 | |
Yutaka Hirano | 4165de9 | 2018-04-10 11:46:49 | [diff] [blame] | 105 | void OnDataFrame(bool fin, |
| 106 | WebSocketMessageType type, |
Yutaka Hirano | 76aacb20 | 2019-09-05 16:36:56 | [diff] [blame] | 107 | base::span<const char> payload) override; |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 108 | |
Yoichi Osato | fcaa2a2 | 2019-08-28 08:22:36 | [diff] [blame] | 109 | bool HasPendingDataFrames() override { return false; } |
| 110 | |
Yoichi Osato | b088adc | 2019-06-06 05:52:19 | [diff] [blame] | 111 | void OnSendFlowControlQuotaAdded(int64_t quota) override; |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 112 | |
Yutaka Hirano | 4165de9 | 2018-04-10 11:46:49 | [diff] [blame] | 113 | void OnClosingHandshake() override; |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 114 | |
Yutaka Hirano | 4165de9 | 2018-04-10 11:46:49 | [diff] [blame] | 115 | void OnDropChannel(bool was_clean, |
| 116 | uint16_t code, |
| 117 | const std::string& reason) override; |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 118 | |
Yutaka Hirano | 4165de9 | 2018-04-10 11:46:49 | [diff] [blame] | 119 | void OnFailChannel(const std::string& message) override; |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 120 | |
Yutaka Hirano | 4165de9 | 2018-04-10 11:46:49 | [diff] [blame] | 121 | void OnStartOpeningHandshake( |
danakj | 9c5cab5 | 2016-04-16 00:54:33 | [diff] [blame] | 122 | std::unique_ptr<WebSocketHandshakeRequestInfo> request) override; |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 123 | |
Yutaka Hirano | 4165de9 | 2018-04-10 11:46:49 | [diff] [blame] | 124 | void OnSSLCertificateError( |
danakj | 9c5cab5 | 2016-04-16 00:54:33 | [diff] [blame] | 125 | std::unique_ptr<SSLErrorCallbacks> ssl_error_callbacks, |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 126 | const GURL& url, |
Emily Stark | d9df3d3 | 2019-04-29 17:54:57 | [diff] [blame] | 127 | int net_error, |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 128 | const SSLInfo& ssl_info, |
| 129 | bool fatal) override; |
| 130 | |
Emily Stark | f2c9bbd | 2019-04-09 17:08:58 | [diff] [blame] | 131 | int OnAuthRequired(const AuthChallengeInfo& auth_info, |
Yutaka Hirano | 70fa2591 | 2018-06-06 05:26:54 | [diff] [blame] | 132 | scoped_refptr<HttpResponseHeaders> response_headers, |
Tsuyoshi Horo | 01faed6 | 2019-02-20 22:11:37 | [diff] [blame] | 133 | const IPEndPoint& remote_endpoint, |
Yutaka Hirano | 70fa2591 | 2018-06-06 05:26:54 | [diff] [blame] | 134 | base::OnceCallback<void(const AuthCredentials*)> callback, |
| 135 | base::Optional<AuthCredentials>* credentials) override; |
| 136 | |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 137 | private: |
| 138 | void QuitNestedEventLoop(); |
| 139 | |
| 140 | // failed_ is true if the handshake failed (ie. OnFailChannel was called). |
| 141 | bool failed_; |
| 142 | std::string selected_subprotocol_; |
| 143 | std::string extensions_; |
| 144 | std::string failure_message_; |
| 145 | base::RunLoop run_loop_; |
| 146 | |
| 147 | DISALLOW_COPY_AND_ASSIGN(ConnectTestingEventInterface); |
| 148 | }; |
| 149 | |
tyoshino | c06da56 | 2015-03-06 06:02:42 | [diff] [blame] | 150 | ConnectTestingEventInterface::ConnectTestingEventInterface() : failed_(false) { |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 151 | } |
| 152 | |
| 153 | void ConnectTestingEventInterface::WaitForResponse() { |
| 154 | run_loop_.Run(); |
| 155 | } |
| 156 | |
| 157 | std::string ConnectTestingEventInterface::failure_message() const { |
| 158 | return failure_message_; |
| 159 | } |
| 160 | |
| 161 | std::string ConnectTestingEventInterface::selected_subprotocol() const { |
| 162 | return selected_subprotocol_; |
| 163 | } |
| 164 | |
| 165 | std::string ConnectTestingEventInterface::extensions() const { |
| 166 | return extensions_; |
| 167 | } |
| 168 | |
Yutaka Hirano | 4165de9 | 2018-04-10 11:46:49 | [diff] [blame] | 169 | void ConnectTestingEventInterface::OnAddChannelResponse( |
Yoichi Osato | 1ead61a | 2020-01-06 04:52:57 | [diff] [blame] | 170 | std::unique_ptr<WebSocketHandshakeResponseInfo> response, |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 171 | const std::string& selected_subprotocol, |
Yoichi Osato | 1bcffbc | 2019-10-30 03:17:31 | [diff] [blame] | 172 | const std::string& extensions, |
| 173 | int64_t send_flow_control_quota) { |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 174 | selected_subprotocol_ = selected_subprotocol; |
| 175 | extensions_ = extensions; |
| 176 | QuitNestedEventLoop(); |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 177 | } |
| 178 | |
Yutaka Hirano | 4165de9 | 2018-04-10 11:46:49 | [diff] [blame] | 179 | void ConnectTestingEventInterface::OnDataFrame(bool fin, |
| 180 | WebSocketMessageType type, |
Yutaka Hirano | 76aacb20 | 2019-09-05 16:36:56 | [diff] [blame] | 181 | base::span<const char> payload) { |
| 182 | } |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 183 | |
Yoichi Osato | b088adc | 2019-06-06 05:52:19 | [diff] [blame] | 184 | void ConnectTestingEventInterface::OnSendFlowControlQuotaAdded(int64_t quota) {} |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 185 | |
Yutaka Hirano | 4165de9 | 2018-04-10 11:46:49 | [diff] [blame] | 186 | void ConnectTestingEventInterface::OnClosingHandshake() {} |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 187 | |
Yutaka Hirano | 4165de9 | 2018-04-10 11:46:49 | [diff] [blame] | 188 | void ConnectTestingEventInterface::OnDropChannel(bool was_clean, |
| 189 | uint16_t code, |
| 190 | const std::string& reason) {} |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 191 | |
Yutaka Hirano | 4165de9 | 2018-04-10 11:46:49 | [diff] [blame] | 192 | void ConnectTestingEventInterface::OnFailChannel(const std::string& message) { |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 193 | failed_ = true; |
| 194 | failure_message_ = message; |
| 195 | QuitNestedEventLoop(); |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 196 | } |
| 197 | |
Yutaka Hirano | 4165de9 | 2018-04-10 11:46:49 | [diff] [blame] | 198 | void ConnectTestingEventInterface::OnStartOpeningHandshake( |
| 199 | std::unique_ptr<WebSocketHandshakeRequestInfo> request) {} |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 200 | |
Yutaka Hirano | 4165de9 | 2018-04-10 11:46:49 | [diff] [blame] | 201 | void ConnectTestingEventInterface::OnSSLCertificateError( |
danakj | 9c5cab5 | 2016-04-16 00:54:33 | [diff] [blame] | 202 | std::unique_ptr<SSLErrorCallbacks> ssl_error_callbacks, |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 203 | const GURL& url, |
Emily Stark | d9df3d3 | 2019-04-29 17:54:57 | [diff] [blame] | 204 | int net_error, |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 205 | const SSLInfo& ssl_info, |
| 206 | bool fatal) { |
skyostil | 4891b25b | 2015-06-11 11:43:45 | [diff] [blame] | 207 | base::ThreadTaskRunnerHandle::Get()->PostTask( |
kylechar | f4fe517 | 2019-02-15 18:53:49 | [diff] [blame] | 208 | FROM_HERE, base::BindOnce(&SSLErrorCallbacks::CancelSSLRequest, |
| 209 | base::Owned(ssl_error_callbacks.release()), |
| 210 | ERR_SSL_PROTOCOL_ERROR, &ssl_info)); |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 211 | } |
| 212 | |
Yutaka Hirano | 70fa2591 | 2018-06-06 05:26:54 | [diff] [blame] | 213 | int ConnectTestingEventInterface::OnAuthRequired( |
Emily Stark | f2c9bbd | 2019-04-09 17:08:58 | [diff] [blame] | 214 | const AuthChallengeInfo& auth_info, |
Yutaka Hirano | 70fa2591 | 2018-06-06 05:26:54 | [diff] [blame] | 215 | scoped_refptr<HttpResponseHeaders> response_headers, |
Tsuyoshi Horo | 01faed6 | 2019-02-20 22:11:37 | [diff] [blame] | 216 | const IPEndPoint& remote_endpoint, |
Yutaka Hirano | 70fa2591 | 2018-06-06 05:26:54 | [diff] [blame] | 217 | base::OnceCallback<void(const AuthCredentials*)> callback, |
| 218 | base::Optional<AuthCredentials>* credentials) { |
| 219 | *credentials = base::nullopt; |
| 220 | return OK; |
| 221 | } |
| 222 | |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 223 | void ConnectTestingEventInterface::QuitNestedEventLoop() { |
| 224 | run_loop_.Quit(); |
| 225 | } |
| 226 | |
| 227 | // A subclass of TestNetworkDelegate that additionally implements the |
| 228 | // OnResolveProxy callback and records the information passed to it. |
ryansturm | 7de050c | 2016-02-23 00:10:21 | [diff] [blame] | 229 | class TestProxyDelegateWithProxyInfo : public ProxyDelegate { |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 230 | public: |
Chris Watkins | 28c2fdd | 2017-11-30 06:06:52 | [diff] [blame] | 231 | TestProxyDelegateWithProxyInfo() = default; |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 232 | |
| 233 | struct ResolvedProxyInfo { |
| 234 | GURL url; |
| 235 | ProxyInfo proxy_info; |
| 236 | }; |
| 237 | |
| 238 | const ResolvedProxyInfo& resolved_proxy_info() const { |
| 239 | return resolved_proxy_info_; |
| 240 | } |
| 241 | |
| 242 | protected: |
| 243 | void OnResolveProxy(const GURL& url, |
ryansturm | 4bab0683 | 2016-03-03 23:41:07 | [diff] [blame] | 244 | const std::string& method, |
Reilly Grant | b414ace7 | 2017-11-14 23:03:22 | [diff] [blame] | 245 | const ProxyRetryInfoMap& proxy_retry_info, |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 246 | ProxyInfo* result) override { |
| 247 | resolved_proxy_info_.url = url; |
| 248 | resolved_proxy_info_.proxy_info = *result; |
| 249 | } |
| 250 | |
ryansturm | 7de050c | 2016-02-23 00:10:21 | [diff] [blame] | 251 | void OnFallback(const ProxyServer& bad_proxy, int net_error) override {} |
ryansturm | 7de050c | 2016-02-23 00:10:21 | [diff] [blame] | 252 | |
Wojciech Dzierżanowski | c270404 | 2019-02-07 20:54:28 | [diff] [blame] | 253 | void OnBeforeHttp1TunnelRequest(const ProxyServer& proxy_server, |
| 254 | HttpRequestHeaders* extra_headers) override {} |
Wojciech Dzierżanowski | 1f82356 | 2019-01-18 11:26:00 | [diff] [blame] | 255 | |
Wojciech Dzierżanowski | c270404 | 2019-02-07 20:54:28 | [diff] [blame] | 256 | Error OnHttp1TunnelHeadersReceived( |
Wojciech Dzierżanowski | 1f82356 | 2019-01-18 11:26:00 | [diff] [blame] | 257 | const ProxyServer& proxy_server, |
| 258 | const HttpResponseHeaders& response_headers) override { |
| 259 | return OK; |
| 260 | } |
| 261 | |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 262 | private: |
| 263 | ResolvedProxyInfo resolved_proxy_info_; |
| 264 | |
ryansturm | 7de050c | 2016-02-23 00:10:21 | [diff] [blame] | 265 | DISALLOW_COPY_AND_ASSIGN(TestProxyDelegateWithProxyInfo); |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 266 | }; |
| 267 | |
Gabriel Charette | 694c3c33 | 2019-08-19 14:53:05 | [diff] [blame] | 268 | class WebSocketEndToEndTest : public TestWithTaskEnvironment { |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 269 | protected: |
| 270 | WebSocketEndToEndTest() |
Adam Rice | cb76ac6 | 2015-02-20 05:33:25 | [diff] [blame] | 271 | : event_interface_(), |
Bence Béky | 6562397 | 2018-03-05 15:31:56 | [diff] [blame] | 272 | proxy_delegate_(std::make_unique<TestProxyDelegateWithProxyInfo>()), |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 273 | context_(true), |
Adam Rice | cb76ac6 | 2015-02-20 05:33:25 | [diff] [blame] | 274 | channel_(), |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 275 | initialised_context_(false) {} |
| 276 | |
| 277 | // Initialise the URLRequestContext. Normally done automatically by |
| 278 | // ConnectAndWait(). This method is for the use of tests that need the |
| 279 | // URLRequestContext initialised before calling ConnectAndWait(). |
| 280 | void InitialiseContext() { |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 281 | context_.Init(); |
Eric Roman | 3d8546a | 2018-09-10 17:00:52 | [diff] [blame] | 282 | context_.proxy_resolution_service()->SetProxyDelegate( |
| 283 | proxy_delegate_.get()); |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 284 | initialised_context_ = true; |
| 285 | } |
| 286 | |
| 287 | // Send the connect request to |socket_url| and wait for a response. Returns |
| 288 | // true if the handshake succeeded. |
| 289 | bool ConnectAndWait(const GURL& socket_url) { |
| 290 | if (!initialised_context_) { |
| 291 | InitialiseContext(); |
| 292 | } |
Daniel Cheng | 88186bd5 | 2017-10-20 08:14:46 | [diff] [blame] | 293 | url::Origin origin = url::Origin::Create(GURL("http://localhost")); |
Maks Orlovich | 8be0e25 | 2019-12-09 18:35:49 | [diff] [blame] | 294 | net::SiteForCookies site_for_cookies = |
| 295 | net::SiteForCookies::FromOrigin(origin); |
Ehimare Okoyomon | 4446d8c | 2019-10-23 12:47:32 | [diff] [blame] | 296 | net::NetworkIsolationKey network_isolation_key(origin, origin); |
Adam Rice | 5b4a3d8 | 2018-08-02 15:28:43 | [diff] [blame] | 297 | event_interface_ = new ConnectTestingEventInterface(); |
Bence Béky | 6562397 | 2018-03-05 15:31:56 | [diff] [blame] | 298 | channel_ = std::make_unique<WebSocketChannel>( |
| 299 | base::WrapUnique(event_interface_), &context_); |
allada | cef397d | 2016-06-29 17:52:23 | [diff] [blame] | 300 | channel_->SendAddChannelRequest(GURL(socket_url), sub_protocols_, origin, |
Ehimare Okoyomon | 4446d8c | 2019-10-23 12:47:32 | [diff] [blame] | 301 | site_for_cookies, network_isolation_key, |
| 302 | HttpRequestHeaders()); |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 303 | event_interface_->WaitForResponse(); |
| 304 | return !event_interface_->failed(); |
| 305 | } |
| 306 | |
| 307 | ConnectTestingEventInterface* event_interface_; // owned by channel_ |
danakj | 9c5cab5 | 2016-04-16 00:54:33 | [diff] [blame] | 308 | std::unique_ptr<TestProxyDelegateWithProxyInfo> proxy_delegate_; |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 309 | TestURLRequestContext context_; |
danakj | 9c5cab5 | 2016-04-16 00:54:33 | [diff] [blame] | 310 | std::unique_ptr<WebSocketChannel> channel_; |
ricea | 5acb1faf7 | 2015-03-16 15:34:00 | [diff] [blame] | 311 | std::vector<std::string> sub_protocols_; |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 312 | bool initialised_context_; |
| 313 | }; |
| 314 | |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 315 | // Basic test of connectivity. If this test fails, nothing else can be expected |
| 316 | // to work. |
Sergey Ulanov | 4c786d3 | 2017-09-08 22:53:25 | [diff] [blame] | 317 | TEST_F(WebSocketEndToEndTest, BasicSmokeTest) { |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 318 | SpawnedTestServer ws_server(SpawnedTestServer::TYPE_WS, |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 319 | GetWebSocketTestDataDirectory()); |
| 320 | ASSERT_TRUE(ws_server.Start()); |
| 321 | EXPECT_TRUE(ConnectAndWait(ws_server.GetURL(kEchoServer))); |
| 322 | } |
| 323 | |
| 324 | // Test for issue crbug.com/433695 "Unencrypted WebSocket connection via |
| 325 | // authenticated proxy times out" |
| 326 | // TODO(ricea): Enable this when the issue is fixed. |
| 327 | TEST_F(WebSocketEndToEndTest, DISABLED_HttpsProxyUnauthedFails) { |
| 328 | SpawnedTestServer proxy_server(SpawnedTestServer::TYPE_BASIC_AUTH_PROXY, |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 329 | base::FilePath()); |
| 330 | SpawnedTestServer ws_server(SpawnedTestServer::TYPE_WS, |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 331 | GetWebSocketTestDataDirectory()); |
| 332 | ASSERT_TRUE(proxy_server.StartInBackground()); |
| 333 | ASSERT_TRUE(ws_server.StartInBackground()); |
| 334 | ASSERT_TRUE(proxy_server.BlockUntilStarted()); |
| 335 | ASSERT_TRUE(ws_server.BlockUntilStarted()); |
| 336 | std::string proxy_config = |
| 337 | "https=" + proxy_server.host_port_pair().ToString(); |
Nicolas Arciniega | d2013f9 | 2020-02-07 23:00:56 | [diff] [blame^] | 338 | std::unique_ptr<ConfiguredProxyResolutionService> proxy_resolution_service( |
| 339 | ConfiguredProxyResolutionService::CreateFixed( |
| 340 | proxy_config, TRAFFIC_ANNOTATION_FOR_TESTS)); |
Lily Houghton | 8c2f97d | 2018-01-22 05:06:59 | [diff] [blame] | 341 | ASSERT_TRUE(proxy_resolution_service); |
| 342 | context_.set_proxy_resolution_service(proxy_resolution_service.get()); |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 343 | EXPECT_FALSE(ConnectAndWait(ws_server.GetURL(kEchoServer))); |
| 344 | EXPECT_EQ("Proxy authentication failed", event_interface_->failure_message()); |
| 345 | } |
| 346 | |
Sergey Ulanov | 4c786d3 | 2017-09-08 22:53:25 | [diff] [blame] | 347 | // These test are not compatible with RemoteTestServer because RemoteTestServer |
| 348 | // doesn't support TYPE_BASIC_AUTH_PROXY. |
| 349 | // TODO(ricea): Make these tests work. See crbug.com/441711. |
| 350 | #if defined(OS_ANDROID) || defined(OS_FUCHSIA) |
| 351 | #define MAYBE_HttpsWssProxyUnauthedFails DISABLED_HttpsWssProxyUnauthedFails |
| 352 | #define MAYBE_HttpsProxyUsed DISABLED_HttpsProxyUsed |
| 353 | #else |
| 354 | #define MAYBE_HttpsWssProxyUnauthedFails HttpsWssProxyUnauthedFails |
| 355 | #define MAYBE_HttpsProxyUsed HttpsProxyUsed |
| 356 | #endif |
| 357 | |
| 358 | TEST_F(WebSocketEndToEndTest, MAYBE_HttpsWssProxyUnauthedFails) { |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 359 | SpawnedTestServer proxy_server(SpawnedTestServer::TYPE_BASIC_AUTH_PROXY, |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 360 | base::FilePath()); |
| 361 | SpawnedTestServer wss_server(SpawnedTestServer::TYPE_WSS, |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 362 | GetWebSocketTestDataDirectory()); |
| 363 | ASSERT_TRUE(proxy_server.StartInBackground()); |
| 364 | ASSERT_TRUE(wss_server.StartInBackground()); |
| 365 | ASSERT_TRUE(proxy_server.BlockUntilStarted()); |
| 366 | ASSERT_TRUE(wss_server.BlockUntilStarted()); |
Eric Roman | da790f9 | 2018-11-07 19:17:15 | [diff] [blame] | 367 | ProxyConfig proxy_config; |
| 368 | proxy_config.proxy_rules().ParseFromString( |
| 369 | "https=" + proxy_server.host_port_pair().ToString()); |
| 370 | // TODO(https://crbug.com/901896): Don't rely on proxying localhost. |
| 371 | proxy_config.proxy_rules().bypass_rules.AddRulesToSubtractImplicit(); |
| 372 | |
Nicolas Arciniega | d2013f9 | 2020-02-07 23:00:56 | [diff] [blame^] | 373 | std::unique_ptr<ConfiguredProxyResolutionService> proxy_resolution_service( |
| 374 | ConfiguredProxyResolutionService::CreateFixed(ProxyConfigWithAnnotation( |
Eric Roman | da790f9 | 2018-11-07 19:17:15 | [diff] [blame] | 375 | proxy_config, TRAFFIC_ANNOTATION_FOR_TESTS))); |
Lily Houghton | 8c2f97d | 2018-01-22 05:06:59 | [diff] [blame] | 376 | ASSERT_TRUE(proxy_resolution_service); |
| 377 | context_.set_proxy_resolution_service(proxy_resolution_service.get()); |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 378 | EXPECT_FALSE(ConnectAndWait(wss_server.GetURL(kEchoServer))); |
| 379 | EXPECT_EQ("Proxy authentication failed", event_interface_->failure_message()); |
| 380 | } |
| 381 | |
| 382 | // Regression test for crbug/426736 "WebSocket connections not using configured |
| 383 | // system HTTPS Proxy". |
Sergey Ulanov | 4c786d3 | 2017-09-08 22:53:25 | [diff] [blame] | 384 | TEST_F(WebSocketEndToEndTest, MAYBE_HttpsProxyUsed) { |
Adam Rice | 5b4a3d8 | 2018-08-02 15:28:43 | [diff] [blame] | 385 | SpawnedTestServer proxy_server(SpawnedTestServer::TYPE_PROXY, |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 386 | base::FilePath()); |
| 387 | SpawnedTestServer ws_server(SpawnedTestServer::TYPE_WS, |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 388 | GetWebSocketTestDataDirectory()); |
| 389 | ASSERT_TRUE(proxy_server.StartInBackground()); |
| 390 | ASSERT_TRUE(ws_server.StartInBackground()); |
| 391 | ASSERT_TRUE(proxy_server.BlockUntilStarted()); |
| 392 | ASSERT_TRUE(ws_server.BlockUntilStarted()); |
Eric Roman | da790f9 | 2018-11-07 19:17:15 | [diff] [blame] | 393 | ProxyConfig proxy_config; |
| 394 | proxy_config.proxy_rules().ParseFromString( |
| 395 | "https=" + proxy_server.host_port_pair().ToString() + ";" + |
| 396 | "http=" + proxy_server.host_port_pair().ToString()); |
| 397 | // TODO(https://crbug.com/901896): Don't rely on proxying localhost. |
| 398 | proxy_config.proxy_rules().bypass_rules.AddRulesToSubtractImplicit(); |
| 399 | |
Nicolas Arciniega | d2013f9 | 2020-02-07 23:00:56 | [diff] [blame^] | 400 | std::unique_ptr<ConfiguredProxyResolutionService> proxy_resolution_service( |
| 401 | ConfiguredProxyResolutionService::CreateFixed(ProxyConfigWithAnnotation( |
Eric Roman | da790f9 | 2018-11-07 19:17:15 | [diff] [blame] | 402 | proxy_config, TRAFFIC_ANNOTATION_FOR_TESTS))); |
Lily Houghton | 8c2f97d | 2018-01-22 05:06:59 | [diff] [blame] | 403 | context_.set_proxy_resolution_service(proxy_resolution_service.get()); |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 404 | InitialiseContext(); |
| 405 | |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 406 | GURL ws_url = ws_server.GetURL(kEchoServer); |
| 407 | EXPECT_TRUE(ConnectAndWait(ws_url)); |
ryansturm | 7de050c | 2016-02-23 00:10:21 | [diff] [blame] | 408 | const TestProxyDelegateWithProxyInfo::ResolvedProxyInfo& info = |
| 409 | proxy_delegate_->resolved_proxy_info(); |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 410 | EXPECT_EQ(ws_url, info.url); |
| 411 | EXPECT_TRUE(info.proxy_info.is_http()); |
| 412 | } |
| 413 | |
Adam Rice | 5b4a3d8 | 2018-08-02 15:28:43 | [diff] [blame] | 414 | std::unique_ptr<HttpResponse> ProxyPacHandler(const HttpRequest& request) { |
| 415 | GURL url = request.GetURL(); |
| 416 | EXPECT_EQ(url.path_piece(), "/proxy.pac"); |
| 417 | EXPECT_TRUE(url.has_query()); |
| 418 | std::string proxy; |
| 419 | EXPECT_TRUE(GetValueForKeyInQuery(url, "proxy", &proxy)); |
| 420 | auto response = std::make_unique<BasicHttpResponse>(); |
| 421 | response->set_content_type("application/x-ns-proxy-autoconfig"); |
| 422 | response->set_content( |
| 423 | base::StringPrintf("function FindProxyForURL(url, host) {\n" |
| 424 | " return 'PROXY %s';\n" |
| 425 | "}\n", |
| 426 | proxy.c_str())); |
| 427 | return response; |
| 428 | } |
| 429 | |
| 430 | // This tests the proxy.pac resolver that is built into the system. This is not |
| 431 | // the one that Chrome normally uses. Chrome's normal implementation is defined |
| 432 | // as a mojo service. It is outside //net and we can't use it from here. This |
| 433 | // tests the alternative implementations that are selected when the |
| 434 | // --winhttp-proxy-resolver flag is provided to Chrome. These only exist on OS X |
| 435 | // and Windows. |
| 436 | // TODO(ricea): Remove this test if --winhttp-proxy-resolver flag is removed. |
| 437 | // See crbug.com/644030. |
| 438 | |
| 439 | #if defined(OS_WIN) || defined(OS_MACOSX) |
| 440 | #define MAYBE_ProxyPacUsed ProxyPacUsed |
| 441 | #else |
| 442 | #define MAYBE_ProxyPacUsed DISABLED_ProxyPacUsed |
| 443 | #endif |
| 444 | |
| 445 | TEST_F(WebSocketEndToEndTest, MAYBE_ProxyPacUsed) { |
| 446 | EmbeddedTestServer proxy_pac_server(net::EmbeddedTestServer::Type::TYPE_HTTP); |
| 447 | SpawnedTestServer proxy_server(SpawnedTestServer::TYPE_PROXY, |
| 448 | base::FilePath()); |
| 449 | SpawnedTestServer ws_server(SpawnedTestServer::TYPE_WS, |
| 450 | GetWebSocketTestDataDirectory()); |
| 451 | proxy_pac_server.RegisterRequestHandler(base::BindRepeating(ProxyPacHandler)); |
| 452 | proxy_server.set_redirect_connect_to_localhost(true); |
| 453 | |
| 454 | ASSERT_TRUE(proxy_pac_server.Start()); |
| 455 | ASSERT_TRUE(proxy_server.StartInBackground()); |
| 456 | ASSERT_TRUE(ws_server.StartInBackground()); |
| 457 | ASSERT_TRUE(proxy_server.BlockUntilStarted()); |
| 458 | ASSERT_TRUE(ws_server.BlockUntilStarted()); |
| 459 | |
| 460 | ProxyConfig proxy_config = |
| 461 | ProxyConfig::CreateFromCustomPacURL(proxy_pac_server.GetURL(base::StrCat( |
| 462 | {"/proxy.pac?proxy=", proxy_server.host_port_pair().ToString()}))); |
| 463 | proxy_config.set_pac_mandatory(true); |
| 464 | auto proxy_config_service = std::make_unique<ProxyConfigServiceFixed>( |
| 465 | ProxyConfigWithAnnotation(proxy_config, TRAFFIC_ANNOTATION_FOR_TESTS)); |
Nicolas Arciniega | d2013f9 | 2020-02-07 23:00:56 | [diff] [blame^] | 466 | std::unique_ptr<ConfiguredProxyResolutionService> proxy_resolution_service( |
| 467 | ConfiguredProxyResolutionService::CreateUsingSystemProxyResolver( |
Matt Mueller | de5dadf | 2019-11-27 20:11:58 | [diff] [blame] | 468 | std::move(proxy_config_service), NetLog::Get())); |
Adam Rice | 5b4a3d8 | 2018-08-02 15:28:43 | [diff] [blame] | 469 | ASSERT_EQ(ws_server.host_port_pair().host(), "127.0.0.1"); |
| 470 | context_.set_proxy_resolution_service(proxy_resolution_service.get()); |
| 471 | InitialiseContext(); |
| 472 | |
Eric Roman | da790f9 | 2018-11-07 19:17:15 | [diff] [blame] | 473 | // Use a name other than localhost, since localhost implicitly bypasses the |
| 474 | // use of proxy.pac. |
Adam Rice | 5b4a3d8 | 2018-08-02 15:28:43 | [diff] [blame] | 475 | HostPortPair fake_ws_host_port_pair("stealth-localhost", |
| 476 | ws_server.host_port_pair().port()); |
| 477 | |
| 478 | GURL ws_url(base::StrCat( |
| 479 | {"ws://", fake_ws_host_port_pair.ToString(), "/", kEchoServer})); |
| 480 | EXPECT_TRUE(ConnectAndWait(ws_url)); |
| 481 | const auto& info = proxy_delegate_->resolved_proxy_info(); |
| 482 | EXPECT_EQ(ws_url, info.url); |
| 483 | EXPECT_TRUE(info.proxy_info.is_http()); |
| 484 | EXPECT_EQ(info.proxy_info.ToPacString(), |
| 485 | base::StrCat({"PROXY ", proxy_server.host_port_pair().ToString()})); |
| 486 | } |
| 487 | |
ricea | 23c3f94 | 2015-02-02 13:35:13 | [diff] [blame] | 488 | // This is a regression test for crbug.com/408061 Crash in |
| 489 | // net::WebSocketBasicHandshakeStream::Upgrade. |
Sergey Ulanov | 4c786d3 | 2017-09-08 22:53:25 | [diff] [blame] | 490 | TEST_F(WebSocketEndToEndTest, TruncatedResponse) { |
ricea | 23c3f94 | 2015-02-02 13:35:13 | [diff] [blame] | 491 | SpawnedTestServer ws_server(SpawnedTestServer::TYPE_WS, |
ricea | 23c3f94 | 2015-02-02 13:35:13 | [diff] [blame] | 492 | GetWebSocketTestDataDirectory()); |
| 493 | ASSERT_TRUE(ws_server.Start()); |
| 494 | InitialiseContext(); |
| 495 | |
| 496 | GURL ws_url = ws_server.GetURL("truncated-headers"); |
| 497 | EXPECT_FALSE(ConnectAndWait(ws_url)); |
| 498 | } |
| 499 | |
Adam Rice | cb76ac6 | 2015-02-20 05:33:25 | [diff] [blame] | 500 | // Regression test for crbug.com/455215 "HSTS not applied to WebSocket" |
Sergey Ulanov | 4c786d3 | 2017-09-08 22:53:25 | [diff] [blame] | 501 | TEST_F(WebSocketEndToEndTest, HstsHttpsToWebSocket) { |
tommycli | 59a6343 | 2015-11-06 00:10:55 | [diff] [blame] | 502 | EmbeddedTestServer https_server(net::EmbeddedTestServer::Type::TYPE_HTTPS); |
| 503 | https_server.SetSSLConfig( |
| 504 | net::EmbeddedTestServer::CERT_COMMON_NAME_IS_DOMAIN); |
| 505 | https_server.ServeFilesFromSourceDirectory("net/data/url_request_unittest"); |
| 506 | |
estark | a5da7670 | 2015-04-09 04:00:16 | [diff] [blame] | 507 | SpawnedTestServer::SSLOptions ssl_options( |
| 508 | SpawnedTestServer::SSLOptions::CERT_COMMON_NAME_IS_DOMAIN); |
Adam Rice | cb76ac6 | 2015-02-20 05:33:25 | [diff] [blame] | 509 | SpawnedTestServer wss_server(SpawnedTestServer::TYPE_WSS, ssl_options, |
| 510 | GetWebSocketTestDataDirectory()); |
estark | a5da7670 | 2015-04-09 04:00:16 | [diff] [blame] | 511 | |
tommycli | 59a6343 | 2015-11-06 00:10:55 | [diff] [blame] | 512 | ASSERT_TRUE(https_server.Start()); |
| 513 | ASSERT_TRUE(wss_server.Start()); |
Adam Rice | cb76ac6 | 2015-02-20 05:33:25 | [diff] [blame] | 514 | InitialiseContext(); |
| 515 | // Set HSTS via https: |
| 516 | TestDelegate delegate; |
tommycli | 59a6343 | 2015-11-06 00:10:55 | [diff] [blame] | 517 | GURL https_page = https_server.GetURL("/hsts-headers.html"); |
rhalavati | 9ebaba7e | 2017-04-27 06:16:29 | [diff] [blame] | 518 | std::unique_ptr<URLRequest> request(context_.CreateRequest( |
| 519 | https_page, DEFAULT_PRIORITY, &delegate, TRAFFIC_ANNOTATION_FOR_TESTS)); |
Adam Rice | cb76ac6 | 2015-02-20 05:33:25 | [diff] [blame] | 520 | request->Start(); |
Wez | 2a31b22 | 2018-06-07 22:07:15 | [diff] [blame] | 521 | delegate.RunUntilComplete(); |
maksim.sisov | 7f60c8e | 2016-09-16 19:38:17 | [diff] [blame] | 522 | EXPECT_EQ(OK, delegate.request_status()); |
Adam Rice | cb76ac6 | 2015-02-20 05:33:25 | [diff] [blame] | 523 | |
| 524 | // Check HSTS with ws: |
| 525 | // Change the scheme from wss: to ws: to verify that it is switched back. |
| 526 | GURL ws_url = ReplaceUrlScheme(wss_server.GetURL(kEchoServer), "ws"); |
| 527 | EXPECT_TRUE(ConnectAndWait(ws_url)); |
| 528 | } |
| 529 | |
Sergey Ulanov | 4c786d3 | 2017-09-08 22:53:25 | [diff] [blame] | 530 | TEST_F(WebSocketEndToEndTest, HstsWebSocketToHttps) { |
tommycli | 59a6343 | 2015-11-06 00:10:55 | [diff] [blame] | 531 | EmbeddedTestServer https_server(net::EmbeddedTestServer::Type::TYPE_HTTPS); |
| 532 | https_server.SetSSLConfig( |
| 533 | net::EmbeddedTestServer::CERT_COMMON_NAME_IS_DOMAIN); |
| 534 | https_server.ServeFilesFromSourceDirectory("net/data/url_request_unittest"); |
| 535 | |
estark | a5da7670 | 2015-04-09 04:00:16 | [diff] [blame] | 536 | SpawnedTestServer::SSLOptions ssl_options( |
| 537 | SpawnedTestServer::SSLOptions::CERT_COMMON_NAME_IS_DOMAIN); |
Adam Rice | cb76ac6 | 2015-02-20 05:33:25 | [diff] [blame] | 538 | SpawnedTestServer wss_server(SpawnedTestServer::TYPE_WSS, ssl_options, |
| 539 | GetWebSocketTestDataDirectory()); |
tommycli | 59a6343 | 2015-11-06 00:10:55 | [diff] [blame] | 540 | ASSERT_TRUE(https_server.Start()); |
| 541 | ASSERT_TRUE(wss_server.Start()); |
Adam Rice | cb76ac6 | 2015-02-20 05:33:25 | [diff] [blame] | 542 | InitialiseContext(); |
| 543 | // Set HSTS via wss: |
| 544 | GURL wss_url = wss_server.GetURL("set-hsts"); |
| 545 | EXPECT_TRUE(ConnectAndWait(wss_url)); |
| 546 | |
| 547 | // Verify via http: |
| 548 | TestDelegate delegate; |
| 549 | GURL http_page = |
tommycli | 59a6343 | 2015-11-06 00:10:55 | [diff] [blame] | 550 | ReplaceUrlScheme(https_server.GetURL("/simple.html"), "http"); |
rhalavati | 9ebaba7e | 2017-04-27 06:16:29 | [diff] [blame] | 551 | std::unique_ptr<URLRequest> request(context_.CreateRequest( |
| 552 | http_page, DEFAULT_PRIORITY, &delegate, TRAFFIC_ANNOTATION_FOR_TESTS)); |
Adam Rice | cb76ac6 | 2015-02-20 05:33:25 | [diff] [blame] | 553 | request->Start(); |
Wez | 2a31b22 | 2018-06-07 22:07:15 | [diff] [blame] | 554 | delegate.RunUntilComplete(); |
maksim.sisov | 7f60c8e | 2016-09-16 19:38:17 | [diff] [blame] | 555 | EXPECT_EQ(OK, delegate.request_status()); |
Adam Rice | cb76ac6 | 2015-02-20 05:33:25 | [diff] [blame] | 556 | EXPECT_TRUE(request->url().SchemeIs("https")); |
| 557 | } |
| 558 | |
Sergey Ulanov | 4c786d3 | 2017-09-08 22:53:25 | [diff] [blame] | 559 | TEST_F(WebSocketEndToEndTest, HstsWebSocketToWebSocket) { |
estark | a5da7670 | 2015-04-09 04:00:16 | [diff] [blame] | 560 | SpawnedTestServer::SSLOptions ssl_options( |
| 561 | SpawnedTestServer::SSLOptions::CERT_COMMON_NAME_IS_DOMAIN); |
Adam Rice | cb76ac6 | 2015-02-20 05:33:25 | [diff] [blame] | 562 | SpawnedTestServer wss_server(SpawnedTestServer::TYPE_WSS, ssl_options, |
| 563 | GetWebSocketTestDataDirectory()); |
| 564 | ASSERT_TRUE(wss_server.Start()); |
| 565 | InitialiseContext(); |
| 566 | // Set HSTS via wss: |
| 567 | GURL wss_url = wss_server.GetURL("set-hsts"); |
| 568 | EXPECT_TRUE(ConnectAndWait(wss_url)); |
| 569 | |
| 570 | // Verify via wss: |
| 571 | GURL ws_url = ReplaceUrlScheme(wss_server.GetURL(kEchoServer), "ws"); |
| 572 | EXPECT_TRUE(ConnectAndWait(ws_url)); |
| 573 | } |
| 574 | |
ricea | 5acb1faf7 | 2015-03-16 15:34:00 | [diff] [blame] | 575 | // Regression test for crbug.com/180504 "WebSocket handshake fails when HTTP |
| 576 | // headers have trailing LWS". |
Sergey Ulanov | 4c786d3 | 2017-09-08 22:53:25 | [diff] [blame] | 577 | TEST_F(WebSocketEndToEndTest, TrailingWhitespace) { |
ricea | 5acb1faf7 | 2015-03-16 15:34:00 | [diff] [blame] | 578 | SpawnedTestServer ws_server(SpawnedTestServer::TYPE_WS, |
ricea | 5acb1faf7 | 2015-03-16 15:34:00 | [diff] [blame] | 579 | GetWebSocketTestDataDirectory()); |
| 580 | ASSERT_TRUE(ws_server.Start()); |
| 581 | |
| 582 | GURL ws_url = ws_server.GetURL("trailing-whitespace"); |
| 583 | sub_protocols_.push_back("sip"); |
| 584 | EXPECT_TRUE(ConnectAndWait(ws_url)); |
| 585 | EXPECT_EQ("sip", event_interface_->selected_subprotocol()); |
| 586 | } |
| 587 | |
ricea | e1d6767 | 2015-03-19 10:10:17 | [diff] [blame] | 588 | // This is a regression test for crbug.com/169448 "WebSockets should support |
| 589 | // header continuations" |
| 590 | // TODO(ricea): HTTP continuation headers have been deprecated by RFC7230. If |
| 591 | // support for continuation headers is removed from Chrome, then this test will |
| 592 | // break and should be removed. |
Sergey Ulanov | 4c786d3 | 2017-09-08 22:53:25 | [diff] [blame] | 593 | TEST_F(WebSocketEndToEndTest, HeaderContinuations) { |
ricea | e1d6767 | 2015-03-19 10:10:17 | [diff] [blame] | 594 | SpawnedTestServer ws_server(SpawnedTestServer::TYPE_WS, |
ricea | e1d6767 | 2015-03-19 10:10:17 | [diff] [blame] | 595 | GetWebSocketTestDataDirectory()); |
| 596 | ASSERT_TRUE(ws_server.Start()); |
| 597 | |
| 598 | GURL ws_url = ws_server.GetURL("header-continuation"); |
| 599 | |
| 600 | EXPECT_TRUE(ConnectAndWait(ws_url)); |
| 601 | EXPECT_EQ("permessage-deflate; server_max_window_bits=10", |
| 602 | event_interface_->extensions()); |
| 603 | } |
| 604 | |
ricea | 433bdab | 2015-01-26 07:25:37 | [diff] [blame] | 605 | } // namespace |
| 606 | |
| 607 | } // namespace net |