anchor.diff:  This value cannot be changed once it is set. It defaults to
   `infinity`.
   
  -=== Hibernate
  -
  -Most tuples returned from handler callbacks can include an
  -extra value `hibernate`. After doing any necessary operations
  -following the return of the callback, Cowboy will hibernate
  -the process.
  -
  -It is highly recommended to hibernate processes that do not
  -handle much traffic. It is a good idea to hibernate all
  -connections by default and investigate only when you start
  -noticing increased CPU usage.
  -
  -=== Supporting older browsers
  -
  -Unfortunately Websocket is a relatively recent technology,
  -which means that not all browsers support it. A library like
  -https://github.com/ninenines/bullet[Bullet] can be used to
  -emulate Websocket connections on older browsers.
  +// @todo Perhaps the default should be changed.
  +
  +=== Saving memory
  +
  +The Websocket connection process can be set to hibernate
  +after the callback returns.
  +
  +Simply add an `hibernate` field to the ok or reply tuples:
  +
  +[source,erlang]
  +----
  +websocket_init(State) ->
  +	{ok, State, hibernate}.
  +
  +websocket_handle(_Frame, State) ->
  +	{ok, State, hibernate}.
  +
  +websocket_info(_Info, State) ->
  +	{reply, {text, <<"Hello!">>}, State, hibernate}.
  +----
  +
  +It is highly recommended to write your handlers with
  +hibernate enabled, as this allows to greatly reduce the
  +memory usage. Do note however that an increase in the
  +CPU usage or latency can be observed instead, in particular
  +for the more busy connections.
  +
  +=== Closing the connection
  +
  +The connection can be closed at any time, either by telling
  +Cowboy to stop it or by sending a close frame.
  +
  +To tell Cowboy to close the connection, use a stop tuple:
  +
  +[source,erlang]
  +----
  +websocket_info(_Info, State) ->
  +	{stop, State}.
  +----
  +
  +Sending a `close` frame will immediately initiate the closing
  +of the Websocket connection. Note that when sending a list of
  +frames that include a close frame, any frame found after the
  +close frame will not be sent.
  
positive.code: 	{ok, State}.
  ----
  
  === Sending frames to the socket
  
  Cowboy allows sending either a single frame or a list of
  frames to the socket, in which case the frames are sent
  sequentially. Any frame can be sent: text, binary, ping,
  pong or close frames.
  
  The following example sends three frames using a single `reply`
  tuple.
  
  [source,erlang]
  ----
  websocket_info(hello_world, State) ->
  	{reply, [
  		{text, "Hello"},
  		{text, <<"world!">>},
  		{binary, <<0:8000>>}
  	], State};
  %% More websocket_info/2 clauses here...
  ----
  
  Note that the payload for text and binary frames is of type
  `iodata()`, meaning it can be either a `binary()` or an
  `iolist()`.
  
  Sending a `close` frame will immediately initiate the closing
  of the Websocket connection. Be aware that any additional
  frames sent by the client or any Erlang messages waiting to
  be received will not be processed. Also note that when replying
  a list of frames that includes close, any frame found after the
  close frame will not be sent.
  
  === Ping and timeout
  
  The biggest performance improvement you can do when dealing
  with a huge number of Websocket connections is to reduce the
  number of timers that are started on the server. A common use
  of timers when dealing with connections is for sending a ping
  every once in a while. This should be done exclusively on the
  client side. Indeed, a server handling one million Websocket
  connections will perform a lot better when it doesn't have to
  handle one million extra timers too!
  
  Cowboy will automatically respond to ping frames sent by the
  client. It will still forward the frame to the handler for
  informative purpose, but no further action is required.
  
  Cowboy can be configured to automatically close the Websocket
  connection when no data arrives on the socket. It is highly
  recommended to configure a timeout for it, as otherwise you
  may end up with zombie "half-connected" sockets that may
  leave the process alive forever.
  
  A good timeout value is 60 seconds.
  
  [source,erlang]
  ----
  
negative.code: 	{cowboy_websocket, Req, State}.
  ----
  
  Cowboy will perform the Websocket handshake immediately. Note
  that the handshake will fail if the client did not request an
  upgrade to Websocket.
  
  The Req object becomes unavailable after this function returns.
  Any information required for proper execution of the Websocket
  handler must be saved in the state.
  
  === Subprotocol
  
  The client may provide a list of Websocket subprotocols it
  supports in the sec-websocket-protocol header. The server *must*
  select one of them and send it back to the client or the
  handshake will fail.
  
  For example, a client could understand both STOMP and MQTT over
  Websocket, and provide the header:
  
  ----
  sec-websocket-protocol: v12.stomp, mqtt
  ----
  
  If the server only understands MQTT it can return:
  
  ----
  sec-websocket-protocol: mqtt
  ----
  
  This selection must be done in `init/2`. An example usage could
  be:
  
  [source,erlang]
  ----
  