Remove code for old WebSocket protocols from WebSocketJob and helpers for it

BUG=

Review URL: https://codereview.chromium.org/26247002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@227750 0039d316-1c4b-4281-b951-d872f2087c98

5 files changed, 63 insertions, 574 deletions

diff --git a/net/websockets/websocket_handshake_handler.cc b/net/websockets/websocket_handshake_handler.cc
index e5b6641..c304842 100644
--- a/net/websockets/websocket_handshake_handler.cc
+++ b/net/websockets/websocket_handshake_handler.cc
@@ -7,7 +7,6 @@
 #include <limits>
 
 #include "base/base64.h"
-#include "base/md5.h"
 #include "base/sha1.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
@@ -23,13 +22,11 @@
 namespace net {
 namespace {
 
-const size_t kRequestKey3Size = 8U;
-const size_t kResponseKeySize = 16U;
-
-// First version that introduced new WebSocket handshake which does not
-// require sending "key3" or "response key" data after headers.
-const int kMinVersionOfHybiNewHandshake = 4;
+const int kVersionHeaderValueForRFC6455 = 13;
 
+// Splits |handshake_message| into Status-Line or Request-Line (including CRLF)
+// and headers (excluding 2nd CRLF of double CRLFs at the end of a handshake
+// response).
 void ParseHandshakeHeader(
     const char* handshake_message, int len,
     std::string* status_line,
@@ -115,19 +112,21 @@ std::string FilterHeaders(
   return filtered_headers;
 }
 
-int GetVersionFromRequest(const std::string& request_headers) {
+bool CheckVersionInRequest(const std::string& request_headers) {
   std::vector<std::string> values;
-  const char* const headers_to_get[2] = {
-      websockets::kSecWebSocketVersionLowercase, "sec-websocket-draft"};
-  FetchHeaders(request_headers, headers_to_get, 2, &values);
+  const char* const headers_to_get[1] = {
+    websockets::kSecWebSocketVersionLowercase};
+  FetchHeaders(request_headers, headers_to_get, 1, &values);
   DCHECK_LE(values.size(), 1U);
   if (values.empty())
-    return 0;
+    return false;
+
   int version;
   bool conversion_success = base::StringToInt(values[0], &version);
-  DCHECK(conversion_success);
-  DCHECK_GE(version, 1);
-  return version;
+  if (!conversion_success)
+    return false;
+
+  return version == kVersionHeaderValueForRFC6455;
 }
 
 // Append a header to a string. Equivalent to
@@ -152,44 +151,9 @@ void AppendHeader(const base::StringPiece& header,
 
 }  // namespace
 
-namespace internal {
-
-void GetKeyNumber(const std::string& key, std::string* challenge) {
-  uint32 key_number = 0;
-  uint32 spaces = 0;
-  for (size_t i = 0; i < key.size(); ++i) {
-    if (isdigit(key[i])) {
-      // key_number should not overflow. (it comes from
-      // WebCore/websockets/WebSocketHandshake.cpp).
-      // Trust, but verify.
-      DCHECK_GE((std::numeric_limits<uint32>::max() - (key[i] - '0')) / 10,
-                key_number) << "Supplied key would overflow";
-      key_number = key_number * 10 + key[i] - '0';
-    } else if (key[i] == ' ') {
-      ++spaces;
-    }
-  }
-  DCHECK_NE(0u, spaces) << "Key must contain at least one space";
-  if (spaces == 0)
-    return;
-  DCHECK_EQ(0u, key_number % spaces) << "Key number must be an integral "
-                                     << "multiple of the number of spaces";
-  key_number /= spaces;
-
-  char part[4];
-  for (int i = 0; i < 4; i++) {
-    part[3 - i] = key_number & 0xFF;
-    key_number >>= 8;
-  }
-  challenge->append(part, 4);
-}
-
-}  // namespace internal
-
 WebSocketHandshakeRequestHandler::WebSocketHandshakeRequestHandler()
     : original_length_(0),
-      raw_length_(0),
-      protocol_version_(-1) {}
+      raw_length_(0) {}
 
 bool WebSocketHandshakeRequestHandler::ParseRequest(
     const char* data, int length) {
@@ -205,29 +169,12 @@ bool WebSocketHandshakeRequestHandler::ParseRequest(
                        &status_line_,
                        &headers_);
 
-  // WebSocket protocol drafts hixie-76 (hybi-00), hybi-01, 02 and 03 require
-  // the clients to send key3 after the handshake request header fields.
-  // Hybi-04 and later drafts, on the other hand, no longer have key3
-  // in the handshake format.
-  protocol_version_ = GetVersionFromRequest(headers_);
-  DCHECK_GE(protocol_version_, 0);
-  if (protocol_version_ >= kMinVersionOfHybiNewHandshake) {
-    key3_ = "";
-    original_length_ = input_header_length;
-    return true;
-  }
-
-  if (input_header_length + kRequestKey3Size > input.size())
+  if (!CheckVersionInRequest(headers_)) {
+    NOTREACHED();
     return false;
+  }
 
-  // Assumes WebKit doesn't send any data after handshake request message
-  // until handshake is finished.
-  // Thus, |key3_| is part of handshake message, and not in part
-  // of WebSocket frame stream.
-  DCHECK_EQ(kRequestKey3Size, input.size() - input_header_length);
-  key3_ = std::string(input.data() + input_header_length,
-                      input.size() - input_header_length);
-  original_length_ = input.size();
+  original_length_ = input_header_length;
   return true;
 }
 
@@ -263,31 +210,12 @@ HttpRequestInfo WebSocketHandshakeRequestHandler::GetRequestInfo(
   request_info.extra_headers.RemoveHeader(websockets::kUpgrade);
   request_info.extra_headers.RemoveHeader(HttpRequestHeaders::kConnection);
 
-  if (protocol_version_ >= kMinVersionOfHybiNewHandshake) {
-    std::string key;
-    bool header_present = request_info.extra_headers.GetHeader(
-        websockets::kSecWebSocketKey, &key);
-    DCHECK(header_present);
-    request_info.extra_headers.RemoveHeader(websockets::kSecWebSocketKey);
-    *challenge = key;
-  } else {
-    challenge->clear();
-    std::string key;
-    bool header_present =
-        request_info.extra_headers.GetHeader("Sec-WebSocket-Key1", &key);
-    DCHECK(header_present);
-    request_info.extra_headers.RemoveHeader("Sec-WebSocket-Key1");
-    internal::GetKeyNumber(key, challenge);
-
-    header_present =
-        request_info.extra_headers.GetHeader("Sec-WebSocket-Key2", &key);
-    DCHECK(header_present);
-    request_info.extra_headers.RemoveHeader("Sec-WebSocket-Key2");
-    internal::GetKeyNumber(key, challenge);
-
-    challenge->append(key3_);
-  }
-
+  std::string key;
+  bool header_present = request_info.extra_headers.GetHeader(
+      websockets::kSecWebSocketKey, &key);
+  DCHECK(header_present);
+  request_info.extra_headers.RemoveHeader(websockets::kSecWebSocketKey);
+  *challenge = key;
   return request_info;
 }
 
@@ -300,13 +228,11 @@ bool WebSocketHandshakeRequestHandler::GetRequestHeaderBlock(
   // For details, see WebSocket Layering over SPDY/3 Draft 8.
   if (spdy_protocol_version <= 2) {
     (*headers)["path"] = url.path();
-    (*headers)["version"] =
-      base::StringPrintf("%s%d", "WebSocket/", protocol_version_);
+    (*headers)["version"] = "WebSocket/13";
     (*headers)["scheme"] = url.scheme();
   } else {
     (*headers)[":path"] = url.path();
-    (*headers)[":version"] =
-      base::StringPrintf("%s%d", "WebSocket/", protocol_version_);
+    (*headers)[":version"] = "WebSocket/13";
     (*headers)[":scheme"] = url.scheme();
   }
 
@@ -368,9 +294,8 @@ bool WebSocketHandshakeRequestHandler::GetRequestHeaderBlock(
 std::string WebSocketHandshakeRequestHandler::GetRawRequest() {
   DCHECK(!status_line_.empty());
   DCHECK(!headers_.empty());
-  // The following works on both hybi-04 and older handshake,
-  // because |key3_| is guaranteed to be empty if the handshake was hybi-04's.
-  std::string raw_request = status_line_ + headers_ + "\r\n" + key3_;
+
+  std::string raw_request = status_line_ + headers_ + "\r\n";
   raw_length_ = raw_request.size();
   return raw_request;
 }
@@ -380,34 +305,18 @@ size_t WebSocketHandshakeRequestHandler::raw_length() const {
   return raw_length_;
 }
 
-int WebSocketHandshakeRequestHandler::protocol_version() const {
-  DCHECK_GE(protocol_version_, 0);
-  return protocol_version_;
-}
-
 WebSocketHandshakeResponseHandler::WebSocketHandshakeResponseHandler()
-    : original_header_length_(0),
-      protocol_version_(0) {}
+    : original_header_length_(0) {}
 
 WebSocketHandshakeResponseHandler::~WebSocketHandshakeResponseHandler() {}
 
-int WebSocketHandshakeResponseHandler::protocol_version() const {
-  DCHECK_GE(protocol_version_, 0);
-  return protocol_version_;
-}
-
-void WebSocketHandshakeResponseHandler::set_protocol_version(
-    int protocol_version) {
-  DCHECK_GE(protocol_version, 0);
-  protocol_version_ = protocol_version;
-}
-
 size_t WebSocketHandshakeResponseHandler::ParseRawResponse(
     const char* data, int length) {
   DCHECK_GT(length, 0);
   if (HasResponse()) {
     DCHECK(!status_line_.empty());
     // headers_ might be empty for wrong response from server.
+
     return 0;
   }
 
@@ -428,14 +337,12 @@ size_t WebSocketHandshakeResponseHandler::ParseRawResponse(
   DCHECK_GE(original_header_length_, header_size);
   header_separator_ = std::string(original_.data() + header_size,
                                   original_header_length_ - header_size);
-  key_ = std::string(original_.data() + original_header_length_,
-                     GetResponseKeySize());
-  return original_header_length_ + GetResponseKeySize() - old_original_length;
+  return original_header_length_ - old_original_length;
 }
 
 bool WebSocketHandshakeResponseHandler::HasResponse() const {
   return original_header_length_ > 0 &&
-      original_header_length_ + GetResponseKeySize() <= original_.size();
+      static_cast<size_t>(original_header_length_) <= original_.size();
 }
 
 bool WebSocketHandshakeResponseHandler::ParseResponseInfo(
@@ -448,24 +355,21 @@ bool WebSocketHandshakeResponseHandler::ParseResponseInfo(
   std::string response_message;
   response_message = response_info.headers->GetStatusLine();
   response_message += "\r\n";
-  if (protocol_version_ >= kMinVersionOfHybiNewHandshake)
-    AppendHeader(websockets::kUpgrade,
-                 websockets::kWebSocketLowercase,
-                 &response_message);
-  else
-    AppendHeader(websockets::kUpgrade, "WebSocket", &response_message);
+
+  AppendHeader(websockets::kUpgrade,
+               websockets::kWebSocketLowercase,
+               &response_message);
+
   AppendHeader(
       HttpRequestHeaders::kConnection, websockets::kUpgrade, &response_message);
 
-  if (protocol_version_ >= kMinVersionOfHybiNewHandshake) {
-    std::string hash =
-        base::SHA1HashString(challenge + websockets::kWebSocketGuid);
-    std::string websocket_accept;
-    bool encode_success = base::Base64Encode(hash, &websocket_accept);
-    DCHECK(encode_success);
-    AppendHeader(
-        websockets::kSecWebSocketAccept, websocket_accept, &response_message);
-  }
+  std::string hash =
+      base::SHA1HashString(challenge + websockets::kWebSocketGuid);
+  std::string websocket_accept;
+  bool encode_success = base::Base64Encode(hash, &websocket_accept);
+  DCHECK(encode_success);
+  AppendHeader(
+      websockets::kSecWebSocketAccept, websocket_accept, &response_message);
 
   void* iter = NULL;
   std::string name;
@@ -475,14 +379,6 @@ bool WebSocketHandshakeResponseHandler::ParseResponseInfo(
   }
   response_message += "\r\n";
 
-  if (protocol_version_ < kMinVersionOfHybiNewHandshake) {
-    base::MD5Digest digest;
-    base::MD5Sum(challenge.data(), challenge.size(), &digest);
-
-    const char* digest_data = reinterpret_cast<char*>(digest.a);
-    response_message.append(digest_data, sizeof(digest.a));
-  }
-
   return ParseRawResponse(response_message.data(),
                           response_message.size()) == response_message.size();
 }
@@ -583,23 +479,15 @@ void WebSocketHandshakeResponseHandler::RemoveHeaders(
 
 std::string WebSocketHandshakeResponseHandler::GetRawResponse() const {
   DCHECK(HasResponse());
-  return std::string(original_.data(),
-                     original_header_length_ + GetResponseKeySize());
+  return original_.substr(0, original_header_length_);
 }
 
 std::string WebSocketHandshakeResponseHandler::GetResponse() {
   DCHECK(HasResponse());
   DCHECK(!status_line_.empty());
   // headers_ might be empty for wrong response from server.
-  DCHECK_EQ(GetResponseKeySize(), key_.size());
 
-  return status_line_ + headers_ + header_separator_ + key_;
-}
-
-size_t WebSocketHandshakeResponseHandler::GetResponseKeySize() const {
-  if (protocol_version_ >= kMinVersionOfHybiNewHandshake)
-    return 0;
-  return kResponseKeySize;
+  return status_line_ + headers_ + header_separator_;
 }
 
 }  // namespace net
diff --git a/net/websockets/websocket_handshake_handler.h b/net/websockets/websocket_handshake_handler.h
index 14c0fce..f307115 100644
--- a/net/websockets/websocket_handshake_handler.h
+++ b/net/websockets/websocket_handshake_handler.h
@@ -10,21 +10,6 @@
 //   cookies to the renderer process, so handles HttpOnly cookies in
 //   browser process.
 //
-// The classes below support two styles of handshake: handshake based
-// on hixie-76 draft and one based on hybi-04 draft. The critical difference
-// between these two is how they pass challenge and response values. Hixie-76
-// based handshake appends a few bytes of binary data after header fields of
-// handshake request and response. These data are called "key3" (for request)
-// or "response key" (for response). On the other hand, handshake based on
-// hybi-04 and later drafts put challenge and response values into handshake
-// header fields, thus we do not need to send or receive extra bytes after
-// handshake headers.
-//
-// While we are working on updating WebSocket implementation in WebKit to
-// conform to the latest protocol draft, we need to accept both styles of
-// handshake. After we land the protocol changes in WebKit, we will be able to
-// drop codes handling old-style handshake.
-
 #ifndef NET_WEBSOCKETS_WEBSOCKET_HANDSHAKE_HANDLER_H_
 #define NET_WEBSOCKETS_WEBSOCKET_HANDSHAKE_HANDLER_H_
 
@@ -58,10 +43,8 @@ class NET_EXPORT_PRIVATE WebSocketHandshakeRequestHandler {
   void RemoveHeaders(const char* const headers_to_remove[],
                      size_t headers_to_remove_len);
 
-  // Gets request info to open WebSocket connection.
-  // Fills challenge data (concatenation of key1, 2 and 3 for hybi-03 and
-  // earlier, or Sec-WebSocket-Key header value for hybi-04 and later)
-  // in |challenge|.
+  // Gets request info to open WebSocket connection and fills challenge data in
+  // |challenge|.
   HttpRequestInfo GetRequestInfo(const GURL& url, std::string* challenge);
   // Gets request as SpdyHeaderBlock.
   // Also, fills challenge data in |challenge|.
@@ -75,19 +58,11 @@ class NET_EXPORT_PRIVATE WebSocketHandshakeRequestHandler {
   // Calling raw_length is valid only after GetRawRequest() call.
   size_t raw_length() const;
 
-  // Returns the value of Sec-WebSocket-Version or Sec-WebSocket-Draft header
-  // (the latter is an old name of the former). Returns 0 if both headers were
-  // absent, which means the handshake was based on hybi-00 (= hixie-76).
-  // Should only be called after the handshake has been parsed.
-  int protocol_version() const;
-
  private:
   std::string status_line_;
   std::string headers_;
-  std::string key3_;
   int original_length_;
   int raw_length_;
-  int protocol_version_;  // "-1" means we haven't parsed the handshake yet.
 
   DISALLOW_COPY_AND_ASSIGN(WebSocketHandshakeRequestHandler);
 };
@@ -97,17 +72,11 @@ class NET_EXPORT_PRIVATE WebSocketHandshakeResponseHandler {
   WebSocketHandshakeResponseHandler();
   ~WebSocketHandshakeResponseHandler();
 
-  // Set WebSocket protocol version before parsing the response.
-  // Default is 0 (hybi-00, which is same as hixie-76).
-  int protocol_version() const;
-  void set_protocol_version(int protocol_version);
-
   // Parses WebSocket handshake response from WebSocket server.
   // Returns number of bytes in |data| used for WebSocket handshake response
-  // message, including response key.  If it already got whole WebSocket
-  // handshake response message, returns zero.  In other words,
-  // [data + returned value, data + length) will be WebSocket frame data
-  // after handshake response message.
+  // message.  If it already got whole WebSocket handshake response message,
+  // returns zero.  In other words, [data + returned value, data + length) will
+  // be WebSocket frame data after handshake response message.
   // TODO(ukai): fail fast when response gives wrong status code.
   size_t ParseRawResponse(const char* data, int length);
   // Returns true if it already parses full handshake response message.
@@ -135,37 +104,18 @@ class NET_EXPORT_PRIVATE WebSocketHandshakeResponseHandler {
   std::string GetResponse();
 
  private:
-  // Returns the length of response key. This function will return 0
-  // if the specified WebSocket protocol version does not require
-  // sending response key.
-  size_t GetResponseKeySize() const;
-
+  // Original bytes input by using ParseRawResponse().
   std::string original_;
+  // Number of bytes actually used for the handshake response in |original_|.
   int original_header_length_;
+
   std::string status_line_;
   std::string headers_;
   std::string header_separator_;
-  std::string key_;
-  int protocol_version_;
 
   DISALLOW_COPY_AND_ASSIGN(WebSocketHandshakeResponseHandler);
 };
 
-namespace internal {
-
-// Private Functions (Exposed for Unit Testing) -------------------------------
-
-// Gets a key number from |key| and appends the number to |challenge|.
-// The key number (/part_N/) is extracted as step per 4.-8. in
-// "5.2.  Sending the server's opening handshake" of
-// http://tools.ietf.org/id/draft-ietf-hybi-thewebsocketprotocol-00.txt
-// TODO(ricea): Remove this when we remove support for pre-RFC6455 versions of
-// WebSockets.
-void NET_EXPORT_PRIVATE GetKeyNumber(const std::string& key,
-                                     std::string* challenge);
-
-}  // namespace internal
-
 }  // namespace net
 
 #endif  // NET_WEBSOCKETS_WEBSOCKET_HANDSHAKE_HANDLER_H_
diff --git a/net/websockets/websocket_handshake_handler_spdy_test.cc b/net/websockets/websocket_handshake_handler_spdy_test.cc
index 1af22da..a825dcd 100644
--- a/net/websockets/websocket_handshake_handler_spdy_test.cc
+++ b/net/websockets/websocket_handshake_handler_spdy_test.cc
@@ -49,7 +49,6 @@ TEST_P(WebSocketHandshakeHandlerSpdyTest, RequestResponse) {
 
   EXPECT_TRUE(request_handler.ParseRequest(kHandshakeRequestMessage,
                                            strlen(kHandshakeRequestMessage)));
-  EXPECT_EQ(13, request_handler.protocol_version());
 
   GURL url("ws://example.com/demo");
   std::string challenge;
@@ -86,7 +85,6 @@ TEST_P(WebSocketHandshakeHandlerSpdyTest, RequestResponse) {
   spdy_util_.SetHeader("sec-websocket-extensions", "foo", &headers);
 
   WebSocketHandshakeResponseHandler response_handler;
-  response_handler.set_protocol_version(13);
   EXPECT_TRUE(response_handler.ParseResponseHeaderBlock(
       headers, challenge, spdy_util_.spdy_version()));
   EXPECT_TRUE(response_handler.HasResponse());
@@ -123,7 +121,6 @@ TEST_P(WebSocketHandshakeHandlerSpdyTest, RequestResponseWithCookies) {
 
   EXPECT_TRUE(request_handler.ParseRequest(kHandshakeRequestMessage,
                                            strlen(kHandshakeRequestMessage)));
-  EXPECT_EQ(13, request_handler.protocol_version());
 
   GURL url("ws://example.com/demo");
   std::string challenge;
@@ -167,7 +164,6 @@ TEST_P(WebSocketHandshakeHandlerSpdyTest, RequestResponseWithCookies) {
 
 
   WebSocketHandshakeResponseHandler response_handler;
-  response_handler.set_protocol_version(13);
   EXPECT_TRUE(response_handler.ParseResponseHeaderBlock(
       headers, challenge, spdy_util_.spdy_version()));
   EXPECT_TRUE(response_handler.HasResponse());
diff --git a/net/websockets/websocket_handshake_handler_test.cc b/net/websockets/websocket_handshake_handler_test.cc
index 4c1b155..e59a982 100644
--- a/net/websockets/websocket_handshake_handler_test.cc
+++ b/net/websockets/websocket_handshake_handler_test.cc
@@ -26,46 +26,6 @@ const char* const kSetCookieHeaders[] = {
   "set-cookie", "set-cookie2"
 };
 
-// A test fixture to simplify tests for GetKeyNumber().
-class WebSocketHandshakeGetKeyNumberTest : public ::testing::Test {
- protected:
-  static const char kExampleFromDraftKey1[];
-
-  // The object is default-initialised with an empty challenge and the example
-  // key from draft-ietf-hybi-thewebsocketprotocol-00. These can be changed
-  // using set_challenge() and set_key().
-  WebSocketHandshakeGetKeyNumberTest()
-      : challenge_(), key_(kExampleFromDraftKey1) {}
-
-  // A convenience wrapper for the function under test which automatically
-  // passes in the arguments stored in the object.
-  void GetKeyNumber() { ::net::internal::GetKeyNumber(key_, &challenge_); }
-
-  // Read current challenge.
-  const std::string& challenge() const { return challenge_; }
-
-  // Overwrite challenge.
-  void set_challenge(const std::string& challenge) { challenge_ = challenge; }
-
-  // Reset the challenge to be empty.
-  void reset_challenge() { challenge_.clear(); }
-
-  // Change key.
-  void set_key(const std::string& key) { key_ = key; }
-
- private:
-  std::string challenge_;
-  std::string key_;
-};
-
-const char WebSocketHandshakeGetKeyNumberTest::kExampleFromDraftKey1[] =
-    "3e6b263  4 17 80";
-
-// A version of the above fixture for death tests.
-class WebSocketHandshakeGetKeyNumberDeathTest
-    : public WebSocketHandshakeGetKeyNumberTest {
-};
-
 }  // namespace
 
 namespace net {
@@ -76,41 +36,16 @@ TEST(WebSocketHandshakeRequestHandlerTest, SimpleRequest) {
   static const char kHandshakeRequestMessage[] =
       "GET /demo HTTP/1.1\r\n"
       "Host: example.com\r\n"
-      "Connection: Upgrade\r\n"
-      "Sec-WebSocket-Key2: 12998 5 Y3 1  .P00\r\n"
-      "Sec-WebSocket-Protocol: sample\r\n"
-      "Upgrade: WebSocket\r\n"
-      "Sec-WebSocket-Key1: 4 @1  46546xW%0l 1 5\r\n"
-      "Origin: http://example.com\r\n"
-      "\r\n"
-      "^n:ds[4U";
-
-  EXPECT_TRUE(handler.ParseRequest(kHandshakeRequestMessage,
-                                   strlen(kHandshakeRequestMessage)));
-  EXPECT_EQ(0, handler.protocol_version());
-
-  handler.RemoveHeaders(kCookieHeaders, arraysize(kCookieHeaders));
-
-  EXPECT_EQ(kHandshakeRequestMessage, handler.GetRawRequest());
-}
-
-TEST(WebSocketHandshakeRequestHandlerTest, SimpleRequestHybi06Handshake) {
-  WebSocketHandshakeRequestHandler handler;
-
-  static const char kHandshakeRequestMessage[] =
-      "GET /demo HTTP/1.1\r\n"
-      "Host: example.com\r\n"
       "Upgrade: websocket\r\n"
       "Connection: Upgrade\r\n"
       "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
       "Sec-WebSocket-Origin: http://example.com\r\n"
       "Sec-WebSocket-Protocol: sample\r\n"
-      "Sec-WebSocket-Version: 6\r\n"
+      "Sec-WebSocket-Version: 13\r\n"
       "\r\n";
 
   EXPECT_TRUE(handler.ParseRequest(kHandshakeRequestMessage,
                                    strlen(kHandshakeRequestMessage)));
-  EXPECT_EQ(6, handler.protocol_version());
 
   handler.RemoveHeaders(kCookieHeaders, arraysize(kCookieHeaders));
 
@@ -123,61 +58,17 @@ TEST(WebSocketHandshakeRequestHandlerTest, ReplaceRequestCookies) {
   static const char kHandshakeRequestMessage[] =
       "GET /demo HTTP/1.1\r\n"
       "Host: example.com\r\n"
-      "Connection: Upgrade\r\n"
-      "Sec-WebSocket-Key2: 12998 5 Y3 1  .P00\r\n"
-      "Sec-WebSocket-Protocol: sample\r\n"
-      "Upgrade: WebSocket\r\n"
-      "Sec-WebSocket-Key1: 4 @1  46546xW%0l 1 5\r\n"
-      "Origin: http://example.com\r\n"
-      "Cookie: WK-websocket-test=1\r\n"
-      "\r\n"
-      "^n:ds[4U";
-
-  EXPECT_TRUE(handler.ParseRequest(kHandshakeRequestMessage,
-                                   strlen(kHandshakeRequestMessage)));
-  EXPECT_EQ(0, handler.protocol_version());
-
-  handler.RemoveHeaders(kCookieHeaders, arraysize(kCookieHeaders));
-
-  handler.AppendHeaderIfMissing("Cookie",
-                                "WK-websocket-test=1; "
-                                "WK-websocket-test-httponly=1");
-
-  static const char kHandshakeRequestExpectedMessage[] =
-      "GET /demo HTTP/1.1\r\n"
-      "Host: example.com\r\n"
-      "Connection: Upgrade\r\n"
-      "Sec-WebSocket-Key2: 12998 5 Y3 1  .P00\r\n"
-      "Sec-WebSocket-Protocol: sample\r\n"
-      "Upgrade: WebSocket\r\n"
-      "Sec-WebSocket-Key1: 4 @1  46546xW%0l 1 5\r\n"
-      "Origin: http://example.com\r\n"
-      "Cookie: WK-websocket-test=1; WK-websocket-test-httponly=1\r\n"
-      "\r\n"
-      "^n:ds[4U";
-
-  EXPECT_EQ(kHandshakeRequestExpectedMessage, handler.GetRawRequest());
-}
-
-TEST(WebSocketHandshakeRequestHandlerTest,
-     ReplaceRequestCookiesHybi06Handshake) {
-  WebSocketHandshakeRequestHandler handler;
-
-  static const char kHandshakeRequestMessage[] =
-      "GET /demo HTTP/1.1\r\n"
-      "Host: example.com\r\n"
       "Upgrade: websocket\r\n"
       "Connection: Upgrade\r\n"
       "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
       "Sec-WebSocket-Origin: http://example.com\r\n"
       "Sec-WebSocket-Protocol: sample\r\n"
-      "Sec-WebSocket-Version: 6\r\n"
+      "Sec-WebSocket-Version: 13\r\n"
       "Cookie: WK-websocket-test=1\r\n"
       "\r\n";
 
   EXPECT_TRUE(handler.ParseRequest(kHandshakeRequestMessage,
                                    strlen(kHandshakeRequestMessage)));
-  EXPECT_EQ(6, handler.protocol_version());
 
   handler.RemoveHeaders(kCookieHeaders, arraysize(kCookieHeaders));
 
@@ -193,7 +84,7 @@ TEST(WebSocketHandshakeRequestHandlerTest,
       "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
       "Sec-WebSocket-Origin: http://example.com\r\n"
       "Sec-WebSocket-Protocol: sample\r\n"
-      "Sec-WebSocket-Version: 6\r\n"
+      "Sec-WebSocket-Version: 13\r\n"
       "Cookie: WK-websocket-test=1; WK-websocket-test-httponly=1\r\n"
       "\r\n";
 
@@ -202,32 +93,6 @@ TEST(WebSocketHandshakeRequestHandlerTest,
 
 TEST(WebSocketHandshakeResponseHandlerTest, SimpleResponse) {
   WebSocketHandshakeResponseHandler handler;
-  EXPECT_EQ(0, handler.protocol_version());
-
-  static const char kHandshakeResponseMessage[] =
-      "HTTP/1.1 101 WebSocket Protocol Handshake\r\n"
-      "Upgrade: WebSocket\r\n"
-      "Connection: Upgrade\r\n"
-      "Sec-WebSocket-Origin: http://example.com\r\n"
-      "Sec-WebSocket-Location: ws://example.com/demo\r\n"
-      "Sec-WebSocket-Protocol: sample\r\n"
-      "\r\n"
-      "8jKS'y:G*Co,Wxa-";
-
-  EXPECT_EQ(strlen(kHandshakeResponseMessage),
-            handler.ParseRawResponse(kHandshakeResponseMessage,
-                                     strlen(kHandshakeResponseMessage)));
-  EXPECT_TRUE(handler.HasResponse());
-
-  handler.RemoveHeaders(kCookieHeaders, arraysize(kCookieHeaders));
-
-  EXPECT_EQ(kHandshakeResponseMessage, handler.GetResponse());
-}
-
-TEST(WebSocketHandshakeResponseHandlerTest, SimpleResponseHybi06Handshake) {
-  WebSocketHandshakeResponseHandler handler;
-  handler.set_protocol_version(6);
-  EXPECT_EQ(6, handler.protocol_version());
 
   static const char kHandshakeResponseMessage[] =
       "HTTP/1.1 101 Switching Protocols\r\n"
@@ -249,49 +114,6 @@ TEST(WebSocketHandshakeResponseHandlerTest, SimpleResponseHybi06Handshake) {
 
 TEST(WebSocketHandshakeResponseHandlerTest, ReplaceResponseCookies) {
   WebSocketHandshakeResponseHandler handler;
-  EXPECT_EQ(0, handler.protocol_version());
-
-  static const char kHandshakeResponseMessage[] =
-      "HTTP/1.1 101 WebSocket Protocol Handshake\r\n"
-      "Upgrade: WebSocket\r\n"
-      "Connection: Upgrade\r\n"
-      "Sec-WebSocket-Origin: http://example.com\r\n"
-      "Sec-WebSocket-Location: ws://example.com/demo\r\n"
-      "Sec-WebSocket-Protocol: sample\r\n"
-      "Set-Cookie: WK-websocket-test-1\r\n"
-      "Set-Cookie: WK-websocket-test-httponly=1; HttpOnly\r\n"
-      "\r\n"
-      "8jKS'y:G*Co,Wxa-";
-
-  EXPECT_EQ(strlen(kHandshakeResponseMessage),
-            handler.ParseRawResponse(kHandshakeResponseMessage,
-                                     strlen(kHandshakeResponseMessage)));
-  EXPECT_TRUE(handler.HasResponse());
-  std::vector<std::string> cookies;
-  handler.GetHeaders(kSetCookieHeaders, arraysize(kSetCookieHeaders), &cookies);
-  ASSERT_EQ(2U, cookies.size());
-  EXPECT_EQ("WK-websocket-test-1", cookies[0]);
-  EXPECT_EQ("WK-websocket-test-httponly=1; HttpOnly", cookies[1]);
-  handler.RemoveHeaders(kSetCookieHeaders, arraysize(kSetCookieHeaders));
-
-  static const char kHandshakeResponseExpectedMessage[] =
-      "HTTP/1.1 101 WebSocket Protocol Handshake\r\n"
-      "Upgrade: WebSocket\r\n"
-      "Connection: Upgrade\r\n"
-      "Sec-WebSocket-Origin: http://example.com\r\n"
-      "Sec-WebSocket-Location: ws://example.com/demo\r\n"
-      "Sec-WebSocket-Protocol: sample\r\n"
-      "\r\n"
-      "8jKS'y:G*Co,Wxa-";
-
-  EXPECT_EQ(kHandshakeResponseExpectedMessage, handler.GetResponse());
-}
-
-TEST(WebSocketHandshakeResponseHandlerTest,
-     ReplaceResponseCookiesHybi06Handshake) {
-  WebSocketHandshakeResponseHandler handler;
-  handler.set_protocol_version(6);
-  EXPECT_EQ(6, handler.protocol_version());
 
   static const char kHandshakeResponseMessage[] =
       "HTTP/1.1 101 Switching Protocols\r\n"
@@ -329,20 +151,18 @@ TEST(WebSocketHandshakeResponseHandlerTest, BadResponse) {
   WebSocketHandshakeResponseHandler handler;
 
   static const char kBadMessage[] = "\n\n\r\net-Location: w";
-  EXPECT_EQ(strlen(kBadMessage),
-            handler.ParseRawResponse(kBadMessage, strlen(kBadMessage)));
+  EXPECT_EQ(2U, handler.ParseRawResponse(kBadMessage, strlen(kBadMessage)));
   EXPECT_TRUE(handler.HasResponse());
-  EXPECT_EQ(kBadMessage, handler.GetResponse());
+  EXPECT_EQ("\n\n", handler.GetResponse());
 }
 
 TEST(WebSocketHandshakeResponseHandlerTest, BadResponse2) {
   WebSocketHandshakeResponseHandler handler;
 
   static const char kBadMessage[] = "\n\r\n\r\net-Location: w";
-  EXPECT_EQ(strlen(kBadMessage),
-            handler.ParseRawResponse(kBadMessage, strlen(kBadMessage)));
+  EXPECT_EQ(3U, handler.ParseRawResponse(kBadMessage, strlen(kBadMessage)));
   EXPECT_TRUE(handler.HasResponse());
-  EXPECT_EQ(kBadMessage, handler.GetResponse());
+  EXPECT_EQ("\n\r\n", handler.GetResponse());
 }
 
 TEST(WebSocketHandshakeHandlerTest, HttpRequestResponse) {
@@ -351,101 +171,16 @@ TEST(WebSocketHandshakeHandlerTest, HttpRequestResponse) {
   static const char kHandshakeRequestMessage[] =
       "GET /demo HTTP/1.1\r\n"
       "Host: example.com\r\n"
-      "Connection: Upgrade\r\n"
-      "Sec-WebSocket-Key2: 12998 5 Y3 1  .P00\r\n"
-      "Sec-WebSocket-Protocol: sample\r\n"
-      "Upgrade: WebSocket\r\n"
-      "Sec-WebSocket-Key1: 4 @1  46546xW%0l 1 5\r\n"
-      "Origin: http://example.com\r\n"
-      "\r\n"
-      "^n:ds[4U";
-
-  EXPECT_TRUE(request_handler.ParseRequest(kHandshakeRequestMessage,
-                                           strlen(kHandshakeRequestMessage)));
-  EXPECT_EQ(0, request_handler.protocol_version());
-
-  GURL url("ws://example.com/demo");
-  std::string challenge;
-  const HttpRequestInfo& request_info =
-      request_handler.GetRequestInfo(url, &challenge);
-
-  EXPECT_EQ(url, request_info.url);
-  EXPECT_EQ("GET", request_info.method);
-  EXPECT_FALSE(request_info.extra_headers.HasHeader("Upgrade"));
-  EXPECT_FALSE(request_info.extra_headers.HasHeader("Connection"));
-  EXPECT_FALSE(request_info.extra_headers.HasHeader("Sec-WebSocket-Key1"));
-  EXPECT_FALSE(request_info.extra_headers.HasHeader("Sec-WebSocket-Key2"));
-  std::string value;
-  EXPECT_TRUE(request_info.extra_headers.GetHeader("Host", &value));
-  EXPECT_EQ("example.com", value);
-  EXPECT_TRUE(request_info.extra_headers.GetHeader("Origin", &value));
-  EXPECT_EQ("http://example.com", value);
-  EXPECT_TRUE(request_info.extra_headers.GetHeader("Sec-WebSocket-Protocol",
-                                                   &value));
-  EXPECT_EQ("sample", value);
-
-  const char expected_challenge[] = "\x31\x6e\x41\x13\x0f\x7e\xd6\x3c^n:ds[4U";
-
-  EXPECT_EQ(expected_challenge, challenge);
-
-  static const char kHandshakeResponseHeader[] =
-      "HTTP/1.1 101 WebSocket Protocol Handshake\r\n"
-      "Sec-WebSocket-Origin: http://example.com\r\n"
-      "Sec-WebSocket-Location: ws://example.com/demo\r\n"
-      "Sec-WebSocket-Protocol: sample\r\n";
-
-  std::string raw_headers =
-      HttpUtil::AssembleRawHeaders(kHandshakeResponseHeader,
-                                   strlen(kHandshakeResponseHeader));
-  HttpResponseInfo response_info;
-  response_info.headers = new HttpResponseHeaders(raw_headers);
-
-  EXPECT_TRUE(StartsWithASCII(response_info.headers->GetStatusLine(),
-                              "HTTP/1.1 101 ", false));
-  EXPECT_FALSE(response_info.headers->HasHeader("Upgrade"));
-  EXPECT_FALSE(response_info.headers->HasHeader("Connection"));
-  EXPECT_TRUE(response_info.headers->HasHeaderValue("Sec-WebSocket-Origin",
-                                                    "http://example.com"));
-  EXPECT_TRUE(response_info.headers->HasHeaderValue("Sec-WebSocket-Location",
-                                                    "ws://example.com/demo"));
-  EXPECT_TRUE(response_info.headers->HasHeaderValue("Sec-WebSocket-Protocol",
-                                                    "sample"));
-
-  WebSocketHandshakeResponseHandler response_handler;
-  EXPECT_EQ(0, response_handler.protocol_version());
-  EXPECT_TRUE(response_handler.ParseResponseInfo(response_info, challenge));
-  EXPECT_TRUE(response_handler.HasResponse());
-
-  static const char kHandshakeResponseExpectedMessage[] =
-      "HTTP/1.1 101 WebSocket Protocol Handshake\r\n"
-      "Upgrade: WebSocket\r\n"
-      "Connection: Upgrade\r\n"
-      "Sec-WebSocket-Origin: http://example.com\r\n"
-      "Sec-WebSocket-Location: ws://example.com/demo\r\n"
-      "Sec-WebSocket-Protocol: sample\r\n"
-      "\r\n"
-      "8jKS'y:G*Co,Wxa-";
-
-  EXPECT_EQ(kHandshakeResponseExpectedMessage, response_handler.GetResponse());
-}
-
-TEST(WebSocketHandshakeHandlerTest, HttpRequestResponseHybi06Handshake) {
-  WebSocketHandshakeRequestHandler request_handler;
-
-  static const char kHandshakeRequestMessage[] =
-      "GET /demo HTTP/1.1\r\n"
-      "Host: example.com\r\n"
       "Upgrade: websocket\r\n"
       "Connection: Upgrade\r\n"
       "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
       "Sec-WebSocket-Origin: http://example.com\r\n"
       "Sec-WebSocket-Protocol: sample\r\n"
-      "Sec-WebSocket-Version: 6\r\n"
+      "Sec-WebSocket-Version: 13\r\n"
       "\r\n";
 
   EXPECT_TRUE(request_handler.ParseRequest(kHandshakeRequestMessage,
                                            strlen(kHandshakeRequestMessage)));
-  EXPECT_EQ(6, request_handler.protocol_version());
 
   GURL url("ws://example.com/demo");
   std::string challenge;
@@ -488,8 +223,6 @@ TEST(WebSocketHandshakeHandlerTest, HttpRequestResponseHybi06Handshake) {
                                                     "sample"));
 
   WebSocketHandshakeResponseHandler response_handler;
-  response_handler.set_protocol_version(request_handler.protocol_version());
-  EXPECT_EQ(6, response_handler.protocol_version());
 
   EXPECT_TRUE(response_handler.ParseResponseInfo(response_info, challenge));
   EXPECT_TRUE(response_handler.HasResponse());
@@ -505,79 +238,4 @@ TEST(WebSocketHandshakeHandlerTest, HttpRequestResponseHybi06Handshake) {
   EXPECT_EQ(kHandshakeResponseExpectedMessage, response_handler.GetResponse());
 }
 
-TEST_F(WebSocketHandshakeGetKeyNumberTest, AppendsToString) {
-  set_challenge("hello");
-  GetKeyNumber();
-  EXPECT_EQ("hello", challenge().substr(0, 5));
-}
-
-TEST_F(WebSocketHandshakeGetKeyNumberTest, AppendsFourBytes) {
-  set_challenge("hello");
-  set_key("1 1");
-  GetKeyNumber();
-  EXPECT_EQ(9u, challenge().length());
-}
-
-TEST_F(WebSocketHandshakeGetKeyNumberTest, IsBigEndian) {
-  set_key(base::StringPrintf("%u ", 0x61626364));
-  GetKeyNumber();
-  EXPECT_EQ("abcd", challenge());
-}
-
-TEST_F(WebSocketHandshakeGetKeyNumberTest, IgnoresLetters) {
-  set_key("1b 1");
-  GetKeyNumber();
-  char expected_response[] = { 0, 0, 0, 11 };
-  EXPECT_EQ(std::string(expected_response, 4), challenge());
-}
-
-TEST_F(WebSocketHandshakeGetKeyNumberTest, DividesBySpaces) {
-  set_key("1 2");
-  GetKeyNumber();
-  EXPECT_EQ(12, challenge()[3]);
-  reset_challenge();
-  set_key("1  2");
-  GetKeyNumber();
-  EXPECT_EQ(6, challenge()[3]);
-  reset_challenge();
-  set_key(" 1  2");
-  GetKeyNumber();
-  EXPECT_EQ(4, challenge()[3]);
-  reset_challenge();
-  set_key(" 1  2 ");
-  GetKeyNumber();
-  EXPECT_EQ(3, challenge()[3]);
-}
-
-TEST_F(WebSocketHandshakeGetKeyNumberTest, MatchesExampleFromDraft) {
-  set_key("3e6b263  4 17 80");
-  GetKeyNumber();
-  char expected_response[] = { 0x36, 0x09, 0x65, 0x65 };
-  EXPECT_EQ(std::string(expected_response, 4), challenge());
-}
-
-TEST_F(WebSocketHandshakeGetKeyNumberTest, Maximum32bitInteger) {
-  set_key("4294967295 ");
-  GetKeyNumber();
-  char expected_response[] = { '\xFF', '\xFF', '\xFF', '\xFF' };
-  EXPECT_EQ(std::string(expected_response, 4), challenge());
-}
-
-#if GTEST_HAS_DEATH_TEST && !defined(NDEBUG)
-TEST_F(WebSocketHandshakeGetKeyNumberDeathTest, ThirtyThreeBitIntegerNoGood) {
-  set_key(" 4294967296");
-  EXPECT_DEBUG_DEATH(GetKeyNumber(), "overflow");
-}
-
-TEST_F(WebSocketHandshakeGetKeyNumberDeathTest, NoSpacesNoGood) {
-  set_key("11");
-  EXPECT_DEBUG_DEATH(GetKeyNumber(), "space");
-}
-
-TEST_F(WebSocketHandshakeGetKeyNumberDeathTest, MustBeIntegralMultiple) {
-  set_key("1  1");
-  EXPECT_DEBUG_DEATH(GetKeyNumber(), "spaces");
-}
-#endif  // GTEST_HAS_DEATH_TEST && !defined(NDEBUG)
-
 }  // namespace net
diff --git a/net/websockets/websocket_job.cc b/net/websockets/websocket_job.cc
index 50d1218..b0f5be8 100644
--- a/net/websockets/websocket_job.cc
+++ b/net/websockets/websocket_job.cc
@@ -358,9 +358,6 @@ bool WebSocketJob::SendHandshakeRequest(const char* data, int len) {
   if (!handshake_request_->ParseRequest(data, len))
     return false;
 
-  // handshake message is completed.
-  handshake_response_->set_protocol_version(
-      handshake_request_->protocol_version());
   AddCookieHeaderAndSend();
   return true;
 }