Refactor SocketStream to report error to the delegate.

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 71 matching lines @@
 void SocketStream::set_context(URLRequestContext* context) {
   context_ = context;
 }
 
 void SocketStream::Connect() {
   DCHECK(MessageLoop::current()) <<
       "The current MessageLoop must exist";
   DCHECK_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type()) <<
       "The current MessageLoop must be TYPE_IO";
   ssl_config_service()->GetSSLConfig(&ssl_config_);
+  DCHECK_EQ(next_state_, STATE_NONE);
 
   AddRef();  // Released in Finish()
   // Open a connection asynchronously, so that delegate won't be called
   // back before returning Connect().
   next_state_ = STATE_RESOLVE_PROXY;
   MessageLoop::current()->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &SocketStream::DoLoop, OK));
 }
 
 bool SocketStream::SendData(const char* data, int len) {
   DCHECK(MessageLoop::current()) <<
       "The current MessageLoop must exist";
   DCHECK_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type()) <<
       "The current MessageLoop must be TYPE_IO";
-  if (!socket_.get() || !socket_->IsConnected())
+  if (!socket_.get() || !socket_->IsConnected() || next_state_ == STATE_NONE)
     return false;
   if (write_buf_) {
     int current_amount_send = write_buf_size_ - write_buf_offset_;
     for (PendingDataQueue::const_iterator iter = pending_write_bufs_.begin();
          iter != pending_write_bufs_.end();
          ++iter)
       current_amount_send += (*iter)->size();
 
     current_amount_send += len;
     if (current_amount_send > max_pending_send_allowed_)
@@ skipping 14 matching lines @@
       FROM_HERE,
       NewRunnableMethod(this, &SocketStream::DoLoop, OK));
   return true;
 }
 
 void SocketStream::Close() {
   DCHECK(MessageLoop::current()) <<
       "The current MessageLoop must exist";
   DCHECK_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type()) <<
       "The current MessageLoop must be TYPE_IO";
-  if (!socket_.get())
+  if (!socket_.get() || !socket_->IsConnected() || next_state_ == STATE_NONE)
     return;
-  if (socket_->IsConnected())
-    socket_->Disconnect();
+  socket_->Disconnect();
+  next_state_ = STATE_CLOSE;
   // Close asynchronously, so that delegate won't be called
   // back before returning Close().
   MessageLoop::current()->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &SocketStream::DoLoop, OK));
 }
 
 void SocketStream::RestartWithAuth(
     const std::wstring& username, const std::wstring& password) {
   DCHECK(MessageLoop::current()) <<
@@ skipping 19 matching lines @@
       NewRunnableMethod(this, &SocketStream::DoRestartWithAuth));
 }
 
 void SocketStream::DetachDelegate() {
   if (!delegate_)
     return;
   delegate_ = NULL;
   Close();
 }
 
-void SocketStream::Finish() {
+void SocketStream::Finish(int result) {
   DCHECK(MessageLoop::current()) <<
       "The current MessageLoop must exist";
   DCHECK_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type()) <<
       "The current MessageLoop must be TYPE_IO";
+  DCHECK_LT(result, 0);
+  DCHECK_EQ(next_state_, STATE_NONE);
   DLOG(INFO) << "Finish";
+  if (delegate_)
+    delegate_->OnError(this, result);
+
   Delegate* delegate = delegate_;
   delegate_ = NULL;
   if (delegate) {
     delegate->OnClose(this);
-    Release();
   }
+  Release();
 }
 
 void SocketStream::SetHostResolver(HostResolver* host_resolver) {
   DCHECK(host_resolver);
   host_resolver_ = host_resolver;
 }
 
 void SocketStream::SetClientSocketFactory(
     ClientSocketFactory* factory) {
   DCHECK(factory);
   factory_ = factory;
 }
 
