Reland 'Fix SPDY error-handling if the connection gets closed just after use.'
Include a fix for a test to appease ASan.
Original description:
> - Make SpdySession::IsReused() return true if the underlying socket was
> UNUSED_IDLE. This makes the HttpNetworkTransaction-level retry try a fresh
> socket in case a preconnected socket was stale.
>
> - If the SpdySession closes in an event loop iteration between
> HttpStreamFactoryImplJob::DoCreateStream and OnNewSpdySessionReadyCallback,
> propogate the error to the request to prevent it from hanging. Do so by
> creating the originating request's SpdyHttpStream as soon as the SpdySession
> is created so it can sample SpdySession::IsReused() and advise
> HttpNetworkTransaction on error.
>
> - Delay pumping the SpdySession read loop by an event loop iteration. This
> simplifies some logic and ensures that HttpNetworkTransaction receives a
> SpdyHttpStream to advise retry logic. This does mean we lose the error code;
> it now follows the asynchronous case and turns into ERR_CONNECTION_CLOSED in
> SpdyHttpStream::InitializeStream.
>
> BUG=352156
>
> Review URL: https://codereview.chromium.org/200723004
BUG=352156
Review URL: https://codereview.chromium.org/199633019
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@259208 0039d316-1c4b-4281-b951-d872f2087c98
diff --git a/net/spdy/spdy_http_stream_unittest.cc b/net/spdy/spdy_http_stream_unittest.cc
index 5a58703..2142d58 100644
--- a/net/spdy/spdy_http_stream_unittest.cc
+++ b/net/spdy/spdy_http_stream_unittest.cc
@@ -8,6 +8,7 @@
#include "base/memory/scoped_ptr.h"
#include "base/message_loop/message_loop_proxy.h"
+#include "base/run_loop.h"
#include "base/stl_util.h"
#include "crypto/ec_private_key.h"
#include "crypto/ec_signature_creator.h"
@@ -149,6 +150,9 @@
UploadProgress progress = stream.GetUploadProgress();
EXPECT_EQ(0u, progress.size());
EXPECT_EQ(0u, progress.position());
+
+ // Pump the event loop so |reads| is consumed before the function returns.
+ base::RunLoop().RunUntilIdle();
}
TEST_P(SpdyHttpStreamTest, SendRequest) {
diff --git a/net/spdy/spdy_session.cc b/net/spdy/spdy_session.cc
index c20d89e4..5f0e285 100644
--- a/net/spdy/spdy_session.cc
+++ b/net/spdy/spdy_session.cc
@@ -532,7 +532,7 @@
net_log_.EndEvent(NetLog::TYPE_SPDY_SESSION);
}
-Error SpdySession::InitializeWithSocket(
+void SpdySession::InitializeWithSocket(
scoped_ptr<ClientSocketHandle> connection,
SpdySessionPool* pool,
bool is_secure,
@@ -593,19 +593,17 @@
NetLog::TYPE_SPDY_SESSION_INITIALIZED,
connection_->socket()->NetLog().source().ToEventParametersCallback());
- int error = DoReadLoop(READ_STATE_DO_READ, OK);
- if (error == ERR_IO_PENDING)
- error = OK;
- if (error == OK) {
- DCHECK_NE(availability_state_, STATE_CLOSED);
- connection_->AddHigherLayeredPool(this);
- if (enable_sending_initial_data_)
- SendInitialData();
- pool_ = pool;
- } else {
- DcheckClosed();
- }
- return static_cast<Error>(error);
+ DCHECK_NE(availability_state_, STATE_CLOSED);
+ connection_->AddHigherLayeredPool(this);
+ if (enable_sending_initial_data_)
+ SendInitialData();
+ pool_ = pool;
+
+ // Bootstrap the read loop.
+ base::MessageLoop::current()->PostTask(
+ FROM_HERE,
+ base::Bind(&SpdySession::PumpReadLoop,
+ weak_factory_.GetWeakPtr(), READ_STATE_DO_READ, OK));
}
bool SpdySession::VerifyDomainAuthentication(const std::string& domain) {
@@ -1554,9 +1552,8 @@
UMA_HISTOGRAM_CUSTOM_COUNTS("Net.SpdySession.BytesRead.OtherErrors",
total_bytes_received_, 1, 100000000, 50);
- // |pool_| will be NULL when |InitializeWithSocket()| is in the
- // call stack.
- if (pool_ && availability_state_ != STATE_GOING_AWAY)
+ DCHECK(pool_);
+ if (availability_state_ != STATE_GOING_AWAY)
pool_->MakeSessionUnavailable(GetWeakPtr());
availability_state_ = STATE_CLOSED;
@@ -1628,10 +1625,8 @@
void SpdySession::MakeUnavailable() {
if (availability_state_ < STATE_GOING_AWAY) {
availability_state_ = STATE_GOING_AWAY;
- // |pool_| will be NULL when |InitializeWithSocket()| is in the
- // call stack.
- if (pool_)
- pool_->MakeSessionUnavailable(GetWeakPtr());
+ DCHECK(pool_);
+ pool_->MakeSessionUnavailable(GetWeakPtr());
}
}
@@ -1686,7 +1681,8 @@
}
bool SpdySession::IsReused() const {
- return buffered_spdy_framer_->frames_received() > 0;
+ return buffered_spdy_framer_->frames_received() > 0 ||
+ connection_->reuse_type() == ClientSocketHandle::UNUSED_IDLE;
}
bool SpdySession::GetLoadTimingInfo(SpdyStreamId stream_id,
diff --git a/net/spdy/spdy_session.h b/net/spdy/spdy_session.h
index cbb87bf8..203f1ef 100644
--- a/net/spdy/spdy_session.h
+++ b/net/spdy/spdy_session.h
@@ -256,13 +256,13 @@
// |certificate_error_code| must either be OK or less than
// ERR_IO_PENDING.
//
- // Returns OK on success, or an error on failure. Never returns
- // ERR_IO_PENDING. If an error is returned, the session must be
- // destroyed immediately.
- Error InitializeWithSocket(scoped_ptr<ClientSocketHandle> connection,
- SpdySessionPool* pool,
- bool is_secure,
- int certificate_error_code);
+ // The session begins reading from |connection| on a subsequent event loop
+ // iteration, so the SpdySession may close immediately afterwards if the first
+ // read of |connection| fails.
+ void InitializeWithSocket(scoped_ptr<ClientSocketHandle> connection,
+ SpdySessionPool* pool,
+ bool is_secure,
+ int certificate_error_code);
// Returns the protocol used by this session. Always between
// kProtoSPDYMinimumVersion and kProtoSPDYMaximumVersion.
@@ -367,7 +367,8 @@
base::Value* GetInfoAsValue() const;
// Indicates whether the session is being reused after having successfully
- // used to send/receive data in the past.
+ // used to send/receive data in the past or if the underlying socket was idle
+ // before being used for a SPDY session.
bool IsReused() const;
// Returns true if the underlying transport socket ever had any reads or
@@ -617,8 +618,7 @@
// Advance the ReadState state machine. |expected_read_state| is the
// expected starting read state.
//
- // This function must always be called via PumpReadLoop() except for
- // from InitializeWithSocket().
+ // This function must always be called via PumpReadLoop().
int DoReadLoop(ReadState expected_read_state, int result);
// The implementations of the states of the ReadState state machine.
int DoRead();
diff --git a/net/spdy/spdy_session_pool.cc b/net/spdy/spdy_session_pool.cc
index 093db1e..6ce0a93 100644
--- a/net/spdy/spdy_session_pool.cc
+++ b/net/spdy/spdy_session_pool.cc
@@ -77,12 +77,11 @@
CertDatabase::GetInstance()->RemoveObserver(this);
}
-net::Error SpdySessionPool::CreateAvailableSessionFromSocket(
+base::WeakPtr<SpdySession> SpdySessionPool::CreateAvailableSessionFromSocket(
const SpdySessionKey& key,
scoped_ptr<ClientSocketHandle> connection,
const BoundNetLog& net_log,
int certificate_error_code,
- base::WeakPtr<SpdySession>* available_session,
bool is_secure) {
DCHECK_GE(default_protocol_, kProtoSPDYMinimumVersion);
DCHECK_LE(default_protocol_, kProtoSPDYMaximumVersion);
@@ -105,22 +104,16 @@
trusted_spdy_proxy_,
net_log.net_log()));
- Error error = new_session->InitializeWithSocket(
+ new_session->InitializeWithSocket(
connection.Pass(), this, is_secure, certificate_error_code);
- DCHECK_NE(error, ERR_IO_PENDING);
- if (error != OK) {
- available_session->reset();
- return error;
- }
-
- *available_session = new_session->GetWeakPtr();
+ base::WeakPtr<SpdySession> available_session = new_session->GetWeakPtr();
sessions_.insert(new_session.release());
- MapKeyToAvailableSession(key, *available_session);
+ MapKeyToAvailableSession(key, available_session);
net_log.AddEvent(
NetLog::TYPE_SPDY_SESSION_POOL_IMPORTED_SESSION_FROM_SOCKET,
- (*available_session)->net_log().source().ToEventParametersCallback());
+ available_session->net_log().source().ToEventParametersCallback());
// Look up the IP address for this session so that we can match
// future sessions (potentially to different domains) which can
@@ -129,11 +122,11 @@
// to see if this is a direct connection.
if (key.proxy_server().is_direct()) {
IPEndPoint address;
- if ((*available_session)->GetPeerAddress(&address) == OK)
+ if (available_session->GetPeerAddress(&address) == OK)
aliases_[address] = key;
}
- return error;
+ return available_session;
}
base::WeakPtr<SpdySession> SpdySessionPool::FindAvailableSession(
diff --git a/net/spdy/spdy_session_pool.h b/net/spdy/spdy_session_pool.h
index c44e9de..0fad5d2 100644
--- a/net/spdy/spdy_session_pool.h
+++ b/net/spdy/spdy_session_pool.h
@@ -79,15 +79,14 @@
// encountered when connecting the SSL socket, with OK meaning there
// was no error.
//
- // If successful, OK is returned and |available_session| will be
- // non-NULL and available. Otherwise, an error is returned and
- // |available_session| will be NULL.
- net::Error CreateAvailableSessionFromSocket(
+ // Returns the new SpdySession. Note that the SpdySession begins reading from
+ // |connection| on a subsequent event loop iteration, so it may be closed
+ // immediately afterwards if the first read of |connection| fails.
+ base::WeakPtr<SpdySession> CreateAvailableSessionFromSocket(
const SpdySessionKey& key,
scoped_ptr<ClientSocketHandle> connection,
const BoundNetLog& net_log,
int certificate_error_code,
- base::WeakPtr<SpdySession>* available_session,
bool is_secure);
// Find an available session for the given key, or NULL if there isn't one.
diff --git a/net/spdy/spdy_session_unittest.cc b/net/spdy/spdy_session_unittest.cc
index 0e8b370..a5d9292 100644
--- a/net/spdy/spdy_session_unittest.cc
+++ b/net/spdy/spdy_session_unittest.cc
@@ -190,8 +190,12 @@
TEST_P(SpdySessionTest, InitialReadError) {
CreateDeterministicNetworkSession();
- TryCreateFakeSpdySessionExpectingFailure(
+ base::WeakPtr<SpdySession> session = TryCreateFakeSpdySessionExpectingFailure(
spdy_session_pool_, key_, ERR_FAILED);
+ EXPECT_TRUE(session);
+ // Flush the read.
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(session);
}
namespace {
@@ -277,8 +281,6 @@
session->CloseSessionOnError(ERR_ABORTED, "Aborting session");
EXPECT_EQ(ERR_ABORTED, callback1.WaitForResult());
-
- data.RunFor(1);
}
// A session receiving a GOAWAY frame with no active streams should
@@ -330,9 +332,12 @@
data.StopAfter(1);
- TryCreateInsecureSpdySessionExpectingFailure(
- http_session_, key_, ERR_CONNECTION_CLOSED, BoundNetLog());
+ base::WeakPtr<SpdySession> session =
+ TryCreateInsecureSpdySessionExpectingFailure(
+ http_session_, key_, ERR_CONNECTION_CLOSED, BoundNetLog());
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(session);
EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_));
}
@@ -1045,8 +1050,6 @@
EXPECT_TRUE(session == NULL);
EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_));
-
- data.RunFor(1);
EXPECT_EQ(NULL, spdy_stream1.get());
}
diff --git a/net/spdy/spdy_test_util_common.cc b/net/spdy/spdy_test_util_common.cc
index 66a6f8c3..22ff5f6 100644
--- a/net/spdy/spdy_test_util_common.cc
+++ b/net/spdy/spdy_test_util_common.cc
@@ -540,15 +540,12 @@
EXPECT_EQ(OK, rv);
- base::WeakPtr<SpdySession> spdy_session;
- EXPECT_EQ(
- expected_status,
+ base::WeakPtr<SpdySession> spdy_session =
http_session->spdy_session_pool()->CreateAvailableSessionFromSocket(
- key, connection.Pass(), net_log, OK, &spdy_session,
- is_secure));
- EXPECT_EQ(expected_status == OK, spdy_session != NULL);
- EXPECT_EQ(expected_status == OK,
- HasSpdySession(http_session->spdy_session_pool(), key));
+ key, connection.Pass(), net_log, OK, is_secure);
+ // Failure is reported asynchronously.
+ EXPECT_TRUE(spdy_session != NULL);
+ EXPECT_TRUE(HasSpdySession(http_session->spdy_session_pool(), key));
return spdy_session;
}
@@ -562,14 +559,14 @@
OK, false /* is_secure */);
}
-void TryCreateInsecureSpdySessionExpectingFailure(
+base::WeakPtr<SpdySession> TryCreateInsecureSpdySessionExpectingFailure(
const scoped_refptr<HttpNetworkSession>& http_session,
const SpdySessionKey& key,
Error expected_error,
const BoundNetLog& net_log) {
DCHECK_LT(expected_error, ERR_IO_PENDING);
- CreateSpdySessionHelper(http_session, key, net_log,
- expected_error, false /* is_secure */);
+ return CreateSpdySessionHelper(http_session, key, net_log,
+ expected_error, false /* is_secure */);
}
base::WeakPtr<SpdySession> CreateSecureSpdySession(
@@ -643,17 +640,15 @@
Error expected_status) {
EXPECT_NE(expected_status, ERR_IO_PENDING);
EXPECT_FALSE(HasSpdySession(pool, key));
- base::WeakPtr<SpdySession> spdy_session;
scoped_ptr<ClientSocketHandle> handle(new ClientSocketHandle());
handle->SetSocket(scoped_ptr<StreamSocket>(new FakeSpdySessionClientSocket(
expected_status == OK ? ERR_IO_PENDING : expected_status)));
- EXPECT_EQ(
- expected_status,
+ base::WeakPtr<SpdySession> spdy_session =
pool->CreateAvailableSessionFromSocket(
- key, handle.Pass(), BoundNetLog(), OK, &spdy_session,
- true /* is_secure */));
- EXPECT_EQ(expected_status == OK, spdy_session != NULL);
- EXPECT_EQ(expected_status == OK, HasSpdySession(pool, key));
+ key, handle.Pass(), BoundNetLog(), OK, true /* is_secure */);
+ // Failure is reported asynchronously.
+ EXPECT_TRUE(spdy_session != NULL);
+ EXPECT_TRUE(HasSpdySession(pool, key));
return spdy_session;
}
@@ -664,11 +659,12 @@
return CreateFakeSpdySessionHelper(pool, key, OK);
}
-void TryCreateFakeSpdySessionExpectingFailure(SpdySessionPool* pool,
- const SpdySessionKey& key,
- Error expected_error) {
+base::WeakPtr<SpdySession> TryCreateFakeSpdySessionExpectingFailure(
+ SpdySessionPool* pool,
+ const SpdySessionKey& key,
+ Error expected_error) {
DCHECK_LT(expected_error, ERR_IO_PENDING);
- CreateFakeSpdySessionHelper(pool, key, expected_error);
+ return CreateFakeSpdySessionHelper(pool, key, expected_error);
}
SpdySessionPoolPeer::SpdySessionPoolPeer(SpdySessionPool* pool) : pool_(pool) {
diff --git a/net/spdy/spdy_test_util_common.h b/net/spdy/spdy_test_util_common.h
index 42b595b68..668a7e8 100644
--- a/net/spdy/spdy_test_util_common.h
+++ b/net/spdy/spdy_test_util_common.h
@@ -247,8 +247,9 @@
// Tries to create a SPDY session for the given key but expects the
// attempt to fail with the given error. A SPDY session for |key| must
-// not already exist.
-void TryCreateInsecureSpdySessionExpectingFailure(
+// not already exist. The session will be created but close in the
+// next event loop iteration.
+base::WeakPtr<SpdySession> TryCreateInsecureSpdySessionExpectingFailure(
const scoped_refptr<HttpNetworkSession>& http_session,
const SpdySessionKey& key,
Error expected_error,
@@ -269,10 +270,12 @@
// Tries to create an insecure SPDY session for the given key but
// expects the attempt to fail with the given error. The session will
// neither receive nor send any data. A SPDY session for |key| must
-// not already exist.
-void TryCreateFakeSpdySessionExpectingFailure(SpdySessionPool* pool,
- const SpdySessionKey& key,
- Error expected_error);
+// not already exist. The session will be created but close in the
+// next event loop iteration.
+base::WeakPtr<SpdySession> TryCreateFakeSpdySessionExpectingFailure(
+ SpdySessionPool* pool,
+ const SpdySessionKey& key,
+ Error expected_error);
class SpdySessionPoolPeer {
public:
