Fix crash in GetSpdySessionFromSSLSocket in the case where the...

net/spdy/spdy_session.cc

 // Copyright (c) 2010 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.h"
 
 #include "base/basictypes.h"
 #include "base/linked_ptr.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 282 matching lines @@
   if (connection_->is_initialized()) {
     // With Spdy we can't recycle sockets.
     connection_->socket()->Disconnect();
   }
 
   RecordHistograms();
 
   net_log_.EndEvent(NetLog::TYPE_SPDY_SESSION, NULL);
 }
 
-void SpdySession::InitializeWithSSLSocket(ClientSocketHandle* connection) {
+net::Error SpdySession::InitializeWithSSLSocket(
+    ClientSocketHandle* connection) {
   static StatsCounter spdy_sessions("spdy.sessions");
   spdy_sessions.Increment();
 
   AdjustSocketBufferSizes(connection->socket());
 
   state_ = CONNECTED;
   connection_.reset(connection);
   is_secure_ = true;  // |connection| contains an SSLClientSocket.
 
   // This is a newly initialized session that no client should have a handle to
   // yet, so there's no need to start writing data as in OnTCPConnect(), but we
   // should start reading data.
-  ReadSocket();
+  net::Error error = ReadSocket();
+  if (error == ERR_IO_PENDING)
+    return OK;
+  return error;
 }
 
 net::Error SpdySession::Connect(const std::string& group_name,
                                 const TCPSocketParams& destination,
                                 RequestPriority priority) {
   DCHECK(priority >= SPDY_PRIORITY_HIGHEST && priority <= SPDY_PRIORITY_LOWEST);
 
   // If the connect process is started, let the caller continue.
   if (state_ > IDLE)
     return net::OK;
@@ skipping 13 matching lines @@
   if (rv == net::ERR_IO_PENDING)
     return net::OK;
   OnTCPConnect(rv);
   return static_cast<net::Error>(rv);
 }
 
 scoped_refptr<SpdyHttpStream> SpdySession::GetOrCreateStream(
     const HttpRequestInfo& request,
     const UploadDataStream* upload_data,
     const BoundNetLog& stream_net_log) {
+  CHECK_NE(state_, CLOSED);
   const GURL& url = request.url;
   const std::string& path = url.PathForRequest();
 
   scoped_refptr<SpdyHttpStream> stream;
 
   // Check if we have a push stream for this path.
   if (request.method == "GET") {
     // Only HTTP will push a stream.
     scoped_refptr<SpdyHttpStream> stream = GetPushStream(path);
     if (stream) {
@@ skipping 299 matching lines @@
     // message loop).
     WriteSocketLater();
   } else {
     in_flight_write_.release();
 
     // The stream is now errored.  Close it down.
     CloseSessionOnError(static_cast<net::Error>(result));
   }
 }
 
-void SpdySession::ReadSocket() {
+net::Error SpdySession::ReadSocket() {
   if (read_pending_)
-    return;
+    return OK;
 
   if (state_ == CLOSED) {
     NOTREACHED();
-    return;
+    return ERR_UNEXPECTED;
   }
 
   CHECK(connection_.get());
   CHECK(connection_->socket());
   int bytes_read = connection_->socket()->Read(read_buffer_.get(),
                                                kReadBufferSize,
                                                &read_callback_);
   switch (bytes_read) {
     case 0:
       // Socket is closed!
       CloseSessionOnError(ERR_CONNECTION_CLOSED);
-      return;
+      return ERR_CONNECTION_CLOSED;
     case net::ERR_IO_PENDING:
       // Waiting for data.  Nothing to do now.
       read_pending_ = true;
-      return;
+      return ERR_IO_PENDING;
     default:
       // Data was read, process it.
       // Schedule the work through the message loop to avoid recursive
       // callbacks.
       read_pending_ = true;
       MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
           this, &SpdySession::OnReadComplete, bytes_read));
       break;
   }
+  return OK;
 }
 
 void SpdySession::WriteSocketLater() {
   if (delayed_write_pending_)
     return;
 
   if (state_ < CONNECTED)
     return;
 
   delayed_write_pending_ = true;
@@ skipping 586 matching lines @@
           UMA_HISTOGRAM_CUSTOM_COUNTS("Net.SpdySettingsRetransRate",
                                       setting.second,
                                       1, 100, 50);
           break;
       }
     }
   }
 }
 
 }  // namespace net