Format all dart: library files

sdk/lib/io/websocket_impl.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of dart.io;
 
 const String _webSocketGUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
 const String _clientNoContextTakeover = "client_no_context_takeover";
 const String _serverNoContextTakeover = "server_no_context_takeover";
 const String _clientMaxWindowBits = "client_max_window_bits";
@@ skipping 46 matching lines @@
  * The web socket protocol transformer handles the protocol byte stream
  * which is supplied through the `handleData`. As the protocol is processed,
  * it'll output frame data as either a List<int> or String.
  *
  * Important information about usage: Be sure you use cancelOnError, so the
  * socket will be closed when the processor encounter an error. Not using it
  * will lead to undefined behaviour.
  */
 // TODO(ajohnsen): make this transformer reusable?
 class _WebSocketProtocolTransformer
-    implements EventSink<List<int>>, StreamTransformer<
-        List<int>, dynamic/*List<int>|_WebSocketPing|_WebSocketPong>*/> {
+    implements
+        EventSink<List<int>>,
+        StreamTransformer<List<int>,
+            dynamic /*List<int>|_WebSocketPing|_WebSocketPong>*/ > {
   static const int START = 0;
   static const int LEN_FIRST = 1;
   static const int LEN_REST = 2;
   static const int MASK = 3;
   static const int PAYLOAD = 4;
   static const int CLOSED = 5;
   static const int FAILURE = 6;
   static const int FIN = 0x80;
   static const int RSV1 = 0x40;
   static const int RSV2 = 0x20;
   static const int RSV3 = 0x10;
   static const int OPCODE = 0xF;
 
   int _state = START;
   bool _fin = false;
   bool _compressed = false;
   int _opcode = -1;
   int _len = -1;
   bool _masked = false;
   int _remainingLenBytes = -1;
   int _remainingMaskingKeyBytes = 4;
   int _remainingPayloadBytes = -1;
   int _unmaskingIndex = 0;
   int _currentMessageType = _WebSocketMessageType.NONE;
   int closeCode = WebSocketStatus.NO_STATUS_RECEIVED;
   String closeReason = "";
 
-  EventSink<dynamic/*List<int>|_WebSocketPing|_WebSocketPong>*/> _eventSink;
+  EventSink<dynamic /*List<int>|_WebSocketPing|_WebSocketPong>*/ > _eventSink;
 
   final bool _serverSide;
   final List _maskingBytes = new List(4);
   final BytesBuilder _payload = new BytesBuilder(copy: false);
 
   _WebSocketPerMessageDeflate _deflate;
   _WebSocketProtocolTransformer([this._serverSide = false, this._deflate]);
 
-  Stream<dynamic/*List<int>|_WebSocketPing|_WebSocketPong>*/> bind(
+  Stream<dynamic /*List<int>|_WebSocketPing|_WebSocketPong>*/ > bind(
       Stream<List<int>> stream) {
     return new Stream.eventTransformed(stream, (EventSink eventSink) {
       if (_eventSink != null) {
         throw new StateError("WebSocket transformer already used.");
       }
       _eventSink = eventSink;
       return this;
     });
   }
 
   void addError(Object error, [StackTrace stackTrace]) {
     _eventSink.addError(error, stackTrace);
   }
 
-  void close() { _eventSink.close(); }
+  void close() {
+    _eventSink.close();
+  }
 
   /**
    * Process data received from the underlying communication channel.
    */
   void add(List<int> bytes) {
     var buffer = bytes is Uint8List ? bytes : new Uint8List.fromList(bytes);
     int index = 0;
     int lastIndex = buffer.length;
     if (_state == CLOSED) {
       throw new WebSocketException("Data on closed connection");
     }
     if (_state == FAILURE) {
       throw new WebSocketException("Data on failed connection");
     }
     while ((index < lastIndex) && _state != CLOSED && _state != FAILURE) {
       int byte = buffer[index];
       if (_state <= LEN_REST) {
         if (_state == START) {
           _fin = (byte & FIN) != 0;
 
-          if((byte & (RSV2 | RSV3)) != 0) {
+          if ((byte & (RSV2 | RSV3)) != 0) {
             // The RSV2, RSV3 bits must both be zero.
             throw new WebSocketException("Protocol error");
           }
 
           _opcode = (byte & OPCODE);
 
           if (_opcode != _WebSocketOpcode.CONTINUATION) {
             if ((byte & RSV1) != 0) {
               _compressed = true;
             } else {
@@ skipping 336 matching lines @@
 
     extensionHeader ??= "";
 
     var hv = HeaderValue.parse(extensionHeader, valueSeparator: ',');
     if (compression.enabled && hv.value == _WebSocketImpl.PER_MESSAGE_DEFLATE) {
       var info = compression._createHeader(hv);
 
       response.headers.add("Sec-WebSocket-Extensions", info.headerValue);
       var serverNoContextTakeover =
           (hv.parameters.containsKey(_serverNoContextTakeover) &&
-            compression.serverNoContextTakeover);
+              compression.serverNoContextTakeover);
       var clientNoContextTakeover =
           (hv.parameters.containsKey(_clientNoContextTakeover) &&
-            compression.clientNoContextTakeover);
+              compression.clientNoContextTakeover);
       var deflate = new _WebSocketPerMessageDeflate(
           serverNoContextTakeover: serverNoContextTakeover,
           clientNoContextTakeover: clientNoContextTakeover,
           serverMaxWindowBits: info.maxWindowBits,
           clientMaxWindowBits: info.maxWindowBits,
           serverSide: true);
 
       return deflate;
     }
 
@@ skipping 33 matching lines @@
   bool clientNoContextTakeover;
   int clientMaxWindowBits;
   int serverMaxWindowBits;
   bool serverSide;
 
   _Filter decoder;
   _Filter encoder;
 
   _WebSocketPerMessageDeflate(
       {this.clientMaxWindowBits: _WebSocketImpl.DEFAULT_WINDOW_BITS,
-       this.serverMaxWindowBits: _WebSocketImpl.DEFAULT_WINDOW_BITS,
-       this.serverNoContextTakeover: false,
-       this.clientNoContextTakeover: false,
-       this.serverSide: false});
+      this.serverMaxWindowBits: _WebSocketImpl.DEFAULT_WINDOW_BITS,
+      this.serverNoContextTakeover: false,
+      this.clientNoContextTakeover: false,
+      this.serverSide: false});
 
   void _ensureDecoder() {
     if (decoder == null) {
       decoder = _Filter._newZLibInflateFilter(
           serverSide ? clientMaxWindowBits : serverMaxWindowBits, null, true);
     }
   }
 
   void _ensureEncoder() {
     if (encoder == null) {
@@ skipping 74 matching lines @@
   final _WebSocketImpl webSocket;
   EventSink<List<int>> _eventSink;
 
   _WebSocketPerMessageDeflate _deflateHelper;
 
   _WebSocketOutgoingTransformer(this.webSocket) {
     _deflateHelper = webSocket._deflate;
   }
 
   Stream<List<int>> bind(Stream stream) {
-    return new Stream<List<int>>.eventTransformed(
-        stream, (EventSink<List<int>> eventSink) {
+    return new Stream<List<int>>.eventTransformed(stream,
+        (EventSink<List<int>> eventSink) {
       if (_eventSink != null) {
         throw new StateError("WebSocket transformer already used");
       }
       _eventSink = eventSink;
       return this;
     });
   }
 
   void add(message) {
     if (message is _WebSocketPong) {
@@ skipping 49 matching lines @@
     _eventSink.close();
   }
 
   void addFrame(int opcode, List<int> data) {
     createFrame(
         opcode,
         data,
         webSocket._serverSide,
         _deflateHelper != null &&
             (opcode == _WebSocketOpcode.TEXT ||
-                opcode == _WebSocketOpcode.BINARY))
-      .forEach((e) { _eventSink.add(e); });
+                opcode == _WebSocketOpcode.BINARY)).forEach((e) {
+      _eventSink.add(e);
+    });
   }
 
   static Iterable<List<int>> createFrame(
       int opcode, List<int> data, bool serverSide, bool compressed) {
     bool mask = !serverSide; // Masking not implemented for server.
     int dataLength = data == null ? 0 : data.length;
     // Determine the header size.
     int headerSize = (mask) ? 6 : 2;
     if (dataLength > 65535) {
       headerSize += 8;
     } else if (dataLength > 125) {
       headerSize += 2;
     }
     Uint8List header = new Uint8List(headerSize);
     int index = 0;
 
     // Set FIN and opcode.
-    var hoc = _WebSocketProtocolTransformer.FIN
-              | (compressed ? _WebSocketProtocolTransformer.RSV1 : 0)
-              | (opcode & _WebSocketProtocolTransformer.OPCODE);
+    var hoc = _WebSocketProtocolTransformer.FIN |
+        (compressed ? _WebSocketProtocolTransformer.RSV1 : 0) |
+        (opcode & _WebSocketProtocolTransformer.OPCODE);
 
     header[index++] = hoc;
     // Determine size and position of length field.
     int lengthBytes = 1;
     if (dataLength > 65535) {
       header[index++] = 127;
       lengthBytes = 8;
     } else if (dataLength > 125) {
       header[index++] = 126;
       lengthBytes = 2;
@@ skipping 152 matching lines @@
       _issuedPause = false;
     }
     return _completer.future;
   }
 
   Future close() {
     _ensureController();
     Future closeSocket() {
       return socket.close().catchError((_) {}).then((_) => webSocket);
     }
+
     _controller.close();
     return _closeCompleter.future.then((_) => closeSocket());
   }
 
   void add(data) {
     if (_closed) return;
     _ensureController();
     _controller.add(data);
   }
 
@@ skipping 78 matching lines @@
         request.headers.add("Sec-WebSocket-Protocol", protocols.toList());
       }
 
       if (compression.enabled) {
         request.headers
             .add("Sec-WebSocket-Extensions", compression._createHeader());
       }
 
       return request.close();
     }).then((response) {
-
       void error(String message) {
         // Flush data.
         response.detachSocket().then((socket) {
           socket.destroy();
         });
         throw new WebSocketException(message);
       }
 
       if (response.statusCode != HttpStatus.SWITCHING_PROTOCOLS ||
           response.headers[HttpHeaders.CONNECTION] == null ||
@@ skipping 105 matching lines @@
         }
         _readyState = WebSocket.CLOSED;
       }
       // Protocol close, use close code from transformer.
       _closeCode = transformer.closeCode;
       _closeReason = transformer.closeReason;
       _controller.close();
     }, cancelOnError: true);
     _subscription.pause();
     _controller = new StreamController(
-        sync: true, onListen: _subscription.resume, onCancel: () {
-      _subscription.cancel();
-      _subscription = null;
-    }, onPause: _subscription.pause, onResume: _subscription.resume);
+        sync: true,
+        onListen: _subscription.resume,
+        onCancel: () {
+          _subscription.cancel();
+          _subscription = null;
+        },
+        onPause: _subscription.pause,
+        onResume: _subscription.resume);
 
     _webSockets[_serviceId] = this;
     try {
       _socket._owner = this;
     } catch (_) {}
   }
 
   StreamSubscription listen(void onData(message),
       {Function onError, void onDone(), bool cancelOnError}) {
     return _controller.stream.listen(onData,
@@ skipping 18 matching lines @@
       });
     });
   }
 
   int get readyState => _readyState;
 
   String get extensions => null;
   int get closeCode => _closeCode;
   String get closeReason => _closeReason;
 
