Set STATE_CLOSE when error occured.

net/socket_stream/socket_stream.cc

 // Copyright (c) 2009 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.
 //
 // TODO(ukai): code is similar with http_network_transaction.cc.  We should
 //   think about ways to share code, if possible.
 
 #include "net/socket_stream/socket_stream.h"
 
 #include <string>
@@ skipping 197 matching lines @@
 }
 
 void SocketStream::SetClientSocketFactory(
     ClientSocketFactory* factory) {
   DCHECK(factory);
   factory_ = factory;
 }
 
 int SocketStream::DidEstablishConnection() {
   if (!socket_.get() || !socket_->IsConnected()) {
+    next_state_ = STATE_CLOSE;
     return ERR_CONNECTION_FAILED;
   }
   next_state_ = STATE_READ_WRITE;
 
   if (delegate_)
     delegate_->OnConnected(this, max_pending_send_allowed_);
 
   return OK;
 }
 
@@ skipping 114 matching lines @@
         result = DoReadWrite(result);
         break;
       case STATE_CLOSE:
         DCHECK_LE(result, OK);
         if (result == OK)
           result = ERR_CONNECTION_CLOSED;
         Finish(result);
         return;
       default:
         NOTREACHED() << "bad state";
-        result = ERR_UNEXPECTED;
+        Finish(result);
         break;
     }
   } while (result != ERR_IO_PENDING);
 }
 
 int SocketStream::DoResolveProxy() {
   DCHECK(!pac_request_);
   next_state_ = STATE_RESOLVE_PROXY_COMPLETE;
 
   return proxy_service()->ResolveProxy(
@@ skipping 38 matching lines @@
 
   HostResolver::RequestInfo resolve_info(host, port);
 
   resolver_.reset(new SingleRequestHostResolver(host_resolver_.get()));
   return resolver_->Resolve(resolve_info, &addresses_, &io_callback_, NULL);
 }
 
 int SocketStream::DoResolveHostComplete(int result) {
   if (result == OK)
     next_state_ = STATE_TCP_CONNECT;
+  else
+    next_state_ = STATE_CLOSE;
   // TODO(ukai): if error occured, reconsider proxy after error.
   return result;
 }
 
 int SocketStream::DoTcpConnect() {
   next_state_ = STATE_TCP_CONNECT_COMPLETE;
   DCHECK(factory_);
   socket_.reset(factory_->CreateTCPClientSocket(addresses_));
   return socket_->Connect(&io_callback_);
 }
 
 int SocketStream::DoTcpConnectComplete(int result) {
   // TODO(ukai): if error occured, reconsider proxy after error.
-  if (result != OK)
+  if (result != OK) {
+    next_state_ = STATE_CLOSE;
     return result;
+  }
 
   if (proxy_mode_ == kTunnelProxy)
     next_state_ = STATE_WRITE_TUNNEL_HEADERS;
   else if (proxy_mode_ == kSOCKSProxy)
     next_state_ = STATE_SOCKS_CONNECT;
   else if (is_secure()) {
     next_state_ = STATE_SSL_CONNECT;
   } else {
     result = DidEstablishConnection();
   }
@@ skipping 52 matching lines @@
   tunnel_request_headers_->SetDataOffset(tunnel_request_headers_bytes_sent_);
   int buf_len = static_cast<int>(tunnel_request_headers_->headers_.size() -
                                  tunnel_request_headers_bytes_sent_);
   DCHECK_GT(buf_len, 0);
   return socket_->Write(tunnel_request_headers_, buf_len, &io_callback_);
 }
 
 int SocketStream::DoWriteTunnelHeadersComplete(int result) {
   DCHECK_EQ(kTunnelProxy, proxy_mode_);
 
-  if (result < 0)
+  if (result < 0) {
+    next_state_ = STATE_CLOSE;
     return result;
+  }
 
   tunnel_request_headers_bytes_sent_ += result;
   if (tunnel_request_headers_bytes_sent_ <
       tunnel_request_headers_->headers_.size())
     next_state_ = STATE_WRITE_TUNNEL_HEADERS;
   else
     next_state_ = STATE_READ_TUNNEL_HEADERS;
   return OK;
 }
 
@@ skipping 13 matching lines @@
       tunnel_response_headers_len_;
   tunnel_response_headers_->SetDataOffset(tunnel_response_headers_len_);
   CHECK(tunnel_response_headers_->data());
 
   return socket_->Read(tunnel_response_headers_, buf_len, &io_callback_);
 }
 
 int SocketStream::DoReadTunnelHeadersComplete(int result) {
   DCHECK_EQ(kTunnelProxy, proxy_mode_);
 
-  if (result < 0)
+  if (result < 0) {
+    next_state_ = STATE_CLOSE;
     return result;
+  }
 
   if (result == 0) {
     // 0 indicates end-of-file, so socket was closed.
     next_state_ = STATE_CLOSE;
     return ERR_CONNECTION_CLOSED;
   }
 
   tunnel_response_headers_len_ += result;
   DCHECK(tunnel_response_headers_len_ <= tunnel_response_headers_capacity_);
 
@@ skipping 47 matching lines @@
         // Wait until RestartWithAuth or Close is called.
         MessageLoop::current()->PostTask(
             FROM_HERE,
             NewRunnableMethod(this, &SocketStream::DoAuthRequired));
         next_state_ = STATE_AUTH_REQUIRED;
         return ERR_IO_PENDING;
       }
     default:
       break;
   }
