spdy_proxy_client_socket_unittest.cc revision 21d179b334e59e9a3bfcaed4c4430bef1bc5759d
1731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// Copyright (c) 2010 The Chromium Authors. All rights reserved. 2731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// Use of this source code is governed by a BSD-style license that can be 3731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// found in the LICENSE file. 4731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 5731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick#include "net/spdy/spdy_proxy_client_socket.h" 6731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 7731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick#include "base/utf_string_conversions.h" 8731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick#include "net/base/address_list.h" 9731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick#include "net/base/net_log.h" 10731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick#include "net/base/net_log_unittest.h" 11731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick#include "net/base/mock_host_resolver.h" 12731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick#include "net/base/test_completion_callback.h" 13731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick#include "net/base/winsock_init.h" 14731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick#include "net/http/http_response_info.h" 15731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick#include "net/http/http_response_headers.h" 16731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick#include "net/socket/client_socket_factory.h" 17731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick#include "net/socket/tcp_client_socket.h" 18731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick#include "net/socket/socket_test_util.h" 19731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick#include "net/spdy/spdy_protocol.h" 20731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick#include "net/spdy/spdy_session_pool.h" 21731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick#include "net/spdy/spdy_test_util.h" 22731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick#include "testing/platform_test.h" 23731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick#include "testing/gtest/include/gtest/gtest.h" 24731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 25731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick//----------------------------------------------------------------------------- 26731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 27731df977c0511bca2206b5f333555b1205ff1f43Iain Merricknamespace { 28731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 29731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickstatic const char kUrl[] = "https://www.google.com/"; 30731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickstatic const char kOriginHost[] = "www.google.com"; 31731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickstatic const int kOriginPort = 443; 32731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickstatic const char kOriginHostPort[] = "www.google.com:443"; 33731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickstatic const char kProxyUrl[] = "http://myproxy:6121/"; 34731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickstatic const char kProxyHost[] = "myproxy"; 35731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickstatic const int kProxyPort = 6121; 36731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickstatic const char kUserAgent[] = "Mozilla/1.0"; 37731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 38731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickstatic const int kStreamId = 1; 39731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 40731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickstatic const char kMsg1[] = "\0hello!\xff"; 41731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickstatic const int kLen1 = 8; 42731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickstatic const char kMsg2[] = "\012345678\0"; 43731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickstatic const int kLen2 = 10; 44731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickstatic const char kMsg3[] = "bye!"; 45731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickstatic const int kLen3 = 4; 46731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickstatic const char kMsg33[] = "bye!bye!"; 47731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickstatic const int kLen33 = kLen3 + kLen3; 48731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickstatic const char kMsg333[] = "bye!bye!bye!"; 49731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickstatic const int kLen333 = kLen3 + kLen3 + kLen3; 50731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 51731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} // anonymous namespace 52731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 53731df977c0511bca2206b5f333555b1205ff1f43Iain Merricknamespace net { 54731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 55731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickclass SpdyProxyClientSocketTest : public PlatformTest { 56731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick public: 57731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick SpdyProxyClientSocketTest(); 58731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 59731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick virtual void TearDown(); 60731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 61731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick protected: 62731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick void Initialize(MockRead* reads, size_t reads_count, MockWrite* writes, 63731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick size_t writes_count); 64731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick spdy::SpdyFrame* ConstructConnectRequestFrame(); 65731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick spdy::SpdyFrame* ConstructConnectAuthRequestFrame(); 66731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick spdy::SpdyFrame* ConstructConnectReplyFrame(); 67731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick spdy::SpdyFrame* ConstructConnectAuthReplyFrame(); 68731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick spdy::SpdyFrame* ConstructConnectErrorReplyFrame(); 69731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick spdy::SpdyFrame* ConstructBodyFrame(const char* data, int length); 70731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_refptr<IOBufferWithSize> CreateBuffer(const char* data, int size); 71731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick void AssertConnectSucceeds(); 72731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick void AssertConnectFails(int result); 73731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick void AssertConnectionEstablished(); 74731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick void AssertSyncReadEquals(const char* data, int len); 75731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick void AssertAsyncReadEquals(const char* data, int len); 76731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick void AssertReadStarts(const char* data, int len); 77731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick void AssertReadReturns(const char* data, int len); 78731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick void AssertAsyncWriteSucceeds(const char* data, int len); 79731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick void AssertWriteReturns(const char* data, int len, int rv); 80731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick void AssertWriteLength(int len); 81731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick void AssertAsyncWriteWithReadsSucceeds(const char* data, int len, 82731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick int num_reads); 83731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 84731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick void AddAuthToCache() { 85731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick const string16 kFoo(ASCIIToUTF16("foo")); 86731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick const string16 kBar(ASCIIToUTF16("bar")); 87731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick session_->auth_cache()->Add(GURL(kProxyUrl), "MyRealm1", "Basic", 88731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick "Basic realm=MyRealm1", kFoo, kBar, "/"); 89731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick } 90731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 91731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick void Run(int steps) { 92731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick data_->StopAfter(steps); 93731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick data_->Run(); 94731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick } 95731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 96731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<SpdyProxyClientSocket> sock_; 97731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick TestCompletionCallback read_callback_; 98731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick TestCompletionCallback write_callback_; 99731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_refptr<DeterministicSocketData> data_; 100731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 101731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick private: 102731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_refptr<HttpNetworkSession> session_; 103731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_refptr<IOBuffer> read_buf_; 104731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick SpdySessionDependencies session_deps_; 105731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockConnect connect_data_; 106731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_refptr<SpdySession> spdy_session_; 107731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_refptr<SpdyStream> spdy_stream_; 108731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick spdy::SpdyFramer framer_; 109731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 110731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick std::string user_agent_; 111731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick GURL url_; 112731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick HostPortPair proxy_host_port_; 113731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick HostPortPair endpoint_host_port_pair_; 114731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ProxyServer proxy_; 115731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick HostPortProxyPair endpoint_host_port_proxy_pair_; 116731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_refptr<TCPSocketParams> tcp_params_; 117731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 118731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick DISALLOW_COPY_AND_ASSIGN(SpdyProxyClientSocketTest); 119731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick}; 120731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 121731df977c0511bca2206b5f333555b1205ff1f43Iain MerrickSpdyProxyClientSocketTest::SpdyProxyClientSocketTest() 122731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick : sock_(NULL), 123731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick read_callback_(), 124731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick write_callback_(), 125731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick data_(NULL), 126731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick session_(NULL), 127731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick read_buf_(NULL), 128731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick session_deps_(), 129731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick connect_data_(false, OK), 130731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick spdy_session_(NULL), 131731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick spdy_stream_(NULL), 132731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick framer_(), 133731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick user_agent_(kUserAgent), 134731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick url_(kUrl), 135731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick proxy_host_port_(kProxyHost, kProxyPort), 136731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick endpoint_host_port_pair_(kOriginHost, kOriginPort), 137731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick proxy_(ProxyServer::SCHEME_HTTPS, proxy_host_port_), 138731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick endpoint_host_port_proxy_pair_(endpoint_host_port_pair_, proxy_), 139731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick tcp_params_(new TCPSocketParams(proxy_host_port_, LOWEST, url_, false)) { 140731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 141731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 142731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickvoid SpdyProxyClientSocketTest::TearDown() { 143731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick if (session_ != NULL) 144731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick session_->spdy_session_pool()->CloseAllSessions(); 145731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 146731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick spdy::SpdyFramer::set_enable_compression_default(true); 147731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // Empty the current queue. 148731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MessageLoop::current()->RunAllPending(); 149731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick PlatformTest::TearDown(); 150731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 151731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 152731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickvoid SpdyProxyClientSocketTest::Initialize(MockRead* reads, 153731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick size_t reads_count, 154731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockWrite* writes, 155731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick size_t writes_count) { 156731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick data_ = new DeterministicSocketData(reads, reads_count, writes, writes_count); 157731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick data_->set_connect_data(connect_data_); 158731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick data_->SetStop(2); 159731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 160731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick session_deps_.deterministic_socket_factory->AddSocketDataProvider( 161731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick data_.get()); 162731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick session_deps_.host_resolver->set_synchronous_mode(true); 163731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 164731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick session_ = SpdySessionDependencies::SpdyCreateSessionDeterministic( 165731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick &session_deps_); 166731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick SpdySession::SetSSLMode(false); 167731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick spdy::SpdyFramer::set_enable_compression_default(false); 168731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 169731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // Creates a new spdy session 170731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick spdy_session_ = 171731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick session_->spdy_session_pool()->Get(endpoint_host_port_proxy_pair_, 172731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick session_->mutable_spdy_settings(), 173731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick BoundNetLog()); 174731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 175731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // Perform the TCP connect 176731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<ClientSocketHandle> connection(new ClientSocketHandle); 177731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick EXPECT_EQ(OK, 178731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick connection->Init(endpoint_host_port_pair_.ToString(), tcp_params_, 179731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick LOWEST, NULL, session_->tcp_socket_pool(), 180731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick BoundNetLog())); 181731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick spdy_session_->InitializeWithSocket(connection.release(), false, OK); 182731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 183731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // Create the SPDY Stream 184731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ASSERT_EQ( 185731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick OK, 186731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick spdy_session_->CreateStream(url_, LOWEST, &spdy_stream_, BoundNetLog(), 187731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick NULL)); 188731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 189731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // Create the SpdyProxyClientSocket 190731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick sock_.reset( 191731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick new SpdyProxyClientSocket(spdy_stream_, user_agent_, 192731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick endpoint_host_port_pair_, url_, 193731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick proxy_host_port_, session_->auth_cache(), 194731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick session_->http_auth_handler_factory())); 195731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 196731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 197731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickscoped_refptr<IOBufferWithSize> SpdyProxyClientSocketTest::CreateBuffer( 198731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick const char* data, int size) { 199731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_refptr<IOBufferWithSize> buf(new IOBufferWithSize(size)); 200731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick memcpy(buf->data(), data, size); 201731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick return buf; 202731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 203731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 204731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickvoid SpdyProxyClientSocketTest::AssertConnectSucceeds() { 205731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ASSERT_EQ(ERR_IO_PENDING, sock_->Connect(&read_callback_)); 206731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick data_->Run(); 207731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ASSERT_EQ(OK, read_callback_.WaitForResult()); 208731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 209731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 210731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickvoid SpdyProxyClientSocketTest::AssertConnectFails(int result) { 211731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ASSERT_EQ(ERR_IO_PENDING, sock_->Connect(&read_callback_)); 212731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick data_->Run(); 213731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ASSERT_EQ(result, read_callback_.WaitForResult()); 214731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 215731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 216731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickvoid SpdyProxyClientSocketTest::AssertConnectionEstablished() { 217731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick const HttpResponseInfo* response = sock_->GetConnectResponseInfo(); 218731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ASSERT_TRUE(response != NULL); 219731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ASSERT_EQ(200, response->headers->response_code()); 220731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ASSERT_EQ("Connection Established", response->headers->GetStatusText()); 221731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 222731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 223731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickvoid SpdyProxyClientSocketTest::AssertSyncReadEquals(const char* data, 224731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick int len) { 225731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_refptr<IOBuffer> buf(new IOBuffer(len)); 226731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ASSERT_EQ(len, sock_->Read(buf, len, NULL)); 227731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ASSERT_EQ(std::string(data, len), std::string(buf->data(), len)); 228731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ASSERT_TRUE(sock_->IsConnected()); 229731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 230731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 231731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickvoid SpdyProxyClientSocketTest::AssertAsyncReadEquals(const char* data, 232731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick int len) { 233731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick data_->StopAfter(1); 234731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // Issue the read, which will be completed asynchronously 235731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_refptr<IOBuffer> buf(new IOBuffer(len)); 236731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ASSERT_EQ(ERR_IO_PENDING, sock_->Read(buf, len, &read_callback_)); 237731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick EXPECT_TRUE(sock_->IsConnected()); 238731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick data_->Run(); 239731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 240731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick EXPECT_TRUE(sock_->IsConnected()); 241731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 242731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // Now the read will return 243731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick EXPECT_EQ(len, read_callback_.WaitForResult()); 244731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ASSERT_EQ(std::string(data, len), std::string(buf->data(), len)); 245731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 246731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 247731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickvoid SpdyProxyClientSocketTest::AssertReadStarts(const char* data, int len) { 248731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick data_->StopAfter(1); 249731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // Issue the read, which will be completed asynchronously 250731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick read_buf_ = new IOBuffer(len); 251731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ASSERT_EQ(ERR_IO_PENDING, sock_->Read(read_buf_, len, &read_callback_)); 252731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick EXPECT_TRUE(sock_->IsConnected()); 253731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 254731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 255731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickvoid SpdyProxyClientSocketTest::AssertReadReturns(const char* data, int len) { 256731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick EXPECT_TRUE(sock_->IsConnected()); 257731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 258731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // Now the read will return 259731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick EXPECT_EQ(len, read_callback_.WaitForResult()); 260731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ASSERT_EQ(std::string(data, len), std::string(read_buf_->data(), len)); 261731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 262731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 263731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickvoid SpdyProxyClientSocketTest::AssertAsyncWriteSucceeds(const char* data, 264731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick int len) { 265731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertWriteReturns(data, len, ERR_IO_PENDING); 266731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick data_->RunFor(1); 267731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertWriteLength(len); 268731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 269731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 270731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickvoid SpdyProxyClientSocketTest::AssertWriteReturns(const char* data, int len, 271731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick int rv) { 272731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_refptr<IOBufferWithSize> buf(CreateBuffer(data, len)); 273731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick EXPECT_EQ(rv, sock_->Write(buf, buf->size(), &write_callback_)); 274731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 275731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 276731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickvoid SpdyProxyClientSocketTest::AssertWriteLength(int len) { 277731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick EXPECT_EQ(len, write_callback_.WaitForResult()); 278731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 279731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 280731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickvoid SpdyProxyClientSocketTest::AssertAsyncWriteWithReadsSucceeds( 281731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick const char* data, int len, int num_reads) { 282731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_refptr<IOBufferWithSize> buf(CreateBuffer(data, len)); 283731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 284731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick EXPECT_EQ(ERR_IO_PENDING, sock_->Write(buf, buf->size(), &write_callback_)); 285731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 286731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick for (int i = 0; i < num_reads; i++) { 287731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Run(1); 288731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertSyncReadEquals(kMsg2, kLen2); 289731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick } 290731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 291731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick write_callback_.WaitForResult(); 292731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 293731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 294731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// Constructs a standard SPDY SYN_STREAM frame for a CONNECT request. 295731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickspdy::SpdyFrame* SpdyProxyClientSocketTest::ConstructConnectRequestFrame() { 296731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick const SpdyHeaderInfo kSynStartHeader = { 297731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick spdy::SYN_STREAM, 298731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick kStreamId, 299731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 0, 300731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick net::ConvertRequestPriorityToSpdyPriority(LOWEST), 301731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick spdy::CONTROL_FLAG_NONE, 302731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick false, 303731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick spdy::INVALID, 304731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick NULL, 305731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 0, 306731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick spdy::DATA_FLAG_NONE 307731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 308731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick const char* const kConnectHeaders[] = { 309731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick "method", "CONNECT", 310731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick "url", kOriginHostPort, 311731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick "host", kOriginHost, 312731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick "user-agent", kUserAgent, 313731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick "version", "HTTP/1.1", 314731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 315731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick return ConstructSpdyPacket( 316731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick kSynStartHeader, NULL, 0, kConnectHeaders, arraysize(kConnectHeaders)/2); 317731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 318731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 319731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// Constructs a SPDY SYN_STREAM frame for a CONNECT request which includes 320731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// Proxy-Authorization headers. 321731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickspdy::SpdyFrame* SpdyProxyClientSocketTest::ConstructConnectAuthRequestFrame() { 322731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick const SpdyHeaderInfo kSynStartHeader = { 323731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick spdy::SYN_STREAM, 324731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick kStreamId, 325731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 0, 326731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick net::ConvertRequestPriorityToSpdyPriority(LOWEST), 327731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick spdy::CONTROL_FLAG_NONE, 328731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick false, 329731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick spdy::INVALID, 330731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick NULL, 331731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 0, 332731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick spdy::DATA_FLAG_NONE 333731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 334731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick const char* const kConnectHeaders[] = { 335731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick "method", "CONNECT", 336731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick "url", kOriginHostPort, 337731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick "host", kOriginHost, 338731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick "user-agent", kUserAgent, 339731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick "version", "HTTP/1.1", 340731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick "proxy-authorization", "Basic Zm9vOmJhcg==", 341731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 342731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick return ConstructSpdyPacket( 343731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick kSynStartHeader, NULL, 0, kConnectHeaders, arraysize(kConnectHeaders)/2); 344731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 345731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 346731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// Constructs a standard SPDY SYN_REPLY frame to match the SPDY CONNECT. 347731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickspdy::SpdyFrame* SpdyProxyClientSocketTest::ConstructConnectReplyFrame() { 348731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick const char* const kStandardReplyHeaders[] = { 349731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick "status", "200 Connection Established", 350731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick "version", "HTTP/1.1" 351731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 352731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick return ConstructSpdyControlFrame(NULL, 353731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 0, 354731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick false, 355731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick kStreamId, 356731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick LOWEST, 357731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick spdy::SYN_REPLY, 358731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick spdy::CONTROL_FLAG_NONE, 359731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick kStandardReplyHeaders, 360731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick arraysize(kStandardReplyHeaders)); 361731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 362731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 363731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// Constructs a standard SPDY SYN_REPLY frame to match the SPDY CONNECT. 364731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickspdy::SpdyFrame* SpdyProxyClientSocketTest::ConstructConnectAuthReplyFrame() { 365731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick const char* const kStandardReplyHeaders[] = { 366731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick "status", "407 Proxy Authentication Required", 367731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick "version", "HTTP/1.1", 368731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick "proxy-authenticate", "Basic realm=\"MyRealm1\"", 369731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 370731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 371731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick return ConstructSpdyControlFrame(NULL, 372731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 0, 373731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick false, 374731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick kStreamId, 375731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick LOWEST, 376731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick spdy::SYN_REPLY, 377731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick spdy::CONTROL_FLAG_NONE, 378731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick kStandardReplyHeaders, 379731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick arraysize(kStandardReplyHeaders)); 380731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 381731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 382731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// Constructs a SPDY SYN_REPLY frame with an HTTP 500 error. 383731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickspdy::SpdyFrame* SpdyProxyClientSocketTest::ConstructConnectErrorReplyFrame() { 384731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick const char* const kStandardReplyHeaders[] = { 385731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick "status", "500 Internal Server Error", 386731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick "version", "HTTP/1.1", 387731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 388731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 389731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick return ConstructSpdyControlFrame(NULL, 390731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 0, 391731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick false, 392731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick kStreamId, 393731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick LOWEST, 394731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick spdy::SYN_REPLY, 395731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick spdy::CONTROL_FLAG_NONE, 396731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick kStandardReplyHeaders, 397731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick arraysize(kStandardReplyHeaders)); 398731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 399731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 400731df977c0511bca2206b5f333555b1205ff1f43Iain Merrickspdy::SpdyFrame* SpdyProxyClientSocketTest::ConstructBodyFrame(const char* data, 401731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick int length) { 402731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick return framer_.CreateDataFrame(kStreamId, data, length, spdy::DATA_FLAG_NONE); 403731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 404731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 405731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// ----------- Connect 406731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 407731df977c0511bca2206b5f333555b1205ff1f43Iain MerrickTEST_F(SpdyProxyClientSocketTest, ConnectSendsCorrectRequest) { 408731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame()); 409731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockWrite writes[] = { 410731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockWrite(*conn, 0, false), 411731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 412731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 413731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame()); 414731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead reads[] = { 415731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*resp, 1, true), 416731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead(true, 0, 3), // EOF 417731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 418731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 419731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Initialize(reads, arraysize(reads), writes, arraysize(writes)); 420731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 421731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ASSERT_FALSE(sock_->IsConnected()); 422731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 423731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertConnectSucceeds(); 424731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 425731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertConnectionEstablished(); 426731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 427731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 428731df977c0511bca2206b5f333555b1205ff1f43Iain MerrickTEST_F(SpdyProxyClientSocketTest, ConnectWithAuthRequested) { 429731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame()); 430731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockWrite writes[] = { 431731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockWrite(*conn, 0, false), 432731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 433731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 434731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectAuthReplyFrame()); 435731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead reads[] = { 436731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*resp, 1, true), 437731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead(true, 0, 3), // EOF 438731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 439731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 440731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Initialize(reads, arraysize(reads), writes, arraysize(writes)); 441731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 442731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertConnectFails(ERR_TUNNEL_CONNECTION_FAILED); 443731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 444731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick const HttpResponseInfo* response = sock_->GetConnectResponseInfo(); 445731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ASSERT_TRUE(response != NULL); 446731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ASSERT_EQ(407, response->headers->response_code()); 447731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ASSERT_EQ("Proxy Authentication Required", 448731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick response->headers->GetStatusText()); 449731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 450731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 451731df977c0511bca2206b5f333555b1205ff1f43Iain MerrickTEST_F(SpdyProxyClientSocketTest, ConnectWithAuthCredentials) { 452731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectAuthRequestFrame()); 453731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockWrite writes[] = { 454731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockWrite(*conn, 0, false), 455731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 456731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 457731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame()); 458731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead reads[] = { 459731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*resp, 1, true), 460731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead(true, 0, 3), // EOF 461731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 462731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 463731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Initialize(reads, arraysize(reads), writes, arraysize(writes)); 464731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AddAuthToCache(); 465731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 466731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertConnectSucceeds(); 467731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 468731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertConnectionEstablished(); 469731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 470731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 471731df977c0511bca2206b5f333555b1205ff1f43Iain MerrickTEST_F(SpdyProxyClientSocketTest, ConnectFails) { 472731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame()); 473731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockWrite writes[] = { 474731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockWrite(*conn, 0, false), 475731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 476731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 477731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame()); 478731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead reads[] = { 479731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead(true, 0, 1), // EOF 480731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 481731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 482731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Initialize(reads, arraysize(reads), writes, arraysize(writes)); 483731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 484731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ASSERT_FALSE(sock_->IsConnected()); 485731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 486731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertConnectFails(ERR_CONNECTION_CLOSED); 487731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 488731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ASSERT_FALSE(sock_->IsConnected()); 489731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 490731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 491731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// ----------- WasEverUsed 492731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 493731df977c0511bca2206b5f333555b1205ff1f43Iain MerrickTEST_F(SpdyProxyClientSocketTest, WasEverUsedReturnsCorrectValues) { 494731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame()); 495731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockWrite writes[] = { 496731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockWrite(*conn, 0, false), 497731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 498731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 499731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame()); 500731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead reads[] = { 501731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*resp, 1, true), 502731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead(true, 0, 2), // EOF 503731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 504731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 505731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Initialize(reads, arraysize(reads), writes, arraysize(writes)); 506731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 507731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick EXPECT_FALSE(sock_->WasEverUsed()); 508731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertConnectSucceeds(); 509731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick EXPECT_TRUE(sock_->WasEverUsed()); 510731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick sock_->Disconnect(); 511731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick EXPECT_TRUE(sock_->WasEverUsed()); 512731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 513731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 514731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// ----------- GetPeerAddress 515731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 516731df977c0511bca2206b5f333555b1205ff1f43Iain MerrickTEST_F(SpdyProxyClientSocketTest, GetPeerAddressReturnsCorrectValues) { 517731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame()); 518731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockWrite writes[] = { 519731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockWrite(*conn, 0, false), 520731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 521731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 522731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame()); 523731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead reads[] = { 524731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*resp, 1, true), 525731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead(true, 0, 2), // EOF 526731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 527731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 528731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Initialize(reads, arraysize(reads), writes, arraysize(writes)); 529731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 530731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick net::AddressList addr; 531731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED, sock_->GetPeerAddress(&addr)); 532731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 533731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertConnectSucceeds(); 534731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick EXPECT_TRUE(sock_->IsConnected()); 535731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick EXPECT_EQ(OK, sock_->GetPeerAddress(&addr)); 536731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 537731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick sock_->Disconnect(); 538731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED, sock_->GetPeerAddress(&addr)); 539731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 540731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 541731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// ----------- Write 542731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 543731df977c0511bca2206b5f333555b1205ff1f43Iain MerrickTEST_F(SpdyProxyClientSocketTest, WriteSendsDataInDataFrame) { 544731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame()); 545731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1)); 546731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2)); 547731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockWrite writes[] = { 548731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockWrite(*conn, 0, false), 549731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockWrite(*msg1, 2, false), 550731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockWrite(*msg2, 3, false), 551731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 552731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 553731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame()); 554731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead reads[] = { 555731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*resp, 1, true), 556731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead(true, 0, 4), // EOF 557731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 558731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 559731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Initialize(reads, arraysize(reads), writes, arraysize(writes)); 560731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 561731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertConnectSucceeds(); 562731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 563731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertAsyncWriteSucceeds(kMsg1, kLen1); 564731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertAsyncWriteSucceeds(kMsg2, kLen2); 565731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 566731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 567731df977c0511bca2206b5f333555b1205ff1f43Iain MerrickTEST_F(SpdyProxyClientSocketTest, WriteSplitsLargeDataIntoMultipleFrames) { 568731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick std::string chunk_data(kMaxSpdyFrameChunkSize, 'x'); 569731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame()); 570731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> chunk(ConstructBodyFrame(chunk_data.data(), 571731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick chunk_data.length())); 572731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockWrite writes[] = { 573731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockWrite(*conn, 0, false), 574731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockWrite(*chunk, 2, false), 575731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockWrite(*chunk, 3, false), 576731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockWrite(*chunk, 4, false) 577731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 578731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 579731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame()); 580731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead reads[] = { 581731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*resp, 1, true), 582731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead(true, 0, 5), // EOF 583731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 584731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 585731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Initialize(reads, arraysize(reads), writes, arraysize(writes)); 586731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 587731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertConnectSucceeds(); 588731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 589731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick std::string big_data(kMaxSpdyFrameChunkSize * 3, 'x'); 590731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_refptr<IOBufferWithSize> buf(CreateBuffer(big_data.data(), 591731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick big_data.length())); 592731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 593731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick EXPECT_EQ(ERR_IO_PENDING, sock_->Write(buf, buf->size(), &write_callback_)); 594731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick data_->RunFor(3); 595731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 596731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick EXPECT_EQ(buf->size(), write_callback_.WaitForResult()); 597731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 598731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 599731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// ----------- Read 600731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 601731df977c0511bca2206b5f333555b1205ff1f43Iain MerrickTEST_F(SpdyProxyClientSocketTest, ReadReadsDataInDataFrame) { 602731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame()); 603731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockWrite writes[] = { 604731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockWrite(*conn, 0, false), 605731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 606731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 607731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame()); 608731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1)); 609731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead reads[] = { 610731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*resp, 1, true), 611731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*msg1, 2, true), 612731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead(true, 0, 3), // EOF 613731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 614731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 615731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Initialize(reads, arraysize(reads), writes, arraysize(writes)); 616731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 617731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertConnectSucceeds(); 618731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 619731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Run(1); // SpdySession consumes the next read and sends it to 620731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // sock_ to be buffered. 621731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertSyncReadEquals(kMsg1, kLen1); 622731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 623731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 624731df977c0511bca2206b5f333555b1205ff1f43Iain MerrickTEST_F(SpdyProxyClientSocketTest, ReadDataFromBufferedFrames) { 625731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame()); 626731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockWrite writes[] = { 627731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockWrite(*conn, 0, false), 628731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 629731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 630731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame()); 631731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1)); 632731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2)); 633731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead reads[] = { 634731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*resp, 1, true), 635731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*msg1, 2, true), 636731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*msg2, 3, true), 637731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead(true, 0, 4), // EOF 638731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 639731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 640731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Initialize(reads, arraysize(reads), writes, arraysize(writes)); 641731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 642731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertConnectSucceeds(); 643731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 644731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Run(1); // SpdySession consumes the next read and sends it to 645731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // sock_ to be buffered. 646731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertSyncReadEquals(kMsg1, kLen1); 647731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Run(1); // SpdySession consumes the next read and sends it to 648731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // sock_ to be buffered. 649731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertSyncReadEquals(kMsg2, kLen2); 650731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 651731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 652731df977c0511bca2206b5f333555b1205ff1f43Iain MerrickTEST_F(SpdyProxyClientSocketTest, ReadDataMultipleBufferedFrames) { 653731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame()); 654731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockWrite writes[] = { 655731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockWrite(*conn, 0, false), 656731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 657731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 658731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame()); 659731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1)); 660731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2)); 661731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead reads[] = { 662731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*resp, 1, true), 663731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*msg1, 2, true), 664731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*msg2, 3, true), 665731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead(true, 0, 4), // EOF 666731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 667731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 668731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Initialize(reads, arraysize(reads), writes, arraysize(writes)); 669731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 670731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertConnectSucceeds(); 671731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 672731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Run(2); // SpdySession consumes the next two reads and sends then to 673731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // sock_ to be buffered. 674731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertSyncReadEquals(kMsg1, kLen1); 675731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertSyncReadEquals(kMsg2, kLen2); 676731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 677731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 678731df977c0511bca2206b5f333555b1205ff1f43Iain MerrickTEST_F(SpdyProxyClientSocketTest, LargeReadWillMergeDataFromDifferentFrames) { 679731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame()); 680731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockWrite writes[] = { 681731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockWrite(*conn, 0, false), 682731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 683731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 684731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame()); 685731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1)); 686731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> msg3(ConstructBodyFrame(kMsg3, kLen3)); 687731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead reads[] = { 688731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*resp, 1, true), 689731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*msg3, 2, true), 690731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*msg3, 3, true), 691731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead(true, 0, 4), // EOF 692731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 693731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 694731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Initialize(reads, arraysize(reads), writes, arraysize(writes)); 695731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 696731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertConnectSucceeds(); 697731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 698731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Run(2); // SpdySession consumes the next two reads and sends then to 699731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // sock_ to be buffered. 700731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // The payload from two data frames, each with kMsg3 will be combined 701731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // together into a single read(). 702731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertSyncReadEquals(kMsg33, kLen33); 703731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 704731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 705731df977c0511bca2206b5f333555b1205ff1f43Iain MerrickTEST_F(SpdyProxyClientSocketTest, MultipleShortReadsThenMoreRead) { 706731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame()); 707731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockWrite writes[] = { 708731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockWrite(*conn, 0, false), 709731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 710731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 711731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame()); 712731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1)); 713731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> msg3(ConstructBodyFrame(kMsg3, kLen3)); 714731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2)); 715731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead reads[] = { 716731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*resp, 1, true), 717731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*msg1, 2, true), 718731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*msg3, 3, true), 719731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*msg3, 4, true), 720731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*msg2, 5, true), 721731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead(true, 0, 6), // EOF 722731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 723731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 724731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Initialize(reads, arraysize(reads), writes, arraysize(writes)); 725731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 726731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertConnectSucceeds(); 727731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 728731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Run(4); // SpdySession consumes the next four reads and sends then to 729731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // sock_ to be buffered. 730731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertSyncReadEquals(kMsg1, kLen1); 731731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // The payload from two data frames, each with kMsg3 will be combined 732731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // together into a single read(). 733731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertSyncReadEquals(kMsg33, kLen33); 734731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertSyncReadEquals(kMsg2, kLen2); 735731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 736731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 737731df977c0511bca2206b5f333555b1205ff1f43Iain MerrickTEST_F(SpdyProxyClientSocketTest, ReadWillSplitDataFromLargeFrame) { 738731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame()); 739731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockWrite writes[] = { 740731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockWrite(*conn, 0, false), 741731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 742731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 743731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame()); 744731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1)); 745731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> msg33(ConstructBodyFrame(kMsg33, kLen33)); 746731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2)); 747731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead reads[] = { 748731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*resp, 1, true), 749731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*msg1, 2, true), 750731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*msg33, 3, true), 751731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead(true, 0, 4), // EOF 752731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 753731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 754731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Initialize(reads, arraysize(reads), writes, arraysize(writes)); 755731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 756731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertConnectSucceeds(); 757731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 758731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Run(2); // SpdySession consumes the next two reads and sends then to 759731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // sock_ to be buffered. 760731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertSyncReadEquals(kMsg1, kLen1); 761731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // The payload from the single large data frame will be read across 762731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // two different reads. 763731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertSyncReadEquals(kMsg3, kLen3); 764731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertSyncReadEquals(kMsg3, kLen3); 765731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 766731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 767731df977c0511bca2206b5f333555b1205ff1f43Iain MerrickTEST_F(SpdyProxyClientSocketTest, MultipleReadsFromSameLargeFrame) { 768731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame()); 769731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockWrite writes[] = { 770731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockWrite(*conn, 0, false), 771731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 772731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 773731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame()); 774731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> msg333(ConstructBodyFrame(kMsg333, kLen333)); 775731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead reads[] = { 776731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*resp, 1, true), 777731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*msg333, 2, true), 778731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead(true, 0, 3), // EOF 779731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 780731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 781731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Initialize(reads, arraysize(reads), writes, arraysize(writes)); 782731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 783731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertConnectSucceeds(); 784731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 785731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Run(1); // SpdySession consumes the next read and sends it to 786731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // sock_ to be buffered. 787731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // The payload from the single large data frame will be read across 788731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // two different reads. 789731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertSyncReadEquals(kMsg33, kLen33); 790731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 791731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // Now attempt to do a read of more data than remains buffered 792731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_refptr<IOBuffer> buf(new IOBuffer(kLen33)); 793731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ASSERT_EQ(kLen3, sock_->Read(buf, kLen33, &read_callback_)); 794731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ASSERT_EQ(std::string(kMsg3, kLen3), std::string(buf->data(), kLen3)); 795731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ASSERT_TRUE(sock_->IsConnected()); 796731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 797731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 798731df977c0511bca2206b5f333555b1205ff1f43Iain MerrickTEST_F(SpdyProxyClientSocketTest, ReadAuthResponseBody) { 799731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame()); 800731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockWrite writes[] = { 801731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockWrite(*conn, 0, false), 802731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 803731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 804731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectAuthReplyFrame()); 805731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1)); 806731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2)); 807731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead reads[] = { 808731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*resp, 1, true), 809731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*msg1, 2, true), 810731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*msg2, 3, true), 811731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead(true, 0, 4), // EOF 812731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 813731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 814731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Initialize(reads, arraysize(reads), writes, arraysize(writes)); 815731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 816731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertConnectFails(ERR_TUNNEL_CONNECTION_FAILED); 817731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 818731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Run(2); // SpdySession consumes the next two reads and sends then to 819731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // sock_ to be buffered. 820731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertSyncReadEquals(kMsg1, kLen1); 821731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertSyncReadEquals(kMsg2, kLen2); 822731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 823731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 824731df977c0511bca2206b5f333555b1205ff1f43Iain MerrickTEST_F(SpdyProxyClientSocketTest, ReadErrorResponseBody) { 825731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame()); 826731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockWrite writes[] = { 827731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockWrite(*conn, 0, false), 828731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 829731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 830731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectErrorReplyFrame()); 831731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1)); 832731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2)); 833731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead reads[] = { 834731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*resp, 1, true), 835731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*msg1, 2, true), 836731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*msg2, 3, true), 837731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead(true, 0, 4), // EOF 838731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 839731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 840731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Initialize(reads, arraysize(reads), writes, arraysize(writes)); 841731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 84221d179b334e59e9a3bfcaed4c4430bef1bc5759dKristian Monsen AssertConnectFails(ERR_HTTPS_PROXY_TUNNEL_RESPONSE); 843731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 844731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Run(2); // SpdySession consumes the next two reads and sends then to 845731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // sock_ to be buffered. 84621d179b334e59e9a3bfcaed4c4430bef1bc5759dKristian Monsen EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED, sock_->Read(NULL, 1, NULL)); 84721d179b334e59e9a3bfcaed4c4430bef1bc5759dKristian Monsen scoped_refptr<IOBuffer> buf(new IOBuffer(kLen1 + kLen2)); 84821d179b334e59e9a3bfcaed4c4430bef1bc5759dKristian Monsen scoped_ptr<HttpStream> stream(sock_->CreateConnectResponseStream()); 84921d179b334e59e9a3bfcaed4c4430bef1bc5759dKristian Monsen stream->ReadResponseBody(buf, kLen1 + kLen2, &read_callback_); 850731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 851731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 852731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// ----------- Reads and Writes 853731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 854731df977c0511bca2206b5f333555b1205ff1f43Iain MerrickTEST_F(SpdyProxyClientSocketTest, AsyncReadAroundWrite) { 855731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame()); 856731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2)); 857731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockWrite writes[] = { 858731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockWrite(*conn, 0, false), 859731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockWrite(*msg2, 3, false), 860731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 861731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 862731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame()); 863731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1)); 864731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> msg3(ConstructBodyFrame(kMsg3, kLen3)); 865731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead reads[] = { 866731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*resp, 1, true), 867731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*msg1, 2, true), // sync read 868731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*msg3, 4, true), // async read 869731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead(true, 0, 5), // EOF 870731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 871731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 872731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Initialize(reads, arraysize(reads), writes, arraysize(writes)); 873731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 874731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertConnectSucceeds(); 875731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 876731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Run(1); 877731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertSyncReadEquals(kMsg1, kLen1); 878731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 879731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertReadStarts(kMsg3, kLen3); 880731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // Read should block until after the write succeeds 881731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 882731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertAsyncWriteSucceeds(kMsg2, kLen2); // Runs 1 step 883731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 884731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ASSERT_FALSE(read_callback_.have_result()); 885731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Run(1); 886731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // Now the read will return 887731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertReadReturns(kMsg3, kLen3); 888731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 889731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 890731df977c0511bca2206b5f333555b1205ff1f43Iain MerrickTEST_F(SpdyProxyClientSocketTest, AsyncWriteAroundReads) { 891731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame()); 892731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2)); 893731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockWrite writes[] = { 894731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockWrite(*conn, 0, false), 895731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockWrite(*msg2, 4, true), 896731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 897731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 898731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame()); 899731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1)); 900731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> msg3(ConstructBodyFrame(kMsg3, kLen3)); 901731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead reads[] = { 902731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*resp, 1, true), 903731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*msg1, 2, true), 904731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*msg3, 3, true), 905731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead(true, 0, 5), // EOF 906731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 907731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 908731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Initialize(reads, arraysize(reads), writes, arraysize(writes)); 909731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 910731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertConnectSucceeds(); 911731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 912731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Run(1); 913731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertSyncReadEquals(kMsg1, kLen1); 914731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // Write should block until the read completes 915731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertWriteReturns(kMsg2, kLen2, ERR_IO_PENDING); 916731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 917731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertAsyncReadEquals(kMsg3, kLen3); 918731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 919731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ASSERT_FALSE(write_callback_.have_result()); 920731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 921731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // Now the write will complete 922731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Run(1); 923731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertWriteLength(kLen2); 924731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 925731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 926731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// ----------- Reading/Writing on Closed socket 927731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 928731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// Reading from an already closed socket should return 0 929731df977c0511bca2206b5f333555b1205ff1f43Iain MerrickTEST_F(SpdyProxyClientSocketTest, ReadOnClosedSocketReturnsZero) { 930731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame()); 931731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockWrite writes[] = { 932731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockWrite(*conn, 0, false), 933731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 934731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 935731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame()); 936731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead reads[] = { 937731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*resp, 1, true), 938731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead(true, 0, 2), // EOF 939731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 940731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 941731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Initialize(reads, arraysize(reads), writes, arraysize(writes)); 942731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 943731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertConnectSucceeds(); 944731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 945731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Run(1); 946731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 947731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ASSERT_EQ(0, sock_->Read(NULL, 1, NULL)); 948731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ASSERT_EQ(ERR_CONNECTION_CLOSED, sock_->Read(NULL, 1, NULL)); 949731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ASSERT_EQ(ERR_CONNECTION_CLOSED, sock_->Read(NULL, 1, NULL)); 950731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 951731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 952731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// Read pending when socket is closed should return 0 953731df977c0511bca2206b5f333555b1205ff1f43Iain MerrickTEST_F(SpdyProxyClientSocketTest, PendingReadOnCloseReturnsZero) { 954731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame()); 955731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockWrite writes[] = { 956731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockWrite(*conn, 0, false), 957731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 958731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 959731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame()); 960731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead reads[] = { 961731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*resp, 1, true), 962731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead(true, 0, 2), // EOF 963731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 964731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 965731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Initialize(reads, arraysize(reads), writes, arraysize(writes)); 966731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 967731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertConnectSucceeds(); 968731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 969731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertReadStarts(kMsg1, kLen1); 970731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 971731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Run(1); 972731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 973731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ASSERT_EQ(0, read_callback_.WaitForResult()); 974731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 975731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 976731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// Reading from a disconnected socket is an error 977731df977c0511bca2206b5f333555b1205ff1f43Iain MerrickTEST_F(SpdyProxyClientSocketTest, ReadOnDisconnectSocketReturnsNotConnected) { 978731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame()); 979731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockWrite writes[] = { 980731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockWrite(*conn, 0, false), 981731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 982731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 983731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame()); 984731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead reads[] = { 985731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*resp, 1, true), 986731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead(true, 0, 2), // EOF 987731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 988731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 989731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Initialize(reads, arraysize(reads), writes, arraysize(writes)); 990731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 991731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertConnectSucceeds(); 992731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 993731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick sock_->Disconnect(); 994731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 995731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ASSERT_EQ(ERR_SOCKET_NOT_CONNECTED, sock_->Read(NULL, 1, NULL)); 996731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 997731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 998731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// Reading buffered data from an already closed socket should return 999731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// buffered data, then 0. 1000731df977c0511bca2206b5f333555b1205ff1f43Iain MerrickTEST_F(SpdyProxyClientSocketTest, ReadOnClosedSocketReturnsBufferedData) { 1001731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame()); 1002731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockWrite writes[] = { 1003731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockWrite(*conn, 0, false), 1004731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 1005731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1006731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame()); 1007731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1)); 1008731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead reads[] = { 1009731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*resp, 1, true), 1010731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*msg1, 2, true), 1011731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead(true, 0, 3), // EOF 1012731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 1013731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1014731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Initialize(reads, arraysize(reads), writes, arraysize(writes)); 1015731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1016731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertConnectSucceeds(); 1017731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1018731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Run(2); 1019731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1020731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertSyncReadEquals(kMsg1, kLen1); 1021731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ASSERT_EQ(0, sock_->Read(NULL, 1, NULL)); 1022731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ASSERT_EQ(ERR_CONNECTION_CLOSED, sock_->Read(NULL, 1, NULL)); 1023731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick // Verify that read *still* returns ERR_CONNECTION_CLOSED 1024731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ASSERT_EQ(ERR_CONNECTION_CLOSED, sock_->Read(NULL, 1, NULL)); 1025731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 1026731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1027731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// Calling Write() on a closed socket is an error 1028731df977c0511bca2206b5f333555b1205ff1f43Iain MerrickTEST_F(SpdyProxyClientSocketTest, WriteOnClosedStream) { 1029731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame()); 1030731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockWrite writes[] = { 1031731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockWrite(*conn, 0, false), 1032731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 1033731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1034731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame()); 1035731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1)); 1036731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead reads[] = { 1037731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*resp, 1, true), 1038731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead(true, 0, 2), // EOF 1039731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 1040731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1041731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Initialize(reads, arraysize(reads), writes, arraysize(writes)); 1042731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1043731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertConnectSucceeds(); 1044731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1045731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Run(1); // Read EOF which will close the stream 1046731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_refptr<IOBufferWithSize> buf(CreateBuffer(kMsg1, kLen1)); 1047731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick EXPECT_EQ(ERR_CONNECTION_CLOSED, sock_->Write(buf, buf->size(), NULL)); 1048731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 1049731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1050731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// Calling Write() on a disconnected socket is an error 1051731df977c0511bca2206b5f333555b1205ff1f43Iain MerrickTEST_F(SpdyProxyClientSocketTest, WriteOnDisconnectedSocket) { 1052731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame()); 1053731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockWrite writes[] = { 1054731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockWrite(*conn, 0, false), 1055731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 1056731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1057731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame()); 1058731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1)); 1059731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead reads[] = { 1060731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*resp, 1, true), 1061731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead(true, 0, 2), // EOF 1062731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 1063731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1064731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Initialize(reads, arraysize(reads), writes, arraysize(writes)); 1065731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1066731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertConnectSucceeds(); 1067731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1068731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick sock_->Disconnect(); 1069731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1070731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_refptr<IOBufferWithSize> buf(CreateBuffer(kMsg1, kLen1)); 1071731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED, sock_->Write(buf, buf->size(), NULL)); 1072731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 1073731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1074731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// If the socket is closed with a pending Write(), the callback 1075731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// should be called with ERR_CONNECTION_CLOSED. 1076731df977c0511bca2206b5f333555b1205ff1f43Iain MerrickTEST_F(SpdyProxyClientSocketTest, WritePendingOnClose) { 1077731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame()); 1078731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockWrite writes[] = { 1079731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockWrite(*conn, 0, false), 1080731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockWrite(true, ERR_IO_PENDING, 2), 1081731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 1082731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1083731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame()); 1084731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead reads[] = { 1085731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*resp, 1, true), 1086731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead(true, 0, 3), // EOF 1087731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 1088731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1089731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Initialize(reads, arraysize(reads), writes, arraysize(writes)); 1090731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1091731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertConnectSucceeds(); 1092731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1093731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick EXPECT_TRUE(sock_->IsConnected()); 1094731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1095731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_refptr<IOBufferWithSize> buf(CreateBuffer(kMsg1, kLen1)); 1096731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick EXPECT_EQ(ERR_IO_PENDING, sock_->Write(buf, buf->size(), &write_callback_)); 1097731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1098731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Run(1); 1099731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1100731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick EXPECT_EQ(ERR_CONNECTION_CLOSED, write_callback_.WaitForResult()); 1101731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 1102731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1103731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// If the socket is Disconnected with a pending Write(), the callback 1104731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// should not be called. 1105731df977c0511bca2206b5f333555b1205ff1f43Iain MerrickTEST_F(SpdyProxyClientSocketTest, DisconnectWithWritePending) { 1106731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame()); 1107731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockWrite writes[] = { 1108731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockWrite(*conn, 0, false), 1109731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockWrite(false, 0, 2), // EOF 1110731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 1111731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1112731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame()); 1113731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead reads[] = { 1114731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*resp, 1, true), 1115731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead(true, 0, 3), // EOF 1116731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 1117731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1118731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Initialize(reads, arraysize(reads), writes, arraysize(writes)); 1119731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1120731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertConnectSucceeds(); 1121731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1122731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick EXPECT_TRUE(sock_->IsConnected()); 1123731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1124731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_refptr<IOBufferWithSize> buf(CreateBuffer(kMsg1, kLen1)); 1125731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick EXPECT_EQ(ERR_IO_PENDING, sock_->Write(buf, buf->size(), &write_callback_)); 1126731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1127731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick sock_->Disconnect(); 1128731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1129731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick EXPECT_FALSE(sock_->IsConnected()); 1130731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick EXPECT_FALSE(write_callback_.have_result()); 1131731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 1132731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1133731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// If the socket is Disconnected with a pending Read(), the callback 1134731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick// should not be called. 1135731df977c0511bca2206b5f333555b1205ff1f43Iain MerrickTEST_F(SpdyProxyClientSocketTest, DisconnectWithReadPending) { 1136731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame()); 1137731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockWrite writes[] = { 1138731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockWrite(*conn, 0, false), 1139731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 1140731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1141731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame()); 1142731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead reads[] = { 1143731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick CreateMockRead(*resp, 1, true), 1144731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick MockRead(true, 0, 2), // EOF 1145731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick }; 1146731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1147731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick Initialize(reads, arraysize(reads), writes, arraysize(writes)); 1148731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1149731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick AssertConnectSucceeds(); 1150731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1151731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick EXPECT_TRUE(sock_->IsConnected()); 1152731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1153731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick scoped_refptr<IOBuffer> buf(new IOBuffer(kLen1)); 1154731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ASSERT_EQ(ERR_IO_PENDING, sock_->Read(buf, kLen1, &read_callback_)); 1155731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1156731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick sock_->Disconnect(); 1157731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1158731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick EXPECT_FALSE(sock_->IsConnected()); 1159731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick EXPECT_FALSE(read_callback_.have_result()); 1160731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} 1161731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick 1162731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick} // namespace net 1163