private bool processClose(WsFrame frame)
        {
            if (!frame.IsClose)
            return false;

              #if DEBUG
              Console.WriteLine("WS: [email protected]: Start closing handshake.");
              #endif
              close(frame.PayloadData);

              return true;
        }

 private bool processFrame(WsFrame frame)
 {
     return frame.IsCompressed && _compression == CompressionMethod.NONE
      ? processUnsupportedFrame (
          frame,
          CloseStatusCode.INCORRECT_DATA,
          "A compressed data has been received without available decompression method.")
      : frame.IsFragmented
        ? processFragmentedFrame (frame)
        : frame.IsData
          ? processDataFrame (frame)
          : frame.IsPing
            ? processPingFrame (frame)
            : frame.IsPong
              ? processPongFrame ()
              : frame.IsClose
                ? processCloseFrame (frame)
                : processUnsupportedFrame (frame, CloseStatusCode.POLICY_VIOLATION, null);
 }

        private bool processUnsupportedFrame(WsFrame frame, CloseStatusCode code, string reason)
        {
            _logger.Debug ("Unsupported frame:\n" + frame.PrintToString (false));
              processException (new WebSocketException (code, reason), null);

              return false;
        }

        private bool processCloseFrame(WsFrame frame)
        {
            var payload = frame.PayloadData;
              close (payload, !payload.ContainsReservedCloseStatusCode, false);

              return false;
        }

 private bool processFragmentedFrame(WsFrame frame)
 {
     return frame.IsContinuation // Not first fragment
      ? true
      : processFragments (frame);
 }

 private bool acceptFrame(WsFrame frame)
 {
     return frame.IsCompressed && _compression == CompressionMethod.None
      ? acceptUnsupportedFrame (
          frame,
          CloseStatusCode.IncorrectData,
          "A compressed data has been received without available decompression method.")
      : frame.IsFragmented
        ? acceptFragmentedFrame (frame)
        : frame.IsData
          ? acceptDataFrame (frame)
          : frame.IsPing
            ? acceptPingFrame (frame)
            : frame.IsPong
              ? acceptPongFrame (frame)
              : frame.IsClose
                ? acceptCloseFrame (frame)
                : acceptUnsupportedFrame (frame, CloseStatusCode.PolicyViolation, null);
 }

        private bool acceptPongFrame(WsFrame frame)
        {
            _receivePong.Set ();
              _logger.Trace ("Received a Pong.");

              return true;
        }

        private bool processFragmented(WsFrame frame)
        {
            // Not first fragment
              if (frame.IsContinuation)
            return true;

              // Not fragmented
              if (frame.IsFinal)
            return false;

              bool incorrect = !frame.IsData ||
                       (frame.IsCompressed && _compression == CompressionMethod.NONE);

              if (!incorrect)
            processFragments (frame);
              else
            processIncorrectFrame ();

              return true;
        }

        private void processFrame(WsFrame frame)
        {
            bool processed = processAbnormal (frame) ||
                       processFragmented (frame) ||
                       processData (frame) ||
                       processPing (frame) ||
                       processPong (frame) ||
                       processClose (frame);

              if (!processed)
            processIncorrectFrame ();
        }

        private bool processClose(WsFrame frame)
        {
            if (!frame.IsClose)
            return false;

              _logger.Trace ("Start closing handshake.");
              close (frame.PayloadData);

              return true;
        }

        private bool processData(WsFrame frame)
        {
            if (!frame.IsData)
            return false;

              if (frame.IsCompressed && _compression == CompressionMethod.NONE)
            return false;

              var args = frame.IsCompressed
               ? new MessageEventArgs (
                   frame.Opcode, frame.PayloadData.ApplicationData.Decompress (_compression))
               : new MessageEventArgs (frame.Opcode, frame.PayloadData);

              OnMessage.Emit (this, args);
              return true;
        }

        private bool processAbnormal(WsFrame frame)
        {
            if (frame != null)
            return false;

              _logger.Trace ("Start closing handshake.");
              var code = CloseStatusCode.ABNORMAL;
              Close (code, code.GetMessage ());

              return true;
        }

        private bool processPong(WsFrame frame)
        {
            if (!frame.IsPong)
            return false;

              #if DEBUG
              Console.WriteLine("WS: [email protected]: Receive Pong.");
              #endif
              _receivePong.Set();

              return true;
        }

        private bool processPing(WsFrame frame)
        {
            if (!frame.IsPing)
            return false;

              #if DEBUG
              Console.WriteLine("WS: [email protected]: Return Pong.");
              #endif
              pong(frame.PayloadData);

              return true;
        }

        private bool acceptDataFrame(WsFrame frame)
        {
            var args = frame.IsCompressed
                 ? new MessageEventArgs (
                     frame.Opcode, frame.PayloadData.ApplicationData.Decompress (_compression))
                 : new MessageEventArgs (frame.Opcode, frame.PayloadData);

              if (_readyState == WebSocketState.Open)
            OnMessage.Emit (this, args);

              return true;
        }

        private bool processPing(WsFrame frame)
        {
            if (!frame.IsPing)
            return false;

              _logger.Trace ("Return Pong.");
              pong (frame.PayloadData);

              return true;
        }

 private bool acceptFragmentedFrame(WsFrame frame)
 {
     return frame.IsContinuation // Not first fragment
      ? true
      : acceptFragments (frame);
 }

        private bool processPong(WsFrame frame)
        {
            if (!frame.IsPong)
            return false;

              _logger.Trace ("Receive Pong.");
              _receivePong.Set ();

              return true;
        }

        private bool acceptPingFrame(WsFrame frame)
        {
            var mask = _client ? Mask.Mask : Mask.Unmask;
              if (send (WsFrame.CreatePongFrame (mask, frame.PayloadData)))
            _logger.Trace ("Returned a Pong.");

              return true;
        }

        private bool send(WsFrame frame)
        {
            lock (_forFrame)
              {
            var ready = _stream == null
                    ? false
                    : _readyState == WebSocketState.OPEN
                      ? true
                      : _readyState == WebSocketState.CLOSING
                        ? frame.IsClose
                        : false;

            if (!ready)
            {
              var msg = "The WebSocket connection isn't established or has been closed.";
              _logger.Error (msg);
              error (msg);

              return false;
            }

            return _stream.WriteFrame (frame);
              }
        }