+  next_state_ = STATE_CLOSE;
   return ERR_TUNNEL_CONNECTION_FAILED;
 }
 
 int SocketStream::DoSOCKSConnect() {
   DCHECK_EQ(kSOCKSProxy, proxy_mode_);
 
   next_state_ = STATE_SOCKS_CONNECT_COMPLETE;
 
   ClientSocket* s = socket_.release();
   HostResolver::RequestInfo req_info(url_.HostNoBrackets(),
                                      url_.EffectiveIntPort());
 
   if (proxy_info_.proxy_server().scheme() == ProxyServer::SCHEME_SOCKS5)
     s = new SOCKS5ClientSocket(s, req_info, host_resolver_.get());
   else
     s = new SOCKSClientSocket(s, req_info, host_resolver_.get());
   socket_.reset(s);
   return socket_->Connect(&io_callback_);
 }
 
 int SocketStream::DoSOCKSConnectComplete(int result) {
   DCHECK_EQ(kSOCKSProxy, proxy_mode_);
 
   if (result == OK) {
     if (is_secure())
       next_state_ = STATE_SSL_CONNECT;
     else
       DidEstablishConnection();

[tyoshino (SeeGerritForStatus), 2009/11/02 02:18:27]

result = DidEstablishConnection ?

   }
   return result;
 }
 
 int SocketStream::DoSSLConnect() {
   DCHECK(factory_);
   socket_.reset(factory_->CreateSSLClientSocket(
       socket_.release(), url_.HostNoBrackets(), ssl_config_));
   next_state_ = STATE_SSL_CONNECT_COMPLETE;
   return socket_->Connect(&io_callback_);
 }
 
 int SocketStream::DoSSLConnectComplete(int result) {
   if (IsCertificateError(result))
     result = HandleCertificateError(result);
 
   if (result == OK)
     result = DidEstablishConnection();
+  else
+    next_state_ = STATE_CLOSE;
   return result;
 }
 
 int SocketStream::DoReadWrite(int result) {
   if (result < OK) {
+    next_state_ = STATE_CLOSE;
     return result;
   }
   if (!socket_.get() || !socket_->IsConnected()) {
+    next_state_ = STATE_CLOSE;
     return ERR_CONNECTION_CLOSED;
   }
 
   next_state_ = STATE_READ_WRITE;
 
   if (!read_buf_) {
     // No read pending.
     read_buf_ = new IOBuffer(kReadBufferSize);
     result = socket_->Read(read_buf_, kReadBufferSize, &read_callback_);
     if (result > 0) {
       DidReceiveData(result);
       return OK;
     } else if (result == 0) {
       // 0 indicates end-of-file, so socket was closed.
+      next_state_ = STATE_CLOSE;
       return ERR_CONNECTION_CLOSED;
     }
     // If read is pending, try write as well.
     // Otherwise, return the result and do next loop.
-    if (result != ERR_IO_PENDING)
+    if (result != ERR_IO_PENDING) {
+      next_state_ = STATE_CLOSE;
       return result;
+    }
   }
   // Read is pending.
   DCHECK(read_buf_);
 
   if (write_buf_ && !current_write_buf_) {
     // No write pending.
     current_write_buf_ = new DrainableIOBuffer(write_buf_, write_buf_size_);
     current_write_buf_->SetOffset(write_buf_offset_);
     result = socket_->Write(current_write_buf_,
                             current_write_buf_->BytesRemaining(),
                             &write_callback_);
     if (result > 0) {
       DidSendData(result);
       return OK;
     }

[tyoshino (SeeGerritForStatus), 2009/11/02 02:18:27]

Here, we should do the same as Read?
if (result != 0 && result != ERR_IO_PENDING) {
  next_state_ = STATE_CLOSE;
  return result;
}

     return result;
   }
 
   // We arrived here when both operation is pending.
   return ERR_IO_PENDING;
 }
 
 GURL SocketStream::ProxyAuthOrigin() const {
   return GURL("http://" + proxy_info_.proxy_server().host_and_port());
 }
@@ skipping 88 matching lines @@
 
 SSLConfigService* SocketStream::ssl_config_service() const {
   return context_->ssl_config_service();
 }
 
 ProxyService* SocketStream::proxy_service() const {
   return context_->proxy_service();
 }
 
 }  // namespace net