-void SocketStream::DidEstablishConnection() {
+int SocketStream::DidEstablishConnection() {
   if (!socket_.get() || !socket_->IsConnected()) {
-    Finish();
-    return;
+    return ERR_CONNECTION_FAILED;
   }
   next_state_ = STATE_READ_WRITE;
 
   if (delegate_)
     delegate_->OnConnected(this, max_pending_send_allowed_);
 
-  return;
+  return OK;
 }
 
 void SocketStream::DidReceiveData(int result) {
   DCHECK(read_buf_);
   DCHECK_GT(result, 0);
   if (!delegate_)
     return;
   // Notify recevied data to delegate.
   delegate_->OnReceivedData(this, read_buf_->data(), result);
   read_buf_ = NULL;
@@ skipping 17 matching lines @@
       write_buf_ = NULL;
     }
     write_buf_offset_ = 0;
   } else {
     write_buf_offset_ += result;
   }
 }
 
 void SocketStream::OnIOCompleted(int result) {
   DoLoop(result);
-  // TODO(ukai): notify error.
 }
 
 void SocketStream::OnReadCompleted(int result) {
-  // TODO(ukai): notify error.
   if (result == 0) {
     // 0 indicates end-of-file, so socket was closed.
-    next_state_ = STATE_NONE;
+    next_state_ = STATE_CLOSE;
   } else if (result > 0 && read_buf_) {
     DidReceiveData(result);
     result = OK;
   }
   DoLoop(result);
 }
 
 void SocketStream::OnWriteCompleted(int result) {
-  // TODO(ukai): notify error.
   if (result >= 0 && write_buf_) {
     DidSendData(result);
     result = OK;
   }
   DoLoop(result);
 }
 