-  void add(data) { _sink.add(data); }
+  void add(data) {
+    _sink.add(data);
+  }
+
   void addUtf8Text(List<int> bytes) {
     if (bytes is! List<int>) {
       throw new ArgumentError.value(bytes, "bytes", "Is not a list of bytes");
     }
     _sink.add(new _EncodedString(bytes));
   }
+
   void addError(error, [StackTrace stackTrace]) {
     _sink.addError(error, stackTrace);
   }
+
   Future addStream(Stream stream) => _sink.addStream(stream);
   Future get done => _sink.done;
 
   Future close([int code, String reason]) {
     if (_isReservedStatusCode(code)) {
       throw new WebSocketException("Reserved status code $code");
     }
     if (_outCloseCode == null) {
       _outCloseCode = code;
       _outCloseReason = reason;
@@ skipping 64 matching lines @@
     return code != null &&
         (code < WebSocketStatus.NORMAL_CLOSURE ||
             code == WebSocketStatus.RESERVED_1004 ||
             code == WebSocketStatus.NO_STATUS_RECEIVED ||
             code == WebSocketStatus.ABNORMAL_CLOSURE ||
             (code > WebSocketStatus.INTERNAL_SERVER_ERROR &&
                 code < WebSocketStatus.RESERVED_1015) ||
             (code >= WebSocketStatus.RESERVED_1015 && code < 3000));
   }
 }