WebSocket over SPDY.

net/socket_stream/socket_stream.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.
 //
 // 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 <set>
@@ skipping 13 matching lines @@
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/socks5_client_socket.h"
 #include "net/socket/socks_client_socket.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/socket/tcp_client_socket.h"
 #include "net/socket_stream/socket_stream_metrics.h"
+#include "net/spdy/spdy_session.h"
+#include "net/spdy/spdy_stream.h"
 #include "net/url_request/url_request.h"
 
 static const int kMaxPendingSendAllowed = 32768;  // 32 kilobytes.
 static const int kReadBufferSize = 4096;
 
 namespace net {
 
 SocketStream::ResponseHeaders::ResponseHeaders() : IOBuffer() {}
 SocketStream::ResponseHeaders::~ResponseHeaders() { data_ = NULL; }
 
@@ skipping 387 matching lines @@
         break;
       case STATE_AUTH_REQUIRED:
         // It might be called when DoClose is called while waiting in
         // STATE_AUTH_REQUIRED.
         Finish(result);
         return;
       case STATE_CLOSE:
         DCHECK_LE(result, OK);
         Finish(result);
         return;
+      case STATE_SPDY:
+        DCHECK_EQ(result, OK);
+        result = DoSpdy();
+        break;
       default:
         NOTREACHED() << "bad state " << state;
         Finish(result);
         return;
     }
     // If the connection is not established yet and had actual errors,
     // close the connection.
     if (state != STATE_READ_WRITE && result < ERR_IO_PENDING) {
       DCHECK_EQ(next_state_, STATE_CLOSE);
       net_log_.EndEvent(
           NetLog::TYPE_SOCKET_STREAM_CONNECT,
           make_scoped_refptr(new NetLogIntegerParameter("net_error", result)));
     }
   } while (result != ERR_IO_PENDING);
 }
 
 int SocketStream::DoResolveProxy() {
   DCHECK(!pac_request_);
   next_state_ = STATE_RESOLVE_PROXY_COMPLETE;
 
   if (!proxy_url_.is_valid()) {
     next_state_ = STATE_CLOSE;
     return ERR_INVALID_ARGUMENT;
   }
 
+  // |endpoint_| indicates the final destination endpoint.
+  endpoint_ = HostPortPair(url_.HostNoBrackets(), url_.EffectiveIntPort());
+
+  // TODO(ukai): check alternate protocols?
+
   return proxy_service()->ResolveProxy(
       proxy_url_, &proxy_info_, &io_callback_, &pac_request_, net_log_);
 }
 
 int SocketStream::DoResolveProxyComplete(int result) {
   pac_request_ = NULL;
   if (result != OK) {
     LOG(ERROR) << "Failed to resolve proxy: " << result;
     if (delegate_)
       delegate_->OnError(this, result);
@@ skipping 58 matching lines @@
     result = delegate_->OnStartOpenConnection(this, &io_callback_);
     if (result == net::ERR_IO_PENDING)
       metrics_->OnWaitConnection();
   } else {
     next_state_ = STATE_CLOSE;
   }
   // TODO(ukai): if error occured, reconsider proxy after error.
   return result;
 }
 
+const HostPortPair& SocketStream::GetHostPortPair() const {
+  return endpoint_;
+}
+
+const ProxyServer& SocketStream::proxy_server() const {
+  return proxy_info_.proxy_server();
+}
+
+void SocketStream::SwitchToSpdy() {
+  DCHECK_EQ(STATE_TCP_CONNECT, next_state_);
+  next_state_ = STATE_SPDY;
+}
+
+int SocketStream::DoSpdy() {
+  metrics_->OnConnected();
+  net_log_.EndEvent(NetLog::TYPE_SOCKET_STREAM_CONNECT, NULL);
+  return ERR_IO_PENDING;  // Finish DoLoop.
+}
+
 int SocketStream::DoTcpConnect(int result) {
   if (result != OK) {
     next_state_ = STATE_CLOSE;
     return result;
   }
   next_state_ = STATE_TCP_CONNECT_COMPLETE;
   DCHECK(factory_);
   socket_.reset(factory_->CreateTCPClientSocket(addresses_,
                                                 net_log_.net_log(),
                                                 net_log_.source()));
@@ skipping 282 matching lines @@
       // SSL info object.
       ssl_config_.allowed_bad_certs.push_back(bad_cert);
       // Restart connection ignoring the bad certificate.
       socket_->Disconnect();
       socket_.reset();
       next_state_ = STATE_TCP_CONNECT;
       return OK;
     }
   }
 
+  // TODO(ukai): upgrade to spdy session if possible.
+
   if (result == OK)
     result = DidEstablishConnection();
   else
     next_state_ = STATE_CLOSE;
   return result;
 }
 
 int SocketStream::DoReadWrite(int result) {
   if (result < OK) {
     next_state_ = STATE_CLOSE;
@@ skipping 167 matching lines @@
 
 SSLConfigService* SocketStream::ssl_config_service() const {
   return context_->ssl_config_service();
 }
 
 ProxyService* SocketStream::proxy_service() const {
   return context_->proxy_service();
 }
 
 }  // namespace net