[WebSocket] Add tests for permessage deflate split frames.

Tools/Scripts/webkitpy/thirdparty/mod_pywebsocket/handshake/hybi.py

 # Copyright 2012, Google Inc.
 # All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
@@ skipping 51 matching lines @@
 from mod_pywebsocket.stream import StreamOptions
 from mod_pywebsocket import util
 
 
 # Used to validate the value in the Sec-WebSocket-Key header strictly. RFC 4648
 # disallows non-zero padding, so the character right before == must be any of
 # A, Q, g and w.
 _SEC_WEBSOCKET_KEY_REGEX = re.compile('^[+/0-9A-Za-z]{21}[AQgw]==$')
 
 # Defining aliases for values used frequently.
-_VERSION_HYBI08 = common.VERSION_HYBI08
-_VERSION_HYBI08_STRING = str(_VERSION_HYBI08)
 _VERSION_LATEST = common.VERSION_HYBI_LATEST
 _VERSION_LATEST_STRING = str(_VERSION_LATEST)
 _SUPPORTED_VERSIONS = [
     _VERSION_LATEST,
-    _VERSION_HYBI08,
 ]
 
 
 def compute_accept(key):
     """Computes value for the Sec-WebSocket-Accept header from value of the
     Sec-WebSocket-Key header.
     """
 
     accept_binary = util.sha1_hash(
         key + common.WEBSOCKET_ACCEPT_UUID).digest()
@@ skipping 54 matching lines @@
             common.WEBSOCKET_UPGRADE_TYPE)
 
         self._validate_connection_header()
 
         self._request.ws_resource = self._request.uri
 
         unused_host = get_mandatory_header(self._request, common.HOST_HEADER)
 
         self._request.ws_version = self._check_version()
 
-        # This handshake must be based on latest hybi. We are responsible to
-        # fallback to HTTP on handshake failure as latest hybi handshake
-        # specifies.
         try:
             self._get_origin()
             self._set_protocol()
             self._parse_extensions()
 
             # Key validation, response generation.
 
             key = self._get_key()
             (accept, accept_binary) = compute_accept(key)
             self._logger.debug(
@@ skipping 113 matching lines @@
                         'request any subprotocol')
 
             self._send_handshake(accept)
         except HandshakeException, e:
             if not e.status:
                 # Fallback to 400 bad request by default.
                 e.status = common.HTTP_STATUS_BAD_REQUEST
             raise e
 
     def _get_origin(self):
-        if self._request.ws_version is _VERSION_HYBI08:
-            origin_header = common.SEC_WEBSOCKET_ORIGIN_HEADER
-        else:
-            origin_header = common.ORIGIN_HEADER
+        origin_header = common.ORIGIN_HEADER
         origin = self._request.headers_in.get(origin_header)
         if origin is None:
             self._logger.debug('Client request does not have origin header')
         self._request.ws_origin = origin
 
     def _check_version(self):
         version = get_mandatory_header(self._request,
                                        common.SEC_WEBSOCKET_VERSION_HEADER)
-        if version == _VERSION_HYBI08_STRING:
-            return _VERSION_HYBI08
         if version == _VERSION_LATEST_STRING:
             return _VERSION_LATEST
 
         if version.find(',') >= 0:
             raise HandshakeException(
                 'Multiple versions (%r) are not allowed for header %s' %
                 (version, common.SEC_WEBSOCKET_VERSION_HEADER),
                 status=common.HTTP_STATUS_BAD_REQUEST)
         raise VersionException(
             'Unsupported version %r for header %s' %
@@ skipping 15 matching lines @@
         self._logger.debug('Subprotocols requested: %r',
                            self._request.ws_requested_protocols)
 
     def _parse_extensions(self):
         extensions_header = self._request.headers_in.get(
             common.SEC_WEBSOCKET_EXTENSIONS_HEADER)
         if not extensions_header:
             self._request.ws_requested_extensions = None
             return
 
-        if self._request.ws_version is common.VERSION_HYBI08:
-            allow_quoted_string=False
-        else:
-            allow_quoted_string=True
         try:
             self._request.ws_requested_extensions = common.parse_extensions(
-                extensions_header, allow_quoted_string=allow_quoted_string)
+                extensions_header)
         except common.ExtensionParsingException, e:
             raise HandshakeException(
                 'Failed to parse Sec-WebSocket-Extensions header: %r' % e)
 
         self._logger.debug(
             'Extensions requested: %r',
             map(common.ExtensionParameter.name,
                 self._request.ws_requested_extensions))
 
     def _validate_key(self, key):
@@ skipping 71 matching lines @@
         return ''.join(response)
 
     def _send_handshake(self, accept):
         raw_response = self._create_handshake_response(accept)
         self._request.connection.write(raw_response)
         self._logger.debug('Sent server\'s opening handshake: %r',
                            raw_response)
 
 
 # vi:sts=4 sw=4 et