-int SocketStream::DoLoop(int result) {
-  if (next_state_ == STATE_NONE) {
-    Finish();
-    return ERR_CONNECTION_CLOSED;
-  }
+void SocketStream::DoLoop(int result) {
+  if (next_state_ == STATE_NONE)
+    return;
 
   do {
     State state = next_state_;
     next_state_ = STATE_NONE;
     switch (state) {
       case STATE_RESOLVE_PROXY:
         DCHECK_EQ(OK, result);
         result = DoResolveProxy();
         break;
       case STATE_RESOLVE_PROXY_COMPLETE:
@@ skipping 37 matching lines @@
       case STATE_SSL_CONNECT:
         DCHECK_EQ(OK, result);
         result = DoSSLConnect();
         break;
       case STATE_SSL_CONNECT_COMPLETE:
         result = DoSSLConnectComplete(result);
         break;
       case STATE_READ_WRITE:
         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;
         break;
     }
-  } while (result != ERR_IO_PENDING && next_state_ != STATE_NONE);
-
-  if (result != ERR_IO_PENDING)
-    Finish();
-
-  return result;
+  } while (result != ERR_IO_PENDING);
 }
 
 int SocketStream::DoResolveProxy() {
   DCHECK(!pac_request_);
   next_state_ = STATE_RESOLVE_PROXY_COMPLETE;
 
   return proxy_service()->ResolveProxy(
       url_, &proxy_info_, &io_callback_, &pac_request_, NULL);
 }
 
 int SocketStream::DoResolveProxyComplete(int result) {
   next_state_ = STATE_RESOLVE_HOST;
 
   pac_request_ = NULL;
   if (result != OK) {
     LOG(ERROR) << "Failed to resolve proxy: " << result;
+    if (delegate_)
+      delegate_->OnError(this, result);
     proxy_info_.UseDirect();
   }
 
   return OK;
 }
 
 int SocketStream::DoResolveHost() {
   next_state_ = STATE_RESOLVE_HOST_COMPLETE;
 
   if (proxy_info_.is_direct())
@@ skipping 40 matching lines @@
   if (result != OK)
     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 {
-    DidEstablishConnection();
+    result = DidEstablishConnection();
   }
-  return OK;
+  return result;
 }
 
 int SocketStream::DoWriteTunnelHeaders() {
   DCHECK_EQ(kTunnelProxy, proxy_mode_);
 
   next_state_ = STATE_WRITE_TUNNEL_HEADERS_COMPLETE;
 
   if (!tunnel_request_headers_.get()) {
     tunnel_request_headers_ = new RequestHeaders();
     tunnel_request_headers_bytes_sent_ = 0;
@@ skipping 81 matching lines @@
 }
 
 int SocketStream::DoReadTunnelHeadersComplete(int result) {
   DCHECK_EQ(kTunnelProxy, proxy_mode_);
 
   if (result < 0)
     return result;
 
   if (result == 0) {
     // 0 indicates end-of-file, so socket was closed.
-    Finish();
-    return result;
+    next_state_ = STATE_CLOSE;
+    return ERR_CONNECTION_CLOSED;
   }
 
   tunnel_response_headers_len_ += result;
   DCHECK(tunnel_response_headers_len_ <= tunnel_response_headers_capacity_);
 
   int eoh = HttpUtil::LocateEndOfHeaders(
       tunnel_response_headers_->headers(), tunnel_response_headers_len_, 0);
   if (eoh == -1) {
-    if (tunnel_response_headers_len_ >= kMaxTunnelResponseHeadersSize)
+    if (tunnel_response_headers_len_ >= kMaxTunnelResponseHeadersSize) {
+      next_state_ = STATE_CLOSE;
       return ERR_RESPONSE_HEADERS_TOO_BIG;
+    }
 
     next_state_ = STATE_READ_TUNNEL_HEADERS;
     return OK;
   }
   // DidReadResponseHeaders
   scoped_refptr<HttpResponseHeaders> headers;
   headers = new HttpResponseHeaders(
       HttpUtil::AssembleRawHeaders(tunnel_response_headers_->headers(), eoh));
   if (headers->GetParsedHttpVersion() < HttpVersion(1, 0)) {
     // Require the "HTTP/1.x" status line.
+    next_state_ = STATE_CLOSE;
     return ERR_TUNNEL_CONNECTION_FAILED;
   }
   switch (headers->response_code()) {
     case 200:  // OK
       if (is_secure()) {
         DCHECK_EQ(eoh, tunnel_response_headers_len_);
         next_state_ = STATE_SSL_CONNECT;
       } else {
-        DidEstablishConnection();
+        result = DidEstablishConnection();
+        if (result < 0) {
+          next_state_ = STATE_CLOSE;
+          return result;
+        }
         if ((eoh < tunnel_response_headers_len_) && delegate_)
           delegate_->OnReceivedData(
               this, tunnel_response_headers_->headers() + eoh,
               tunnel_response_headers_len_ - eoh);
       }
       return OK;
     case 407:  // Proxy Authentication Required.
       result = HandleAuthChallenge(headers.get());
       if (result == ERR_PROXY_AUTH_REQUESTED &&
           auth_handler_.get() && delegate_) {
         auth_info_ = new AuthChallengeInfo;
         auth_info_->is_proxy = true;
         auth_info_->host_and_port =
             ASCIIToWide(proxy_info_.proxy_server().host_and_port());
         auth_info_->scheme = ASCIIToWide(auth_handler_->scheme());
         auth_info_->realm = ASCIIToWide(auth_handler_->realm());
         // 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;
   }
   return ERR_TUNNEL_CONNECTION_FAILED;
 }
 
 int SocketStream::DoSOCKSConnect() {
   DCHECK_EQ(kSOCKSProxy, proxy_mode_);
@@ skipping 30 matching lines @@
       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)
-    DidEstablishConnection();
+    result = DidEstablishConnection();
   return result;
 }
 
 int SocketStream::DoReadWrite(int result) {
   if (result < OK) {
-    Finish();
     return result;
   }
   if (!socket_.get() || !socket_->IsConnected()) {
-    Finish();
     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.
-      Finish();
       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)
       return result;
   }
   // Read is pending.
   DCHECK(read_buf_);
 
@@ skipping 67 matching lines @@
 }
 
 void SocketStream::DoAuthRequired() {
   if (delegate_ && auth_info_.get())
     delegate_->OnAuthRequired(this, auth_info_.get());
   else
     DoLoop(net::ERR_UNEXPECTED);
 }
 
 void SocketStream::DoRestartWithAuth() {
+  DCHECK_EQ(next_state_, STATE_AUTH_REQUIRED);
   auth_cache_.Add(ProxyAuthOrigin(), auth_handler_,
                   auth_identity_.username, auth_identity_.password,
                   std::string());
 
   tunnel_request_headers_ = NULL;
   tunnel_request_headers_bytes_sent_ = 0;
   tunnel_response_headers_ = NULL;
   tunnel_response_headers_capacity_ = 0;
   tunnel_response_headers_len_ = 0;
 
@@ skipping 21 matching lines @@
 
 SSLConfigService* SocketStream::ssl_config_service() const {
   return context_->ssl_config_service();
 }
 
 ProxyService* SocketStream::proxy_service() const {
   return context_->proxy_service();
 }
 
 }  // namespace net