Ensure SpdySession::StartGoingAway is always called with an error.

net/spdy/spdy_session_pool_unittest.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/spdy/spdy_session_pool.h"
 
 #include <cstddef>
 #include <string>
 
 #include "base/memory/ref_counted.h"
@@ skipping 519 matching lines @@
   CreateNetworkSession();
 
   // Set up session A: Going away, but with an active stream.
   session_deps_.socket_factory->AddSocketDataProvider(&data);
   const std::string kTestHostA("http://www.a.com");
   HostPortPair test_host_port_pairA(kTestHostA, 80);
   SpdySessionKey keyA(
       test_host_port_pairA, ProxyServer::Direct(), PRIVACY_MODE_DISABLED);
   base::WeakPtr<SpdySession> sessionA =
       CreateInsecureSpdySession(http_session_, keyA, BoundNetLog());
+
   GURL urlA(kTestHostA);
   base::WeakPtr<SpdyStream> spdy_streamA = CreateStreamSynchronously(
       SPDY_BIDIRECTIONAL_STREAM, sessionA, urlA, MEDIUM, BoundNetLog());
   test::StreamDelegateDoNothing delegateA(spdy_streamA);
   spdy_streamA->SetDelegate(&delegateA);
 
   scoped_ptr<SpdyHeaderBlock> headers(
       spdy_util.ConstructGetHeaderBlock(urlA.spec()));
   spdy_streamA->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND);
   EXPECT_TRUE(spdy_streamA->HasUrlFromHeaders());
 
   base::MessageLoop::current()->RunUntilIdle();  // Allow headers to write.
   EXPECT_TRUE(delegateA.send_headers_completed());
 
   sessionA->MakeUnavailable();
   EXPECT_TRUE(sessionA->IsGoingAway());
   EXPECT_FALSE(delegateA.StreamIsClosed());
 
-  // Set up session B: Available, but idle.
+  // Set up session B: Available, with a created stream.
   const std::string kTestHostB("http://www.b.com");
   HostPortPair test_host_port_pairB(kTestHostB, 80);
   SpdySessionKey keyB(
       test_host_port_pairB, ProxyServer::Direct(), PRIVACY_MODE_DISABLED);
   base::WeakPtr<SpdySession> sessionB =
       CreateInsecureSpdySession(http_session_, keyB, BoundNetLog());
   EXPECT_TRUE(sessionB->IsAvailable());
 
+  GURL urlB(kTestHostB);
+  base::WeakPtr<SpdyStream> spdy_streamB = CreateStreamSynchronously(
+      SPDY_BIDIRECTIONAL_STREAM, sessionB, urlB, MEDIUM, BoundNetLog());
+  test::StreamDelegateDoNothing delegateB(spdy_streamB);
+  spdy_streamB->SetDelegate(&delegateB);
+
   // Set up session C: Draining.
   session_deps_.socket_factory->AddSocketDataProvider(&data);
   const std::string kTestHostC("http://www.c.com");
   HostPortPair test_host_port_pairC(kTestHostC, 80);
   SpdySessionKey keyC(
       test_host_port_pairC, ProxyServer::Direct(), PRIVACY_MODE_DISABLED);
   base::WeakPtr<SpdySession> sessionC =
       CreateInsecureSpdySession(http_session_, keyC, BoundNetLog());
 
   sessionC->CloseSessionOnError(ERR_SPDY_PROTOCOL_ERROR, "Error!");
   EXPECT_TRUE(sessionC->IsDraining());
 
   spdy_session_pool_->OnIPAddressChanged();
 
 #if defined(OS_ANDROID) || defined(OS_WIN) || defined(OS_IOS)
   EXPECT_TRUE(sessionA->IsGoingAway());
   EXPECT_TRUE(sessionB->IsDraining());
   EXPECT_TRUE(sessionC->IsDraining());
 
-  EXPECT_EQ(1u, sessionA->num_active_streams());  // Stream is still active.
+  EXPECT_EQ(1u,
+            sessionA->num_active_streams());  // Active stream is still active.
   EXPECT_FALSE(delegateA.StreamIsClosed());
 
+  EXPECT_TRUE(delegateB.StreamIsClosed());  // Created stream was closed.
+  EXPECT_EQ(ERR_NETWORK_CHANGED, delegateB.WaitForClose());
+
   sessionA->CloseSessionOnError(ERR_ABORTED, "Closing");
   sessionB->CloseSessionOnError(ERR_ABORTED, "Closing");
 
   EXPECT_TRUE(delegateA.StreamIsClosed());
   EXPECT_EQ(ERR_ABORTED, delegateA.WaitForClose());
 #else
   EXPECT_TRUE(sessionA->IsDraining());
   EXPECT_TRUE(sessionB->IsDraining());
   EXPECT_TRUE(sessionC->IsDraining());
 
+  // Both streams were closed with an error.
   EXPECT_TRUE(delegateA.StreamIsClosed());
   EXPECT_EQ(ERR_NETWORK_CHANGED, delegateA.WaitForClose());
+  EXPECT_TRUE(delegateB.StreamIsClosed());
+  EXPECT_EQ(ERR_NETWORK_CHANGED, delegateB.WaitForClose());
 #endif  // defined(OS_ANDROID) || defined(OS_WIN) || defined(OS_IOS)
 }
 
 }  // namespace
 
 }  // namespace net