1 // Copyright (c) 2012 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 #include "jingle/glue/network_service_async_socket.h"
6 
7 #include <stddef.h>
8 
9 #include <memory>
10 #include <string>
11 #include <utility>
12 
13 #include "base/bind.h"
14 #include "base/check_op.h"
15 #include "base/containers/circular_deque.h"
16 #include "base/memory/ptr_util.h"
17 #include "base/message_loop/message_pump_default.h"
18 #include "base/notreached.h"
19 #include "base/run_loop.h"
20 #include "base/stl_util.h"
21 #include "base/strings/strcat.h"
22 #include "base/strings/string_number_conversions.h"
23 #include "base/test/task_environment.h"
24 #include "mojo/public/cpp/bindings/pending_receiver.h"
25 #include "mojo/public/cpp/bindings/pending_remote.h"
26 #include "mojo/public/cpp/bindings/remote.h"
27 #include "mojo/public/cpp/bindings/unique_receiver_set.h"
28 #include "mojo/public/cpp/system/data_pipe_utils.h"
29 #include "net/base/address_list.h"
30 #include "net/base/host_port_pair.h"
31 #include "net/base/ip_address.h"
32 #include "net/base/net_errors.h"
33 #include "net/base/network_isolation_key.h"
34 #include "net/cert/mock_cert_verifier.h"
35 #include "net/http/transport_security_state.h"
36 #include "net/log/net_log_source.h"
37 #include "net/socket/socket_test_util.h"
38 #include "net/socket/ssl_client_socket.h"
39 #include "net/ssl/ssl_config_service.h"
40 #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
41 #include "net/url_request/url_request_test_util.h"
42 #include "services/network/proxy_resolving_socket_factory_mojo.h"
43 #include "services/network/public/mojom/proxy_resolving_socket.mojom.h"
44 #include "testing/gtest/include/gtest/gtest.h"
45 #include "third_party/webrtc/rtc_base/third_party/sigslot/sigslot.h"
46 #include "url/origin.h"
47 
48 namespace jingle_glue {
49 
50 namespace {
51 
52 // Data provider that handles reads/writes for NetworkServiceAsyncSocket.
53 class AsyncSocketDataProvider : public net::SocketDataProvider {
54  public:
AsyncSocketDataProvider()55   AsyncSocketDataProvider() : has_pending_read_(false) {}
56 
~AsyncSocketDataProvider()57   ~AsyncSocketDataProvider() override {
58     EXPECT_TRUE(writes_.empty());
59     EXPECT_TRUE(reads_.empty());
60   }
61 
62   // If there's no read, sets the "has pending read" flag.  Otherwise,
63   // pops the next read.
OnRead()64   net::MockRead OnRead() override {
65     if (reads_.empty()) {
66       DCHECK(!has_pending_read_);
67       has_pending_read_ = true;
68       const net::MockRead pending_read(net::SYNCHRONOUS, net::ERR_IO_PENDING);
69       return pending_read;
70     }
71     net::MockRead mock_read = reads_.front();
72     reads_.pop_front();
73     return mock_read;
74   }
75 
CancelPendingRead()76   void CancelPendingRead() override {
77     DCHECK(has_pending_read_);
78     has_pending_read_ = false;
79   }
80 
81   // Simply pops the next write and, if applicable, compares it to
82   // |data|.
OnWrite(const std::string & data)83   net::MockWriteResult OnWrite(const std::string& data) override {
84     DCHECK(!writes_.empty());
85     net::MockWrite mock_write = writes_.front();
86     writes_.pop_front();
87     if (mock_write.result != net::OK) {
88       return net::MockWriteResult(mock_write.mode, mock_write.result);
89     }
90     std::string expected_data(mock_write.data, mock_write.data_len);
91     EXPECT_EQ(expected_data, data);
92     if (expected_data != data) {
93       return net::MockWriteResult(net::SYNCHRONOUS, net::ERR_UNEXPECTED);
94     }
95     return net::MockWriteResult(mock_write.mode, data.size());
96   }
97 
98   // We ignore resets so we can pre-load the socket data provider with
99   // read/write events.
Reset()100   void Reset() override {}
101 
102   // If there is a pending read, completes it with the given read.
103   // Otherwise, queues up the given read.
AddRead(const net::MockRead & mock_read)104   void AddRead(const net::MockRead& mock_read) {
105     DCHECK_NE(mock_read.result, net::ERR_IO_PENDING);
106     if (has_pending_read_) {
107       has_pending_read_ = false;
108       socket()->OnReadComplete(mock_read);
109       return;
110     }
111     reads_.push_back(mock_read);
112   }
113 
114   // Simply queues up the given write.
AddWrite(const net::MockWrite & mock_write)115   void AddWrite(const net::MockWrite& mock_write) {
116     writes_.push_back(mock_write);
117   }
118 
AllReadDataConsumed() const119   bool AllReadDataConsumed() const override { return reads_.empty(); }
120 
AllWriteDataConsumed() const121   bool AllWriteDataConsumed() const override { return writes_.empty(); }
122 
123  private:
124   base::circular_deque<net::MockRead> reads_;
125   bool has_pending_read_;
126 
127   base::circular_deque<net::MockWrite> writes_;
128 
129   DISALLOW_COPY_AND_ASSIGN(AsyncSocketDataProvider);
130 };
131 
132 class MockProxyResolvingSocket : public network::mojom::ProxyResolvingSocket {
133  public:
134   enum Event {
135     // These names are from the perspective of the client, not the socket.
136     kRead,
137     kWrite,
138     kCloseReadPipe,
139     kCloseWritePipe,
140     kReadError,
141     kReadErrorInvalid,
142     kWriteError,
143     kWriteErrorInvalid,
144     kReadEofError,
145     kCloseObserverPipe,
146   };
147 
MockProxyResolvingSocket()148   MockProxyResolvingSocket() {}
~MockProxyResolvingSocket()149   ~MockProxyResolvingSocket() override {}
150 
Connect(mojo::PendingRemote<network::mojom::SocketObserver> observer,network::mojom::ProxyResolvingSocketFactory::CreateProxyResolvingSocketCallback callback)151   void Connect(mojo::PendingRemote<network::mojom::SocketObserver> observer,
152                network::mojom::ProxyResolvingSocketFactory::
153                    CreateProxyResolvingSocketCallback callback) {
154     mojo::DataPipe send_pipe;
155     mojo::DataPipe receive_pipe;
156 
157     observer_.Bind(std::move(observer));
158     receive_pipe_handle_ = std::move(receive_pipe.producer_handle);
159     send_pipe_handle_ = std::move(send_pipe.consumer_handle);
160 
161     std::move(callback).Run(net::OK, base::nullopt, base::nullopt,
162                             std::move(receive_pipe.consumer_handle),
163                             std::move(send_pipe.producer_handle));
164   }
165 
166   void RunEvents(std::vector<Event>&& events);
167 
168   // mojom::ProxyResolvingSocket implementation.
UpgradeToTLS(const net::HostPortPair & host_port_pair,const net::MutableNetworkTrafficAnnotationTag & traffic_annotation,mojo::PendingReceiver<network::mojom::TLSClientSocket> receiver,mojo::PendingRemote<network::mojom::SocketObserver> observer,network::mojom::ProxyResolvingSocket::UpgradeToTLSCallback callback)169   void UpgradeToTLS(
170       const net::HostPortPair& host_port_pair,
171       const net::MutableNetworkTrafficAnnotationTag& traffic_annotation,
172       mojo::PendingReceiver<network::mojom::TLSClientSocket> receiver,
173       mojo::PendingRemote<network::mojom::SocketObserver> observer,
174       network::mojom::ProxyResolvingSocket::UpgradeToTLSCallback callback)
175       override {
176     NOTREACHED();
177   }
178 
179  private:
180   mojo::Remote<network::mojom::SocketObserver> observer_;
181   mojo::ScopedDataPipeProducerHandle receive_pipe_handle_;
182   mojo::ScopedDataPipeConsumerHandle send_pipe_handle_;
183 
184   DISALLOW_COPY_AND_ASSIGN(MockProxyResolvingSocket);
185 };
186 
187 class MockProxyResolvingSocketFactory
188     : public network::mojom::ProxyResolvingSocketFactory {
189  public:
MockProxyResolvingSocketFactory()190   explicit MockProxyResolvingSocketFactory() : socket_raw_(nullptr) {}
~MockProxyResolvingSocketFactory()191   ~MockProxyResolvingSocketFactory() override {}
192 
193   // mojom::ProxyResolvingSocketFactory implementation.
CreateProxyResolvingSocket(const GURL & url,const net::NetworkIsolationKey & network_isolation_key,network::mojom::ProxyResolvingSocketOptionsPtr options,const net::MutableNetworkTrafficAnnotationTag & traffic_annotation,mojo::PendingReceiver<network::mojom::ProxyResolvingSocket> receiver,mojo::PendingRemote<network::mojom::SocketObserver> observer,CreateProxyResolvingSocketCallback callback)194   void CreateProxyResolvingSocket(
195       const GURL& url,
196       const net::NetworkIsolationKey& network_isolation_key,
197       network::mojom::ProxyResolvingSocketOptionsPtr options,
198       const net::MutableNetworkTrafficAnnotationTag& traffic_annotation,
199       mojo::PendingReceiver<network::mojom::ProxyResolvingSocket> receiver,
200       mojo::PendingRemote<network::mojom::SocketObserver> observer,
201       CreateProxyResolvingSocketCallback callback) override {
202     url::Origin origin = url::Origin::Create(url);
203     EXPECT_EQ(net::NetworkIsolationKey(origin /* top_frame_origin */,
204                                        origin /* frame_origin */),
205               network_isolation_key);
206     auto socket = std::make_unique<MockProxyResolvingSocket>();
207     socket_raw_ = socket.get();
208     proxy_resolving_socket_receivers_.Add(std::move(socket),
209                                           std::move(receiver));
210     socket_raw_->Connect(std::move(observer), std::move(callback));
211   }
212 
socket()213   MockProxyResolvingSocket* socket() { return socket_raw_; }
214 
215  private:
216   mojo::UniqueReceiverSet<network::mojom::ProxyResolvingSocket>
217       proxy_resolving_socket_receivers_;
218 
219   // Owned by |proxy_resolving_socket_receivers_|.
220   MockProxyResolvingSocket* socket_raw_;
221 
222   DISALLOW_COPY_AND_ASSIGN(MockProxyResolvingSocketFactory);
223 };
224 
RunEvents(std::vector<Event> && events)225 void MockProxyResolvingSocket::RunEvents(std::vector<Event>&& events) {
226   for (Event ev : events) {
227     switch (ev) {
228       case kRead:
229         mojo::BlockingCopyFromString("data", receive_pipe_handle_);
230         break;
231       case kWrite: {
232         std::string written;
233         while (true) {
234           char read_buffer[1024];
235           uint32_t read_size = sizeof(read_buffer);
236           MojoResult result = send_pipe_handle_->ReadData(
237               read_buffer, &read_size, MOJO_READ_DATA_FLAG_NONE);
238           if (result != MOJO_RESULT_OK)
239             break;
240           written.append(read_buffer, read_size);
241         }
242 
243         EXPECT_EQ("atad", written);
244         break;
245       }
246       case kCloseReadPipe:
247         receive_pipe_handle_.reset();
248         break;
249       case kCloseWritePipe:
250         send_pipe_handle_.reset();
251         break;
252       case kReadError:
253         observer_->OnReadError(net::ERR_OUT_OF_MEMORY);
254         observer_.FlushForTesting();
255         break;
256       case kReadErrorInvalid:
257         observer_->OnReadError(42);
258         observer_.FlushForTesting();
259         break;
260       case kWriteError:
261         observer_->OnWriteError(net::ERR_ACCESS_DENIED);
262         observer_.FlushForTesting();
263         break;
264       case kWriteErrorInvalid:
265         observer_->OnWriteError(net::ERR_IO_PENDING);
266         observer_.FlushForTesting();
267         break;
268       case kReadEofError:
269         observer_->OnReadError(0);
270         observer_.FlushForTesting();
271         break;
272       case kCloseObserverPipe:
273         observer_.reset();
274         break;
275     }
276     // Make sure the event is actually delivered.
277     base::RunLoop().RunUntilIdle();
278   }
279 }
280 
281 class NetworkServiceAsyncSocketTest : public testing::Test,
282                                       public sigslot::has_slots<> {
283  protected:
NetworkServiceAsyncSocketTest(bool use_mojo_level_mock=false)284   explicit NetworkServiceAsyncSocketTest(bool use_mojo_level_mock = false)
285       : ssl_socket_data_provider_(net::ASYNC, net::OK),
286         use_mojo_level_mock_(use_mojo_level_mock),
287         mock_proxy_resolving_socket_factory_(nullptr),
288         addr_({"localhost", 35}) {
289     // GTest death tests by default execute in a fork()ed but not exec()ed
290     // process. On macOS, a CoreFoundation-backed MessageLoop will exit with a
291     // __THE_PROCESS_HAS_FORKED_AND_YOU_CANNOT_USE_THIS_COREFOUNDATION_FUNCTIONALITY___YOU_MUST_EXEC__
292     // when called. Use the threadsafe mode to avoid this problem.
293     testing::GTEST_FLAG(death_test_style) = "threadsafe";
294   }
295 
~NetworkServiceAsyncSocketTest()296   ~NetworkServiceAsyncSocketTest() override {}
297 
SetUp()298   void SetUp() override {
299     mock_client_socket_factory_ =
300         std::make_unique<net::MockClientSocketFactory>();
301     mock_client_socket_factory_->set_enable_read_if_ready(true);
302     mock_client_socket_factory_->AddSocketDataProvider(
303         &async_socket_data_provider_);
304     mock_client_socket_factory_->AddSSLSocketDataProvider(
305         &ssl_socket_data_provider_);
306 
307     test_url_request_context_ =
308         std::make_unique<net::TestURLRequestContext>(true /* delay init */);
309     test_url_request_context_->set_client_socket_factory(
310         mock_client_socket_factory_.get());
311     test_url_request_context_->Init();
312 
313     if (use_mojo_level_mock_) {
314       auto mock_proxy_resolving_socket_factory =
315           std::make_unique<MockProxyResolvingSocketFactory>();
316       mock_proxy_resolving_socket_factory_ =
317           mock_proxy_resolving_socket_factory.get();
318       proxy_resolving_socket_factory_ =
319           std::move(mock_proxy_resolving_socket_factory);
320     } else {
321       mock_proxy_resolving_socket_factory_ = nullptr;
322       proxy_resolving_socket_factory_ =
323           std::make_unique<network::ProxyResolvingSocketFactoryMojo>(
324               test_url_request_context_.get());
325     }
326 
327     ns_async_socket_.reset(new NetworkServiceAsyncSocket(
328         base::BindRepeating(
329             &NetworkServiceAsyncSocketTest::BindToProxyResolvingSocketFactory,
330             base::Unretained(this)),
331         false, /* use_fake_tls_handshake */
332         14, 20, TRAFFIC_ANNOTATION_FOR_TESTS));
333 
334     ns_async_socket_->SignalConnected.connect(
335         this, &NetworkServiceAsyncSocketTest::OnConnect);
336     ns_async_socket_->SignalSSLConnected.connect(
337         this, &NetworkServiceAsyncSocketTest::OnSSLConnect);
338     ns_async_socket_->SignalClosed.connect(
339         this, &NetworkServiceAsyncSocketTest::OnClose);
340     ns_async_socket_->SignalRead.connect(
341         this, &NetworkServiceAsyncSocketTest::OnRead);
342     ns_async_socket_->SignalError.connect(
343         this, &NetworkServiceAsyncSocketTest::OnError);
344   }
345 
TearDown()346   void TearDown() override {
347     // Run any tasks that we forgot to pump.
348     base::RunLoop().RunUntilIdle();
349     ExpectClosed();
350     ExpectNoSignal();
351     ns_async_socket_.reset();
352   }
353 
BindToProxyResolvingSocketFactory(mojo::PendingReceiver<network::mojom::ProxyResolvingSocketFactory> receiver)354   void BindToProxyResolvingSocketFactory(
355       mojo::PendingReceiver<network::mojom::ProxyResolvingSocketFactory>
356           receiver) {
357     proxy_resolving_socket_factory_receiver_ = std::make_unique<
358         mojo::Receiver<network::mojom::ProxyResolvingSocketFactory>>(
359         proxy_resolving_socket_factory_.get());
360     proxy_resolving_socket_factory_receiver_->Bind(std::move(receiver));
361   }
362 
363   enum Signal {
364     SIGNAL_CONNECT,
365     SIGNAL_SSL_CONNECT,
366     SIGNAL_CLOSE,
367     SIGNAL_READ,
368     SIGNAL_ERROR,
369   };
370 
371   // Helper struct that records the state at the time of a signal.
372 
373   struct SignalSocketState {
SignalSocketStatejingle_glue::__anon811b799b0111::NetworkServiceAsyncSocketTest::SignalSocketState374     SignalSocketState()
375         : signal(SIGNAL_ERROR),
376           state(NetworkServiceAsyncSocket::STATE_CLOSED),
377           error(NetworkServiceAsyncSocket::ERROR_NONE),
378           net_error(net::OK) {}
379 
SignalSocketStatejingle_glue::__anon811b799b0111::NetworkServiceAsyncSocketTest::SignalSocketState380     SignalSocketState(Signal signal,
381                       NetworkServiceAsyncSocket::State state,
382                       NetworkServiceAsyncSocket::Error error,
383                       net::Error net_error)
384         : signal(signal), state(state), error(error), net_error(net_error) {}
385 
IsEqualjingle_glue::__anon811b799b0111::NetworkServiceAsyncSocketTest::SignalSocketState386     bool IsEqual(const SignalSocketState& other) const {
387       return (signal == other.signal) && (state == other.state) &&
388              (error == other.error) && (net_error == other.net_error);
389     }
390 
FromAsyncSocketjingle_glue::__anon811b799b0111::NetworkServiceAsyncSocketTest::SignalSocketState391     static SignalSocketState FromAsyncSocket(Signal signal,
392                                              jingle_xmpp::AsyncSocket* async_socket) {
393       return SignalSocketState(
394           signal, async_socket->state(), async_socket->error(),
395           static_cast<net::Error>(async_socket->GetError()));
396     }
397 
NoErrorjingle_glue::__anon811b799b0111::NetworkServiceAsyncSocketTest::SignalSocketState398     static SignalSocketState NoError(Signal signal,
399                                      jingle_xmpp::AsyncSocket::State state) {
400       return SignalSocketState(signal, state, jingle_xmpp::AsyncSocket::ERROR_NONE,
401                                net::OK);
402     }
403 
ToStringjingle_glue::__anon811b799b0111::NetworkServiceAsyncSocketTest::SignalSocketState404     std::string ToString() const {
405       return base::StrCat({"(", base::NumberToString(signal), ",",
406                            base::NumberToString(state), ",",
407                            base::NumberToString(error), ",",
408                            base::NumberToString(net_error), ")"});
409     }
410 
411     Signal signal;
412     NetworkServiceAsyncSocket::State state;
413     NetworkServiceAsyncSocket::Error error;
414     net::Error net_error;
415   };
416 
CaptureSocketState(Signal signal)417   void CaptureSocketState(Signal signal) {
418     signal_socket_states_.push_back(
419         SignalSocketState::FromAsyncSocket(signal, ns_async_socket_.get()));
420   }
421 
OnConnect()422   void OnConnect() { CaptureSocketState(SIGNAL_CONNECT); }
423 
OnSSLConnect()424   void OnSSLConnect() { CaptureSocketState(SIGNAL_SSL_CONNECT); }
425 
OnClose()426   void OnClose() { CaptureSocketState(SIGNAL_CLOSE); }
427 
OnRead()428   void OnRead() { CaptureSocketState(SIGNAL_READ); }
429 
OnError()430   void OnError() { ADD_FAILURE(); }
431 
432   // State expect functions.
433 
ExpectState(NetworkServiceAsyncSocket::State state,NetworkServiceAsyncSocket::Error error,net::Error net_error)434   void ExpectState(NetworkServiceAsyncSocket::State state,
435                    NetworkServiceAsyncSocket::Error error,
436                    net::Error net_error) {
437     EXPECT_EQ(state, ns_async_socket_->state());
438     EXPECT_EQ(error, ns_async_socket_->error());
439     EXPECT_EQ(net_error, ns_async_socket_->GetError());
440   }
441 
ExpectNonErrorState(NetworkServiceAsyncSocket::State state)442   void ExpectNonErrorState(NetworkServiceAsyncSocket::State state) {
443     ExpectState(state, NetworkServiceAsyncSocket::ERROR_NONE, net::OK);
444   }
445 
ExpectErrorState(NetworkServiceAsyncSocket::State state,NetworkServiceAsyncSocket::Error error)446   void ExpectErrorState(NetworkServiceAsyncSocket::State state,
447                         NetworkServiceAsyncSocket::Error error) {
448     ExpectState(state, error, net::OK);
449   }
450 
ExpectClosed()451   void ExpectClosed() {
452     ExpectNonErrorState(NetworkServiceAsyncSocket::STATE_CLOSED);
453   }
454 
455   // Signal expect functions.
456 
ExpectNoSignal()457   void ExpectNoSignal() {
458     if (!signal_socket_states_.empty()) {
459       ADD_FAILURE() << signal_socket_states_.front().signal;
460     }
461   }
462 
ExpectSignalSocketState(SignalSocketState expected_signal_socket_state)463   void ExpectSignalSocketState(SignalSocketState expected_signal_socket_state) {
464     if (signal_socket_states_.empty()) {
465       ADD_FAILURE() << expected_signal_socket_state.signal;
466       return;
467     }
468     EXPECT_TRUE(
469         expected_signal_socket_state.IsEqual(signal_socket_states_.front()))
470         << "Expected signal:" << expected_signal_socket_state.ToString()
471         << " actual signal: " << signal_socket_states_.front().ToString();
472     signal_socket_states_.pop_front();
473   }
474 
ExpectReadSignal()475   void ExpectReadSignal() {
476     ExpectSignalSocketState(SignalSocketState::NoError(
477         SIGNAL_READ, NetworkServiceAsyncSocket::STATE_OPEN));
478   }
479 
ExpectSSLConnectSignal()480   void ExpectSSLConnectSignal() {
481     ExpectSignalSocketState(SignalSocketState::NoError(
482         SIGNAL_SSL_CONNECT, NetworkServiceAsyncSocket::STATE_TLS_OPEN));
483   }
484 
ExpectSSLReadSignal()485   void ExpectSSLReadSignal() {
486     ExpectSignalSocketState(SignalSocketState::NoError(
487         SIGNAL_READ, NetworkServiceAsyncSocket::STATE_TLS_OPEN));
488   }
489 
490   // Open/close utility functions.
491 
DoOpenClosed()492   void DoOpenClosed() {
493     ExpectClosed();
494     async_socket_data_provider_.set_connect_data(
495         net::MockConnect(net::SYNCHRONOUS, net::OK));
496     EXPECT_TRUE(ns_async_socket_->Connect(addr_));
497     ExpectNonErrorState(NetworkServiceAsyncSocket::STATE_CONNECTING);
498 
499     base::RunLoop().RunUntilIdle();
500     // We may not necessarily be open; may have been other events
501     // queued up.
502     ExpectSignalSocketState(SignalSocketState::NoError(
503         SIGNAL_CONNECT, NetworkServiceAsyncSocket::STATE_OPEN));
504   }
505 
DoCloseOpened(SignalSocketState expected_signal_socket_state)506   void DoCloseOpened(SignalSocketState expected_signal_socket_state) {
507     // We may be in an error state, so just compare state().
508     EXPECT_EQ(NetworkServiceAsyncSocket::STATE_OPEN, ns_async_socket_->state());
509     EXPECT_TRUE(ns_async_socket_->Close());
510     ExpectSignalSocketState(expected_signal_socket_state);
511     ExpectNonErrorState(NetworkServiceAsyncSocket::STATE_CLOSED);
512   }
513 
DoCloseOpenedNoError()514   void DoCloseOpenedNoError() {
515     DoCloseOpened(SignalSocketState::NoError(
516         SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED));
517   }
518 
DoSSLOpenClosed()519   void DoSSLOpenClosed() {
520     const char kDummyData[] = "dummy_data";
521     async_socket_data_provider_.AddRead(net::MockRead(kDummyData));
522     DoOpenClosed();
523     ExpectReadSignal();
524     EXPECT_EQ(kDummyData, DrainRead(1));
525 
526     EXPECT_TRUE(ns_async_socket_->StartTls("fakedomain.com"));
527     base::RunLoop().RunUntilIdle();
528     ExpectSSLConnectSignal();
529     ExpectNoSignal();
530     ExpectNonErrorState(NetworkServiceAsyncSocket::STATE_TLS_OPEN);
531   }
532 
DoSSLCloseOpened(SignalSocketState expected_signal_socket_state)533   void DoSSLCloseOpened(SignalSocketState expected_signal_socket_state) {
534     // We may be in an error state, so just compare state().
535     EXPECT_EQ(NetworkServiceAsyncSocket::STATE_TLS_OPEN,
536               ns_async_socket_->state());
537     EXPECT_TRUE(ns_async_socket_->Close());
538     ExpectSignalSocketState(expected_signal_socket_state);
539     ExpectNonErrorState(NetworkServiceAsyncSocket::STATE_CLOSED);
540   }
541 
DoSSLCloseOpenedNoError()542   void DoSSLCloseOpenedNoError() {
543     DoSSLCloseOpened(SignalSocketState::NoError(
544         SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED));
545   }
546 
547   // Read utility functions.
548 
DrainRead(size_t buf_size)549   std::string DrainRead(size_t buf_size) {
550     std::string read;
551     std::unique_ptr<char[]> buf(new char[buf_size]);
552     size_t len_read;
553     while (true) {
554       bool success = ns_async_socket_->Read(buf.get(), buf_size, &len_read);
555       if (!success) {
556         ADD_FAILURE();
557         break;
558       }
559       if (len_read == 0U) {
560         break;
561       }
562       read.append(buf.get(), len_read);
563     }
564     return read;
565   }
566 
567   // Need a message loop for both the socket and Mojo.
568   base::test::SingleThreadTaskEnvironment task_environment_;
569 
570   AsyncSocketDataProvider async_socket_data_provider_;
571   net::SSLSocketDataProvider ssl_socket_data_provider_;
572 
573   bool use_mojo_level_mock_;
574 
575   std::unique_ptr<net::MockClientSocketFactory> mock_client_socket_factory_;
576   std::unique_ptr<net::TestURLRequestContext> test_url_request_context_;
577   // Either null or owned by proxy_resolving_socket_factory_.
578   MockProxyResolvingSocketFactory* mock_proxy_resolving_socket_factory_;
579   std::unique_ptr<network::mojom::ProxyResolvingSocketFactory>
580       proxy_resolving_socket_factory_;
581   std::unique_ptr<mojo::Receiver<network::mojom::ProxyResolvingSocketFactory>>
582       proxy_resolving_socket_factory_receiver_;
583 
584   std::unique_ptr<NetworkServiceAsyncSocket> ns_async_socket_;
585   base::circular_deque<SignalSocketState> signal_socket_states_;
586   const net::HostPortPair addr_;
587 
588  private:
589   DISALLOW_COPY_AND_ASSIGN(NetworkServiceAsyncSocketTest);
590 };
591 
TEST_F(NetworkServiceAsyncSocketTest,InitialState)592 TEST_F(NetworkServiceAsyncSocketTest, InitialState) {
593   ExpectClosed();
594   ExpectNoSignal();
595 }
596 
TEST_F(NetworkServiceAsyncSocketTest,EmptyClose)597 TEST_F(NetworkServiceAsyncSocketTest, EmptyClose) {
598   ExpectClosed();
599   EXPECT_TRUE(ns_async_socket_->Close());
600   ExpectClosed();
601 }
602 
TEST_F(NetworkServiceAsyncSocketTest,ImmediateConnectAndClose)603 TEST_F(NetworkServiceAsyncSocketTest, ImmediateConnectAndClose) {
604   DoOpenClosed();
605 
606   ExpectNonErrorState(NetworkServiceAsyncSocket::STATE_OPEN);
607 
608   DoCloseOpenedNoError();
609 }
610 
611 // After this, no need to test immediate successful connect and
612 // Close() so thoroughly.
613 
TEST_F(NetworkServiceAsyncSocketTest,DoubleClose)614 TEST_F(NetworkServiceAsyncSocketTest, DoubleClose) {
615   DoOpenClosed();
616 
617   EXPECT_TRUE(ns_async_socket_->Close());
618   ExpectClosed();
619   ExpectSignalSocketState(SignalSocketState::NoError(
620       SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED));
621 
622   EXPECT_TRUE(ns_async_socket_->Close());
623   ExpectClosed();
624 }
625 
TEST_F(NetworkServiceAsyncSocketTest,ZeroPortConnect)626 TEST_F(NetworkServiceAsyncSocketTest, ZeroPortConnect) {
627   const net::HostPortPair zero_port_addr({addr_.host(), 0});
628   EXPECT_FALSE(ns_async_socket_->Connect(zero_port_addr));
629   ExpectErrorState(NetworkServiceAsyncSocket::STATE_CLOSED,
630                    NetworkServiceAsyncSocket::ERROR_DNS);
631 
632   EXPECT_TRUE(ns_async_socket_->Close());
633   ExpectClosed();
634 }
635 
TEST_F(NetworkServiceAsyncSocketTest,DoubleConnect)636 TEST_F(NetworkServiceAsyncSocketTest, DoubleConnect) {
637   EXPECT_DEBUG_DEATH(
638       {
639         DoOpenClosed();
640 
641         EXPECT_FALSE(ns_async_socket_->Connect(addr_));
642         ExpectErrorState(NetworkServiceAsyncSocket::STATE_OPEN,
643                          NetworkServiceAsyncSocket::ERROR_WRONGSTATE);
644 
645         DoCloseOpened(SignalSocketState(
646             SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
647             NetworkServiceAsyncSocket::ERROR_WRONGSTATE, net::OK));
648       },
649       "non-closed socket");
650 }
651 
TEST_F(NetworkServiceAsyncSocketTest,ImmediateConnectCloseBeforeRead)652 TEST_F(NetworkServiceAsyncSocketTest, ImmediateConnectCloseBeforeRead) {
653   DoOpenClosed();
654 
655   EXPECT_TRUE(ns_async_socket_->Close());
656   ExpectClosed();
657   ExpectSignalSocketState(SignalSocketState::NoError(
658       SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED));
659 
660   base::RunLoop().RunUntilIdle();
661 }
662 
TEST_F(NetworkServiceAsyncSocketTest,HangingConnect)663 TEST_F(NetworkServiceAsyncSocketTest, HangingConnect) {
664   EXPECT_TRUE(ns_async_socket_->Connect(addr_));
665   ExpectNonErrorState(NetworkServiceAsyncSocket::STATE_CONNECTING);
666   ExpectNoSignal();
667 
668   EXPECT_TRUE(ns_async_socket_->Close());
669   ExpectClosed();
670   ExpectSignalSocketState(SignalSocketState::NoError(
671       SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED));
672 }
673 
TEST_F(NetworkServiceAsyncSocketTest,PendingConnect)674 TEST_F(NetworkServiceAsyncSocketTest, PendingConnect) {
675   async_socket_data_provider_.set_connect_data(
676       net::MockConnect(net::ASYNC, net::OK));
677   EXPECT_TRUE(ns_async_socket_->Connect(addr_));
678   ExpectNonErrorState(NetworkServiceAsyncSocket::STATE_CONNECTING);
679   ExpectNoSignal();
680 
681   base::RunLoop().RunUntilIdle();
682   ExpectNonErrorState(NetworkServiceAsyncSocket::STATE_OPEN);
683   ExpectSignalSocketState(SignalSocketState::NoError(
684       SIGNAL_CONNECT, NetworkServiceAsyncSocket::STATE_OPEN));
685   ExpectNoSignal();
686 
687   base::RunLoop().RunUntilIdle();
688 
689   DoCloseOpenedNoError();
690 }
691 
692 // After this no need to test successful pending connect so
693 // thoroughly.
694 
TEST_F(NetworkServiceAsyncSocketTest,PendingConnectCloseBeforeRead)695 TEST_F(NetworkServiceAsyncSocketTest, PendingConnectCloseBeforeRead) {
696   async_socket_data_provider_.set_connect_data(
697       net::MockConnect(net::ASYNC, net::OK));
698   EXPECT_TRUE(ns_async_socket_->Connect(addr_));
699 
700   base::RunLoop().RunUntilIdle();
701   ExpectSignalSocketState(SignalSocketState::NoError(
702       SIGNAL_CONNECT, NetworkServiceAsyncSocket::STATE_OPEN));
703 
704   DoCloseOpenedNoError();
705 
706   base::RunLoop().RunUntilIdle();
707 }
708 
TEST_F(NetworkServiceAsyncSocketTest,PendingConnectError)709 TEST_F(NetworkServiceAsyncSocketTest, PendingConnectError) {
710   async_socket_data_provider_.set_connect_data(
711       net::MockConnect(net::ASYNC, net::ERR_TIMED_OUT));
712   EXPECT_TRUE(ns_async_socket_->Connect(addr_));
713 
714   base::RunLoop().RunUntilIdle();
715 
716   ExpectSignalSocketState(SignalSocketState(
717       SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
718       NetworkServiceAsyncSocket::ERROR_WINSOCK, net::ERR_TIMED_OUT));
719 }
720 
721 // After this we can assume Connect() and Close() work as expected.
722 
TEST_F(NetworkServiceAsyncSocketTest,EmptyRead)723 TEST_F(NetworkServiceAsyncSocketTest, EmptyRead) {
724   DoOpenClosed();
725 
726   char buf[4096];
727   size_t len_read = 10000U;
728   EXPECT_TRUE(ns_async_socket_->Read(buf, sizeof(buf), &len_read));
729   EXPECT_EQ(0U, len_read);
730 
731   DoCloseOpenedNoError();
732 }
733 
TEST_F(NetworkServiceAsyncSocketTest,WrongRead)734 TEST_F(NetworkServiceAsyncSocketTest, WrongRead) {
735   EXPECT_DEBUG_DEATH(
736       {
737         async_socket_data_provider_.set_connect_data(
738             net::MockConnect(net::ASYNC, net::OK));
739         EXPECT_TRUE(ns_async_socket_->Connect(addr_));
740         ExpectNonErrorState(NetworkServiceAsyncSocket::STATE_CONNECTING);
741         ExpectNoSignal();
742 
743         char buf[4096];
744         size_t len_read;
745         EXPECT_FALSE(ns_async_socket_->Read(buf, sizeof(buf), &len_read));
746         ExpectErrorState(NetworkServiceAsyncSocket::STATE_CONNECTING,
747                          NetworkServiceAsyncSocket::ERROR_WRONGSTATE);
748         EXPECT_TRUE(ns_async_socket_->Close());
749         ExpectSignalSocketState(SignalSocketState(
750             SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
751             NetworkServiceAsyncSocket::ERROR_WRONGSTATE, net::OK));
752       },
753       "non-open");
754 }
755 
TEST_F(NetworkServiceAsyncSocketTest,WrongReadClosed)756 TEST_F(NetworkServiceAsyncSocketTest, WrongReadClosed) {
757   char buf[4096];
758   size_t len_read;
759   EXPECT_FALSE(ns_async_socket_->Read(buf, sizeof(buf), &len_read));
760   ExpectErrorState(NetworkServiceAsyncSocket::STATE_CLOSED,
761                    NetworkServiceAsyncSocket::ERROR_WRONGSTATE);
762   EXPECT_TRUE(ns_async_socket_->Close());
763 }
764 
765 const char kReadData[] = "mydatatoread";
766 
TEST_F(NetworkServiceAsyncSocketTest,Read)767 TEST_F(NetworkServiceAsyncSocketTest, Read) {
768   async_socket_data_provider_.AddRead(net::MockRead(kReadData));
769   DoOpenClosed();
770 
771   ExpectReadSignal();
772   ExpectNoSignal();
773 
774   EXPECT_EQ(kReadData, DrainRead(1));
775 
776   base::RunLoop().RunUntilIdle();
777 
778   DoCloseOpenedNoError();
779 }
780 
TEST_F(NetworkServiceAsyncSocketTest,ReadTwice)781 TEST_F(NetworkServiceAsyncSocketTest, ReadTwice) {
782   async_socket_data_provider_.AddRead(net::MockRead(kReadData));
783   DoOpenClosed();
784 
785   ExpectReadSignal();
786   ExpectNoSignal();
787 
788   EXPECT_EQ(kReadData, DrainRead(1));
789 
790   base::RunLoop().RunUntilIdle();
791 
792   const char kReadData2[] = "mydatatoread2";
793   async_socket_data_provider_.AddRead(net::MockRead(kReadData2));
794   base::RunLoop().RunUntilIdle();
795 
796   ExpectReadSignal();
797   ExpectNoSignal();
798 
799   EXPECT_EQ(kReadData2, DrainRead(1));
800 
801   DoCloseOpenedNoError();
802 }
803 
TEST_F(NetworkServiceAsyncSocketTest,ReadError)804 TEST_F(NetworkServiceAsyncSocketTest, ReadError) {
805   async_socket_data_provider_.AddRead(net::MockRead(kReadData));
806   DoOpenClosed();
807 
808   ExpectReadSignal();
809   ExpectNoSignal();
810 
811   EXPECT_EQ(kReadData, DrainRead(1));
812 
813   base::RunLoop().RunUntilIdle();
814 
815   async_socket_data_provider_.AddRead(
816       net::MockRead(net::SYNCHRONOUS, net::ERR_TIMED_OUT));
817   base::RunLoop().RunUntilIdle();
818 
819   ExpectSignalSocketState(SignalSocketState(
820       SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
821       NetworkServiceAsyncSocket::ERROR_WINSOCK, net::ERR_TIMED_OUT));
822 }
823 
TEST_F(NetworkServiceAsyncSocketTest,ReadEOF)824 TEST_F(NetworkServiceAsyncSocketTest, ReadEOF) {
825   async_socket_data_provider_.AddRead(net::MockRead(kReadData));
826   DoOpenClosed();
827 
828   ExpectReadSignal();
829   ExpectNoSignal();
830 
831   EXPECT_EQ(kReadData, DrainRead(1));
832 
833   base::RunLoop().RunUntilIdle();
834 
835   async_socket_data_provider_.AddRead(net::MockRead(net::SYNCHRONOUS, net::OK));
836   base::RunLoop().RunUntilIdle();
837   ExpectSignalSocketState(SignalSocketState::NoError(
838       SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED));
839 }
840 
TEST_F(NetworkServiceAsyncSocketTest,ReadEmpty)841 TEST_F(NetworkServiceAsyncSocketTest, ReadEmpty) {
842   async_socket_data_provider_.AddRead(net::MockRead(""));
843   DoOpenClosed();
844 
845   ExpectSignalSocketState(SignalSocketState::NoError(
846       SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED));
847 }
848 
TEST_F(NetworkServiceAsyncSocketTest,PendingRead)849 TEST_F(NetworkServiceAsyncSocketTest, PendingRead) {
850   DoOpenClosed();
851 
852   ExpectNoSignal();
853 
854   async_socket_data_provider_.AddRead(net::MockRead(kReadData));
855   base::RunLoop().RunUntilIdle();
856 
857   ExpectSignalSocketState(SignalSocketState::NoError(
858       SIGNAL_READ, NetworkServiceAsyncSocket::STATE_OPEN));
859   ExpectNoSignal();
860 
861   EXPECT_EQ(kReadData, DrainRead(1));
862 
863   base::RunLoop().RunUntilIdle();
864 
865   DoCloseOpenedNoError();
866 }
867 
TEST_F(NetworkServiceAsyncSocketTest,PendingEmptyRead)868 TEST_F(NetworkServiceAsyncSocketTest, PendingEmptyRead) {
869   DoOpenClosed();
870 
871   ExpectNoSignal();
872 
873   async_socket_data_provider_.AddRead(net::MockRead(""));
874   base::RunLoop().RunUntilIdle();
875 
876   ExpectSignalSocketState(SignalSocketState::NoError(
877       SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED));
878 }
879 
TEST_F(NetworkServiceAsyncSocketTest,PendingReadError)880 TEST_F(NetworkServiceAsyncSocketTest, PendingReadError) {
881   DoOpenClosed();
882 
883   ExpectNoSignal();
884 
885   async_socket_data_provider_.AddRead(
886       net::MockRead(net::ASYNC, net::ERR_TIMED_OUT));
887   base::RunLoop().RunUntilIdle();
888 
889   ExpectSignalSocketState(SignalSocketState(
890       SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
891       NetworkServiceAsyncSocket::ERROR_WINSOCK, net::ERR_TIMED_OUT));
892 }
893 
894 // After this we can assume non-SSL Read() works as expected.
895 
TEST_F(NetworkServiceAsyncSocketTest,WrongWrite)896 TEST_F(NetworkServiceAsyncSocketTest, WrongWrite) {
897   EXPECT_DEBUG_DEATH(
898       {
899         std::string data("foo");
900         EXPECT_FALSE(ns_async_socket_->Write(data.data(), data.size()));
901         ExpectErrorState(NetworkServiceAsyncSocket::STATE_CLOSED,
902                          NetworkServiceAsyncSocket::ERROR_WRONGSTATE);
903         EXPECT_TRUE(ns_async_socket_->Close());
904       },
905       "non-open");
906 }
907 
908 const char kWriteData[] = "mydatatowrite";
909 
TEST_F(NetworkServiceAsyncSocketTest,SyncWrite)910 TEST_F(NetworkServiceAsyncSocketTest, SyncWrite) {
911   async_socket_data_provider_.AddWrite(
912       net::MockWrite(net::SYNCHRONOUS, kWriteData, 3));
913   async_socket_data_provider_.AddWrite(
914       net::MockWrite(net::SYNCHRONOUS, kWriteData + 3, 5));
915   async_socket_data_provider_.AddWrite(net::MockWrite(
916       net::SYNCHRONOUS, kWriteData + 8, base::size(kWriteData) - 8));
917   DoOpenClosed();
918 
919   EXPECT_TRUE(ns_async_socket_->Write(kWriteData, 3));
920   base::RunLoop().RunUntilIdle();
921   EXPECT_TRUE(ns_async_socket_->Write(kWriteData + 3, 5));
922   base::RunLoop().RunUntilIdle();
923   EXPECT_TRUE(
924       ns_async_socket_->Write(kWriteData + 8, base::size(kWriteData) - 8));
925   base::RunLoop().RunUntilIdle();
926 
927   ExpectNoSignal();
928 
929   DoCloseOpenedNoError();
930 }
931 
TEST_F(NetworkServiceAsyncSocketTest,AsyncWrite)932 TEST_F(NetworkServiceAsyncSocketTest, AsyncWrite) {
933   DoOpenClosed();
934 
935   async_socket_data_provider_.AddWrite(
936       net::MockWrite(net::ASYNC, kWriteData, 3));
937   async_socket_data_provider_.AddWrite(
938       net::MockWrite(net::ASYNC, kWriteData + 3, 5));
939   async_socket_data_provider_.AddWrite(
940       net::MockWrite(net::ASYNC, kWriteData + 8, base::size(kWriteData) - 8));
941 
942   EXPECT_TRUE(ns_async_socket_->Write(kWriteData, 3));
943   base::RunLoop().RunUntilIdle();
944   EXPECT_TRUE(ns_async_socket_->Write(kWriteData + 3, 5));
945   base::RunLoop().RunUntilIdle();
946   EXPECT_TRUE(
947       ns_async_socket_->Write(kWriteData + 8, base::size(kWriteData) - 8));
948   base::RunLoop().RunUntilIdle();
949 
950   ExpectNoSignal();
951 
952   DoCloseOpenedNoError();
953 }
954 
TEST_F(NetworkServiceAsyncSocketTest,AsyncWriteError)955 TEST_F(NetworkServiceAsyncSocketTest, AsyncWriteError) {
956   DoOpenClosed();
957 
958   async_socket_data_provider_.AddWrite(
959       net::MockWrite(net::ASYNC, kWriteData, 3));
960   async_socket_data_provider_.AddWrite(
961       net::MockWrite(net::ASYNC, kWriteData + 3, 5));
962   async_socket_data_provider_.AddWrite(
963       net::MockWrite(net::ASYNC, net::ERR_TIMED_OUT));
964 
965   EXPECT_TRUE(ns_async_socket_->Write(kWriteData, 3));
966   base::RunLoop().RunUntilIdle();
967   EXPECT_TRUE(ns_async_socket_->Write(kWriteData + 3, 5));
968   base::RunLoop().RunUntilIdle();
969   EXPECT_TRUE(
970       ns_async_socket_->Write(kWriteData + 8, base::size(kWriteData) - 8));
971   base::RunLoop().RunUntilIdle();
972 
973   ExpectSignalSocketState(SignalSocketState(
974       SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
975       NetworkServiceAsyncSocket::ERROR_WINSOCK, net::ERR_TIMED_OUT));
976 }
977 
TEST_F(NetworkServiceAsyncSocketTest,LargeWrite)978 TEST_F(NetworkServiceAsyncSocketTest, LargeWrite) {
979   EXPECT_DEBUG_DEATH(
980       {
981         DoOpenClosed();
982 
983         std::string large_data(100, 'x');
984         EXPECT_FALSE(
985             ns_async_socket_->Write(large_data.data(), large_data.size()));
986         ExpectState(NetworkServiceAsyncSocket::STATE_OPEN,
987                     NetworkServiceAsyncSocket::ERROR_WINSOCK,
988                     net::ERR_INSUFFICIENT_RESOURCES);
989         DoCloseOpened(SignalSocketState(
990             SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
991             NetworkServiceAsyncSocket::ERROR_WINSOCK,
992             net::ERR_INSUFFICIENT_RESOURCES));
993       },
994       "exceed the max write buffer");
995 }
996 
TEST_F(NetworkServiceAsyncSocketTest,LargeAccumulatedWrite)997 TEST_F(NetworkServiceAsyncSocketTest, LargeAccumulatedWrite) {
998   EXPECT_DEBUG_DEATH(
999       {
1000         DoOpenClosed();
1001 
1002         std::string data(15, 'x');
1003         EXPECT_TRUE(ns_async_socket_->Write(data.data(), data.size()));
1004         EXPECT_FALSE(ns_async_socket_->Write(data.data(), data.size()));
1005         ExpectState(NetworkServiceAsyncSocket::STATE_OPEN,
1006                     NetworkServiceAsyncSocket::ERROR_WINSOCK,
1007                     net::ERR_INSUFFICIENT_RESOURCES);
1008         DoCloseOpened(SignalSocketState(
1009             SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
1010             NetworkServiceAsyncSocket::ERROR_WINSOCK,
1011             net::ERR_INSUFFICIENT_RESOURCES));
1012       },
1013       "exceed the max write buffer");
1014 }
1015 
1016 // After this we can assume non-SSL I/O works as expected.
1017 
TEST_F(NetworkServiceAsyncSocketTest,HangingSSLConnect)1018 TEST_F(NetworkServiceAsyncSocketTest, HangingSSLConnect) {
1019   async_socket_data_provider_.AddRead(net::MockRead(kReadData));
1020   DoOpenClosed();
1021   ExpectReadSignal();
1022 
1023   EXPECT_TRUE(ns_async_socket_->StartTls("fakedomain.com"));
1024   ExpectNoSignal();
1025 
1026   ExpectNonErrorState(NetworkServiceAsyncSocket::STATE_TLS_CONNECTING);
1027   EXPECT_TRUE(ns_async_socket_->Close());
1028   ExpectSignalSocketState(SignalSocketState::NoError(
1029       SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED));
1030   ExpectNonErrorState(NetworkServiceAsyncSocket::STATE_CLOSED);
1031 }
1032 
TEST_F(NetworkServiceAsyncSocketTest,ImmediateSSLConnect)1033 TEST_F(NetworkServiceAsyncSocketTest, ImmediateSSLConnect) {
1034   async_socket_data_provider_.AddRead(net::MockRead(kReadData));
1035   DoOpenClosed();
1036   ExpectReadSignal();
1037 
1038   EXPECT_TRUE(ns_async_socket_->StartTls("fakedomain.com"));
1039   base::RunLoop().RunUntilIdle();
1040   ExpectSSLConnectSignal();
1041   ExpectNoSignal();
1042   ExpectNonErrorState(NetworkServiceAsyncSocket::STATE_TLS_OPEN);
1043 
1044   DoSSLCloseOpenedNoError();
1045 }
1046 
TEST_F(NetworkServiceAsyncSocketTest,DoubleSSLConnect)1047 TEST_F(NetworkServiceAsyncSocketTest, DoubleSSLConnect) {
1048   EXPECT_DEBUG_DEATH(
1049       {
1050         async_socket_data_provider_.AddRead(net::MockRead(kReadData));
1051         DoOpenClosed();
1052         ExpectReadSignal();
1053 
1054         EXPECT_TRUE(ns_async_socket_->StartTls("fakedomain.com"));
1055         base::RunLoop().RunUntilIdle();
1056         ExpectSSLConnectSignal();
1057         ExpectNoSignal();
1058         ExpectNonErrorState(NetworkServiceAsyncSocket::STATE_TLS_OPEN);
1059 
1060         EXPECT_FALSE(ns_async_socket_->StartTls("fakedomain.com"));
1061 
1062         DoSSLCloseOpened(SignalSocketState(
1063             SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
1064             NetworkServiceAsyncSocket::ERROR_WRONGSTATE, net::OK));
1065       },
1066       "wrong state");
1067 }
1068 
TEST_F(NetworkServiceAsyncSocketTest,FailedSSLConnect)1069 TEST_F(NetworkServiceAsyncSocketTest, FailedSSLConnect) {
1070   ssl_socket_data_provider_.connect =
1071       net::MockConnect(net::ASYNC, net::ERR_CERT_COMMON_NAME_INVALID),
1072 
1073   async_socket_data_provider_.AddRead(net::MockRead(kReadData));
1074   DoOpenClosed();
1075   ExpectReadSignal();
1076 
1077   EXPECT_TRUE(ns_async_socket_->StartTls("fakedomain.com"));
1078   base::RunLoop().RunUntilIdle();
1079   ExpectSignalSocketState(
1080       SignalSocketState(SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
1081                         NetworkServiceAsyncSocket::ERROR_WINSOCK,
1082                         net::ERR_CERT_COMMON_NAME_INVALID));
1083 
1084   EXPECT_TRUE(ns_async_socket_->Close());
1085   ExpectClosed();
1086 }
1087 
TEST_F(NetworkServiceAsyncSocketTest,ReadDuringSSLConnecting)1088 TEST_F(NetworkServiceAsyncSocketTest, ReadDuringSSLConnecting) {
1089   async_socket_data_provider_.AddRead(net::MockRead(kReadData));
1090   DoOpenClosed();
1091   ExpectReadSignal();
1092   EXPECT_EQ(kReadData, DrainRead(1));
1093 
1094   EXPECT_TRUE(ns_async_socket_->StartTls("fakedomain.com"));
1095   ExpectNoSignal();
1096 
1097   // Shouldn't do anything.
1098   async_socket_data_provider_.AddRead(net::MockRead(kReadData));
1099 
1100   char buf[4096];
1101   size_t len_read = 10000U;
1102   EXPECT_TRUE(ns_async_socket_->Read(buf, sizeof(buf), &len_read));
1103   EXPECT_EQ(0U, len_read);
1104 
1105   base::RunLoop().RunUntilIdle();
1106   ExpectSSLConnectSignal();
1107   ExpectSSLReadSignal();
1108   ExpectNoSignal();
1109   ExpectNonErrorState(NetworkServiceAsyncSocket::STATE_TLS_OPEN);
1110 
1111   len_read = 10000U;
1112   EXPECT_TRUE(ns_async_socket_->Read(buf, sizeof(buf), &len_read));
1113   EXPECT_EQ(kReadData, std::string(buf, len_read));
1114 
1115   DoSSLCloseOpenedNoError();
1116 }
1117 
TEST_F(NetworkServiceAsyncSocketTest,WriteDuringSSLConnecting)1118 TEST_F(NetworkServiceAsyncSocketTest, WriteDuringSSLConnecting) {
1119   async_socket_data_provider_.AddRead(net::MockRead(kReadData));
1120   DoOpenClosed();
1121   ExpectReadSignal();
1122 
1123   EXPECT_TRUE(ns_async_socket_->StartTls("fakedomain.com"));
1124   ExpectNoSignal();
1125   ExpectNonErrorState(NetworkServiceAsyncSocket::STATE_TLS_CONNECTING);
1126 
1127   async_socket_data_provider_.AddWrite(
1128       net::MockWrite(net::ASYNC, kWriteData, 3));
1129 
1130   // Shouldn't do anything.
1131   EXPECT_TRUE(ns_async_socket_->Write(kWriteData, 3));
1132 
1133   // TODO(akalin): Figure out how to test that the write happens
1134   // *after* the SSL connect.
1135 
1136   base::RunLoop().RunUntilIdle();
1137   ExpectSSLConnectSignal();
1138   ExpectNoSignal();
1139 
1140   base::RunLoop().RunUntilIdle();
1141 
1142   DoSSLCloseOpenedNoError();
1143 }
1144 
1145 // After this we can assume SSL connect works as expected.
1146 
TEST_F(NetworkServiceAsyncSocketTest,SSLRead)1147 TEST_F(NetworkServiceAsyncSocketTest, SSLRead) {
1148   DoSSLOpenClosed();
1149   async_socket_data_provider_.AddRead(net::MockRead(kReadData));
1150   base::RunLoop().RunUntilIdle();
1151 
1152   ExpectSSLReadSignal();
1153   ExpectNoSignal();
1154 
1155   EXPECT_EQ(kReadData, DrainRead(1));
1156 
1157   base::RunLoop().RunUntilIdle();
1158 
1159   DoSSLCloseOpenedNoError();
1160 }
1161 
TEST_F(NetworkServiceAsyncSocketTest,SSLSyncWrite)1162 TEST_F(NetworkServiceAsyncSocketTest, SSLSyncWrite) {
1163   async_socket_data_provider_.AddWrite(
1164       net::MockWrite(net::SYNCHRONOUS, kWriteData, 3));
1165   async_socket_data_provider_.AddWrite(
1166       net::MockWrite(net::SYNCHRONOUS, kWriteData + 3, 5));
1167   async_socket_data_provider_.AddWrite(net::MockWrite(
1168       net::SYNCHRONOUS, kWriteData + 8, base::size(kWriteData) - 8));
1169   DoSSLOpenClosed();
1170 
1171   EXPECT_TRUE(ns_async_socket_->Write(kWriteData, 3));
1172   base::RunLoop().RunUntilIdle();
1173   EXPECT_TRUE(ns_async_socket_->Write(kWriteData + 3, 5));
1174   base::RunLoop().RunUntilIdle();
1175   EXPECT_TRUE(
1176       ns_async_socket_->Write(kWriteData + 8, base::size(kWriteData) - 8));
1177   base::RunLoop().RunUntilIdle();
1178 
1179   ExpectNoSignal();
1180 
1181   DoSSLCloseOpenedNoError();
1182 }
1183 
TEST_F(NetworkServiceAsyncSocketTest,SSLAsyncWrite)1184 TEST_F(NetworkServiceAsyncSocketTest, SSLAsyncWrite) {
1185   DoSSLOpenClosed();
1186 
1187   async_socket_data_provider_.AddWrite(
1188       net::MockWrite(net::ASYNC, kWriteData, 3));
1189   async_socket_data_provider_.AddWrite(
1190       net::MockWrite(net::ASYNC, kWriteData + 3, 5));
1191   async_socket_data_provider_.AddWrite(
1192       net::MockWrite(net::ASYNC, kWriteData + 8, base::size(kWriteData) - 8));
1193 
1194   EXPECT_TRUE(ns_async_socket_->Write(kWriteData, 3));
1195   base::RunLoop().RunUntilIdle();
1196   EXPECT_TRUE(ns_async_socket_->Write(kWriteData + 3, 5));
1197   base::RunLoop().RunUntilIdle();
1198   EXPECT_TRUE(
1199       ns_async_socket_->Write(kWriteData + 8, base::size(kWriteData) - 8));
1200   base::RunLoop().RunUntilIdle();
1201 
1202   ExpectNoSignal();
1203 
1204   DoSSLCloseOpenedNoError();
1205 }
1206 
1207 class NetworkServiceAsyncSocketMojoTest : public NetworkServiceAsyncSocketTest {
1208  protected:
NetworkServiceAsyncSocketMojoTest()1209   NetworkServiceAsyncSocketMojoTest()
1210       : NetworkServiceAsyncSocketTest(true /* use_mojo_level_mock */) {}
~NetworkServiceAsyncSocketMojoTest()1211   ~NetworkServiceAsyncSocketMojoTest() override {}
1212 };
1213 
TEST_F(NetworkServiceAsyncSocketMojoTest,ReadEOF1)1214 TEST_F(NetworkServiceAsyncSocketMojoTest, ReadEOF1) {
1215   DoOpenClosed();
1216   mock_proxy_resolving_socket_factory_->socket()->RunEvents(
1217       {MockProxyResolvingSocket::kRead,
1218        MockProxyResolvingSocket::kCloseReadPipe,
1219        MockProxyResolvingSocket::kReadEofError,
1220        MockProxyResolvingSocket::kCloseObserverPipe});
1221 
1222   ExpectReadSignal();
1223   ExpectNoSignal();
1224   EXPECT_EQ("data", DrainRead(1));
1225 
1226   base::RunLoop().RunUntilIdle();
1227   ExpectSignalSocketState(SignalSocketState::NoError(
1228       SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED));
1229   ExpectClosed();
1230 }
1231 
TEST_F(NetworkServiceAsyncSocketMojoTest,ReadEOF2)1232 TEST_F(NetworkServiceAsyncSocketMojoTest, ReadEOF2) {
1233   DoOpenClosed();
1234   mock_proxy_resolving_socket_factory_->socket()->RunEvents(
1235       {MockProxyResolvingSocket::kReadEofError,
1236        MockProxyResolvingSocket::kCloseObserverPipe,
1237        MockProxyResolvingSocket::kRead,
1238        MockProxyResolvingSocket::kCloseReadPipe});
1239 
1240   ExpectReadSignal();
1241   ExpectNoSignal();
1242   EXPECT_EQ("data", DrainRead(1));
1243 
1244   base::RunLoop().RunUntilIdle();
1245   ExpectSignalSocketState(SignalSocketState::NoError(
1246       SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED));
1247   ExpectClosed();
1248 }
1249 
TEST_F(NetworkServiceAsyncSocketMojoTest,ReadError1)1250 TEST_F(NetworkServiceAsyncSocketMojoTest, ReadError1) {
1251   DoOpenClosed();
1252   mock_proxy_resolving_socket_factory_->socket()->RunEvents(
1253       {MockProxyResolvingSocket::kRead,
1254        MockProxyResolvingSocket::kCloseReadPipe,
1255        MockProxyResolvingSocket::kReadError,
1256        MockProxyResolvingSocket::kCloseObserverPipe});
1257 
1258   ExpectReadSignal();
1259   ExpectNoSignal();
1260   EXPECT_EQ("data", DrainRead(1));
1261 
1262   base::RunLoop().RunUntilIdle();
1263   ExpectSignalSocketState(SignalSocketState(
1264       SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
1265       NetworkServiceAsyncSocket::ERROR_WINSOCK, net::ERR_OUT_OF_MEMORY));
1266   ExpectClosed();
1267 }
1268 
TEST_F(NetworkServiceAsyncSocketMojoTest,ReadError2)1269 TEST_F(NetworkServiceAsyncSocketMojoTest, ReadError2) {
1270   DoOpenClosed();
1271   mock_proxy_resolving_socket_factory_->socket()->RunEvents(
1272       {MockProxyResolvingSocket::kReadError,
1273        MockProxyResolvingSocket::kCloseObserverPipe,
1274        MockProxyResolvingSocket::kRead,
1275        MockProxyResolvingSocket::kCloseReadPipe});
1276 
1277   ExpectReadSignal();
1278   ExpectNoSignal();
1279   EXPECT_EQ("data", DrainRead(1));
1280 
1281   base::RunLoop().RunUntilIdle();
1282   ExpectSignalSocketState(SignalSocketState(
1283       SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
1284       NetworkServiceAsyncSocket::ERROR_WINSOCK, net::ERR_OUT_OF_MEMORY));
1285   ExpectClosed();
1286 }
1287 
TEST_F(NetworkServiceAsyncSocketMojoTest,ReadErrorDouble)1288 TEST_F(NetworkServiceAsyncSocketMojoTest, ReadErrorDouble) {
1289   DoOpenClosed();
1290   mock_proxy_resolving_socket_factory_->socket()->RunEvents(
1291       {MockProxyResolvingSocket::kReadError,
1292        MockProxyResolvingSocket::kReadError,
1293        MockProxyResolvingSocket::kCloseObserverPipe,
1294        MockProxyResolvingSocket::kRead,
1295        MockProxyResolvingSocket::kCloseReadPipe});
1296 
1297   ExpectReadSignal();
1298   ExpectNoSignal();
1299   EXPECT_EQ("data", DrainRead(1));
1300 
1301   base::RunLoop().RunUntilIdle();
1302   ExpectSignalSocketState(SignalSocketState(
1303       SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
1304       NetworkServiceAsyncSocket::ERROR_WINSOCK, net::ERR_OUT_OF_MEMORY));
1305   ExpectClosed();
1306 }
1307 
TEST_F(NetworkServiceAsyncSocketMojoTest,ReadErrorDoubleInvalid)1308 TEST_F(NetworkServiceAsyncSocketMojoTest, ReadErrorDoubleInvalid) {
1309   DoOpenClosed();
1310   mock_proxy_resolving_socket_factory_->socket()->RunEvents(
1311       {MockProxyResolvingSocket::kReadError,
1312        MockProxyResolvingSocket::kReadErrorInvalid,
1313        MockProxyResolvingSocket::kCloseObserverPipe,
1314        MockProxyResolvingSocket::kRead,
1315        MockProxyResolvingSocket::kCloseReadPipe});
1316 
1317   ExpectReadSignal();
1318   ExpectNoSignal();
1319   EXPECT_EQ("data", DrainRead(1));
1320 
1321   base::RunLoop().RunUntilIdle();
1322   ExpectSignalSocketState(SignalSocketState(
1323       SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
1324       NetworkServiceAsyncSocket::ERROR_WINSOCK, net::ERR_OUT_OF_MEMORY));
1325   ExpectClosed();
1326 }
1327 
TEST_F(NetworkServiceAsyncSocketMojoTest,ReadErrorDoubleInvalid2)1328 TEST_F(NetworkServiceAsyncSocketMojoTest, ReadErrorDoubleInvalid2) {
1329   DoOpenClosed();
1330   mock_proxy_resolving_socket_factory_->socket()->RunEvents(
1331       {MockProxyResolvingSocket::kReadErrorInvalid,
1332        MockProxyResolvingSocket::kReadError,
1333        MockProxyResolvingSocket::kCloseObserverPipe,
1334        MockProxyResolvingSocket::kRead,
1335        MockProxyResolvingSocket::kCloseReadPipe});
1336 
1337   ExpectReadSignal();
1338   ExpectNoSignal();
1339   EXPECT_EQ("data", DrainRead(1));
1340 
1341   base::RunLoop().RunUntilIdle();
1342   ExpectSignalSocketState(SignalSocketState(
1343       SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
1344       NetworkServiceAsyncSocket::ERROR_WINSOCK, net::ERR_FAILED));
1345   ExpectClosed();
1346 }
1347 
TEST_F(NetworkServiceAsyncSocketMojoTest,ReadErrorClosedObserverPipe)1348 TEST_F(NetworkServiceAsyncSocketMojoTest, ReadErrorClosedObserverPipe) {
1349   DoOpenClosed();
1350   mock_proxy_resolving_socket_factory_->socket()->RunEvents(
1351       {MockProxyResolvingSocket::kRead,
1352        MockProxyResolvingSocket::kCloseObserverPipe});
1353   // Can't run kCloseReadPipe since it'll already be closed.
1354 
1355   ExpectReadSignal();
1356   // Since this is a misbehaving network service process scenario, no attempt
1357   // to recover the data is made.
1358   ExpectSignalSocketState(SignalSocketState(
1359       SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
1360       NetworkServiceAsyncSocket::ERROR_WINSOCK, net::ERR_FAILED));
1361   ExpectClosed();
1362 }
1363 
TEST_F(NetworkServiceAsyncSocketMojoTest,WriteError1)1364 TEST_F(NetworkServiceAsyncSocketMojoTest, WriteError1) {
1365   DoOpenClosed();
1366   ExpectNoSignal();
1367   ns_async_socket_->Write("atad", 4);
1368   base::RunLoop().RunUntilIdle();
1369 
1370   mock_proxy_resolving_socket_factory_->socket()->RunEvents(
1371       {MockProxyResolvingSocket::kWrite,
1372        MockProxyResolvingSocket::kCloseWritePipe,
1373        MockProxyResolvingSocket::kWriteError});
1374   // Cannot close the observer pipe here at the end since the other size
1375   // would have closed it already.
1376 
1377   base::RunLoop().RunUntilIdle();
1378   ExpectSignalSocketState(SignalSocketState(
1379       SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
1380       NetworkServiceAsyncSocket::ERROR_WINSOCK, net::ERR_ACCESS_DENIED));
1381   ExpectClosed();
1382 }
1383 
TEST_F(NetworkServiceAsyncSocketMojoTest,WriteError2)1384 TEST_F(NetworkServiceAsyncSocketMojoTest, WriteError2) {
1385   DoOpenClosed();
1386   ExpectNoSignal();
1387   ns_async_socket_->Write("atad", 4);
1388   base::RunLoop().RunUntilIdle();
1389 
1390   mock_proxy_resolving_socket_factory_->socket()->RunEvents(
1391       {MockProxyResolvingSocket::kWriteError,
1392        MockProxyResolvingSocket::kCloseObserverPipe,
1393        MockProxyResolvingSocket::kWrite,
1394        MockProxyResolvingSocket::kCloseWritePipe});
1395 
1396   base::RunLoop().RunUntilIdle();
1397   ExpectSignalSocketState(SignalSocketState(
1398       SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
1399       NetworkServiceAsyncSocket::ERROR_WINSOCK, net::ERR_ACCESS_DENIED));
1400   ExpectClosed();
1401 }
1402 
TEST_F(NetworkServiceAsyncSocketMojoTest,WriteErrorDouble)1403 TEST_F(NetworkServiceAsyncSocketMojoTest, WriteErrorDouble) {
1404   DoOpenClosed();
1405   ExpectNoSignal();
1406   ns_async_socket_->Write("atad", 4);
1407   base::RunLoop().RunUntilIdle();
1408 
1409   mock_proxy_resolving_socket_factory_->socket()->RunEvents(
1410       {MockProxyResolvingSocket::kWriteError,
1411        MockProxyResolvingSocket::kWriteError,
1412        MockProxyResolvingSocket::kCloseObserverPipe,
1413        MockProxyResolvingSocket::kWrite,
1414        MockProxyResolvingSocket::kCloseWritePipe});
1415 
1416   base::RunLoop().RunUntilIdle();
1417   ExpectSignalSocketState(SignalSocketState(
1418       SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
1419       NetworkServiceAsyncSocket::ERROR_WINSOCK, net::ERR_ACCESS_DENIED));
1420   ExpectClosed();
1421 }
1422 
TEST_F(NetworkServiceAsyncSocketMojoTest,WriteErrorDoubleInvalid)1423 TEST_F(NetworkServiceAsyncSocketMojoTest, WriteErrorDoubleInvalid) {
1424   DoOpenClosed();
1425   ExpectNoSignal();
1426   ns_async_socket_->Write("atad", 4);
1427   base::RunLoop().RunUntilIdle();
1428 
1429   mock_proxy_resolving_socket_factory_->socket()->RunEvents(
1430       {MockProxyResolvingSocket::kWriteError,
1431        MockProxyResolvingSocket::kWriteErrorInvalid,
1432        MockProxyResolvingSocket::kCloseObserverPipe,
1433        MockProxyResolvingSocket::kWrite,
1434        MockProxyResolvingSocket::kCloseWritePipe});
1435 
1436   base::RunLoop().RunUntilIdle();
1437   ExpectSignalSocketState(SignalSocketState(
1438       SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
1439       NetworkServiceAsyncSocket::ERROR_WINSOCK, net::ERR_ACCESS_DENIED));
1440   ExpectClosed();
1441 }
1442 
TEST_F(NetworkServiceAsyncSocketMojoTest,WriteErrorDoubleInvalid2)1443 TEST_F(NetworkServiceAsyncSocketMojoTest, WriteErrorDoubleInvalid2) {
1444   DoOpenClosed();
1445   ExpectNoSignal();
1446   ns_async_socket_->Write("atad", 4);
1447   base::RunLoop().RunUntilIdle();
1448 
1449   mock_proxy_resolving_socket_factory_->socket()->RunEvents(
1450       {MockProxyResolvingSocket::kWriteErrorInvalid,
1451        MockProxyResolvingSocket::kWriteError,
1452        MockProxyResolvingSocket::kCloseObserverPipe,
1453        MockProxyResolvingSocket::kWrite,
1454        MockProxyResolvingSocket::kCloseWritePipe});
1455 
1456   base::RunLoop().RunUntilIdle();
1457   ExpectSignalSocketState(SignalSocketState(
1458       SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
1459       NetworkServiceAsyncSocket::ERROR_WINSOCK, net::ERR_FAILED));
1460   ExpectClosed();
1461 }
1462 
1463 }  // namespace
1464 
1465 }  // namespace jingle_glue
1466