WebSocket over SPDY: handshake support for both of SPDY/2 and SPDY/3

net/websockets/websocket_job.cc

 // Copyright (c) 2012 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/websockets/websocket_job.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
@@ skipping 62 matching lines @@
 
 WebSocketJob::WebSocketJob(SocketStream::Delegate* delegate)
     : delegate_(delegate),
       state_(INITIALIZED),
       waiting_(false),
       handshake_request_(new WebSocketHandshakeRequestHandler),
       handshake_response_(new WebSocketHandshakeResponseHandler),
       started_to_send_handshake_request_(false),
       handshake_request_sent_(0),
       response_cookies_save_index_(0),
+      protocol_version_(0),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_for_send_pending_(this)) {
 }
 
 WebSocketJob::~WebSocketJob() {
   DCHECK_EQ(CLOSED, state_);
   DCHECK(!delegate_);
   DCHECK(!socket_.get());
 }
 
@@ skipping 212 matching lines @@
 }
 
 int WebSocketJob::OnReceivedSpdyResponseHeader(
     const SpdyHeaderBlock& headers, int status) {
   DCHECK_NE(INITIALIZED, state_);
   if (state_ != CONNECTING)
     return status;
   if (status != OK)
     return status;
   // TODO(toyoshim): Fallback to non-spdy connection?
-  handshake_response_->ParseResponseHeaderBlock(headers, challenge_);
+  handshake_response_->ParseResponseHeaderBlock(headers,
+                                                challenge_,
+                                                protocol_version_);
 
   SaveCookiesAndNotifyHeaderComplete();
   return OK;
 }
 
 void WebSocketJob::OnSentSpdyData(int amount_sent) {
   DCHECK_NE(INITIALIZED, state_);
   DCHECK_NE(CONNECTING, state_);
   if (state_ == CLOSED)
     return;
@@ skipping 56 matching lines @@
 void WebSocketJob::LoadCookieCallback(const std::string& cookie) {
   if (!cookie.empty())
     handshake_request_->AppendHeaderIfMissing("Cookie", cookie);
   DoSendData();
 }
 
 void WebSocketJob::DoSendData() {
   if (spdy_websocket_stream_.get()) {
     scoped_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock);
     handshake_request_->GetRequestHeaderBlock(
-        socket_->url(), headers.get(), &challenge_);
+        socket_->url(), headers.get(), &challenge_, protocol_version_);
     spdy_websocket_stream_->SendRequest(headers.Pass());
   } else {
     const std::string& handshake_request =
         handshake_request_->GetRawRequest();
     handshake_request_sent_ = 0;
     socket_->net_log()->AddEvent(
         NetLog::TYPE_WEB_SOCKET_SEND_REQUEST_HEADERS,
         base::Bind(&NetLogWebSocketHandshakeCallback, &handshake_request));
     socket_->SendData(handshake_request.data(),
                       handshake_request.size());
@@ skipping 157 matching lines @@
       spdy_pool->Get(pair, *socket_->net_log());
   SSLInfo ssl_info;
   bool was_npn_negotiated;
   NextProto protocol_negotiated = kProtoUnknown;
   bool use_ssl = spdy_session->GetSSLInfo(
       &ssl_info, &was_npn_negotiated, &protocol_negotiated);
   if (socket_->is_secure() && !use_ssl)
     return OK;
 
   // Create SpdyWebSocketStream.
+  protocol_version_ = spdy_session->GetProtocolVersion();
   spdy_websocket_stream_.reset(new SpdyWebSocketStream(spdy_session, this));
 
   int result = spdy_websocket_stream_->InitializeStream(
       socket_->url(), MEDIUM, *socket_->net_log());
   if (result == OK) {
     OnConnected(socket_, kMaxPendingSendAllowed);
     return ERR_PROTOCOL_SWITCHED;
   }
   if (result != ERR_IO_PENDING) {
     spdy_websocket_stream_.reset();
@@ skipping 70 matching lines @@
 
   scoped_refptr<IOBufferWithSize> next_buffer = send_buffer_queue_.front();
   send_buffer_queue_.pop_front();
   current_send_buffer_ = new DrainableIOBuffer(next_buffer,
                                                next_buffer->size());
   SendDataInternal(current_send_buffer_->data(),
                    current_send_buffer_->BytesRemaining());
 }
 
 }  // namespace net