Check in generated Dart bindings and add presubmit script

mojo/dart/packages/mojo_services/lib/mojo/web_socket.mojom.dart

Index: mojo/dart/packages/mojo_services/lib/mojo/web_socket.mojom.dart
diff --git a/mojo/dart/packages/mojo_services/lib/mojo/web_socket.mojom.dart b/mojo/dart/packages/mojo_services/lib/mojo/web_socket.mojom.dart
new file mode 100644
index 0000000000000000000000000000000000000000..53ddcaa3b69077024d1e6b30c814553e6ed2b587
--- /dev/null
+++ b/mojo/dart/packages/mojo_services/lib/mojo/web_socket.mojom.dart
@@ -0,0 +1,1289 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+library web_socket_mojom;
+
+import 'dart:async';
+
+import 'package:mojo/bindings.dart' as bindings;
+import 'package:mojo/core.dart' as core;
+import 'package:mojo/mojo/network_error.mojom.dart' as network_error_mojom;
+
+
+
+class WebSocketConnectParams extends bindings.Struct {
+  static const List<bindings.StructDataHeader> kVersions = const [
+    const bindings.StructDataHeader(48, 0)
+  ];
+  String url = null;
+  List<String> protocols = null;
+  String origin = null;
+  core.MojoDataPipeConsumer sendStream = null;
+  Object client = null;
+
+  WebSocketConnectParams() : super(kVersions.last.size);
+
+  static WebSocketConnectParams deserialize(bindings.Message message) {
+    var decoder = new bindings.Decoder(message);
+    var result = decode(decoder);
+    if (decoder.excessHandles != null) {
+      decoder.excessHandles.forEach((h) => h.close());
+    }
+    return result;
+  }
+
+  static WebSocketConnectParams decode(bindings.Decoder decoder0) {
+    if (decoder0 == null) {
+      return null;
+    }
+    WebSocketConnectParams result = new WebSocketConnectParams();
+
+    var mainDataHeader = decoder0.decodeStructDataHeader();
+    if (mainDataHeader.version <= kVersions.last.version) {
+      // Scan in reverse order to optimize for more recent versions.
+      for (int i = kVersions.length - 1; i >= 0; --i) {
+        if (mainDataHeader.version >= kVersions[i].version) {
+          if (mainDataHeader.size == kVersions[i].size) {
+            // Found a match.
+            break;
+          }
+          throw new bindings.MojoCodecError(
+              'Header size doesn\'t correspond to known version size.');
+        }
+      }
+    } else if (mainDataHeader.size < kVersions.last.size) {
+      throw new bindings.MojoCodecError(
+        'Message newer than the last known version cannot be shorter than '
+        'required by the last known version.');
+    }
+    if (mainDataHeader.version >= 0) {
+      
+      result.url = decoder0.decodeString(8, false);
+    }
+    if (mainDataHeader.version >= 0) {
+      
+      var decoder1 = decoder0.decodePointer(16, false);
+      {
+        var si1 = decoder1.decodeDataHeaderForPointerArray(bindings.kUnspecifiedArrayLength);
+        result.protocols = new List<String>(si1.numElements);
+        for (int i1 = 0; i1 < si1.numElements; ++i1) {
+          
+          result.protocols[i1] = decoder1.decodeString(bindings.ArrayDataHeader.kHeaderSize + bindings.kPointerSize * i1, false);
+        }
+      }
+    }
+    if (mainDataHeader.version >= 0) {
+      
+      result.origin = decoder0.decodeString(24, false);
+    }
+    if (mainDataHeader.version >= 0) {
+      
+      result.sendStream = decoder0.decodeConsumerHandle(32, false);
+    }
+    if (mainDataHeader.version >= 0) {
+      
+      result.client = decoder0.decodeServiceInterface(36, false, WebSocketClientProxy.newFromEndpoint);
+    }
+    return result;
+  }
+
+  void encode(bindings.Encoder encoder) {
+    var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
+    
+    encoder0.encodeString(url, 8, false);
+    
+    if (protocols == null) {
+      encoder0.encodeNullPointer(16, false);
+    } else {
+      var encoder1 = encoder0.encodePointerArray(protocols.length, 16, bindings.kUnspecifiedArrayLength);
+      for (int i0 = 0; i0 < protocols.length; ++i0) {
+        
+        encoder1.encodeString(protocols[i0], bindings.ArrayDataHeader.kHeaderSize + bindings.kPointerSize * i0, false);
+      }
+    }
+    
+    encoder0.encodeString(origin, 24, false);
+    
+    encoder0.encodeConsumerHandle(sendStream, 32, false);
+    
+    encoder0.encodeInterface(client, 36, false);
+  }
+
+  String toString() {
+    return "WebSocketConnectParams("
+           "url: $url" ", "
+           "protocols: $protocols" ", "
+           "origin: $origin" ", "
+           "sendStream: $sendStream" ", "
+           "client: $client" ")";
+  }
+
+  Map toJson() {
+    throw new bindings.MojoCodecError(
+        'Object containing handles cannot be encoded to JSON.');
+  }
+}
+
+
+class WebSocketSendParams extends bindings.Struct {
+  static const List<bindings.StructDataHeader> kVersions = const [
+    const bindings.StructDataHeader(24, 0)
+  ];
+  bool fin = false;
+  WebSocketMessageType type = null;
+  int numBytes = 0;
+
+  WebSocketSendParams() : super(kVersions.last.size);
+
+  static WebSocketSendParams deserialize(bindings.Message message) {
+    var decoder = new bindings.Decoder(message);
+    var result = decode(decoder);
+    if (decoder.excessHandles != null) {
+      decoder.excessHandles.forEach((h) => h.close());
+    }
+    return result;
+  }
+
+  static WebSocketSendParams decode(bindings.Decoder decoder0) {
+    if (decoder0 == null) {
+      return null;
+    }
+    WebSocketSendParams result = new WebSocketSendParams();
+
+    var mainDataHeader = decoder0.decodeStructDataHeader();
+    if (mainDataHeader.version <= kVersions.last.version) {
+      // Scan in reverse order to optimize for more recent versions.
+      for (int i = kVersions.length - 1; i >= 0; --i) {
+        if (mainDataHeader.version >= kVersions[i].version) {
+          if (mainDataHeader.size == kVersions[i].size) {
+            // Found a match.
+            break;
+          }
+          throw new bindings.MojoCodecError(
+              'Header size doesn\'t correspond to known version size.');
+        }
+      }
+    } else if (mainDataHeader.size < kVersions.last.size) {
+      throw new bindings.MojoCodecError(
+        'Message newer than the last known version cannot be shorter than '
+        'required by the last known version.');
+    }
+    if (mainDataHeader.version >= 0) {
+      
+      result.fin = decoder0.decodeBool(8, 0);
+    }
+    if (mainDataHeader.version >= 0) {
+      
+        result.type = WebSocketMessageType.decode(decoder0, 12);
+        if (result.type == null) {
+          throw new bindings.MojoCodecError(
+            'Trying to decode null union for non-nullable WebSocketMessageType.');
+        }
+    }
+    if (mainDataHeader.version >= 0) {
+      
+      result.numBytes = decoder0.decodeUint32(16);
+    }
+    return result;
+  }
+
+  void encode(bindings.Encoder encoder) {
+    var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
+    
+    encoder0.encodeBool(fin, 8, 0);
+    
+    encoder0.encodeEnum(type, 12);
+    
+    encoder0.encodeUint32(numBytes, 16);
+  }
+
+  String toString() {
+    return "WebSocketSendParams("
+           "fin: $fin" ", "
+           "type: $type" ", "
+           "numBytes: $numBytes" ")";
+  }
+
+  Map toJson() {
+    Map map = new Map();
+    map["fin"] = fin;
+    map["type"] = type;
+    map["numBytes"] = numBytes;
+    return map;
+  }
+}
+
+
+class WebSocketFlowControlParams extends bindings.Struct {
+  static const List<bindings.StructDataHeader> kVersions = const [
+    const bindings.StructDataHeader(16, 0)
+  ];
+  int quota = 0;
+
+  WebSocketFlowControlParams() : super(kVersions.last.size);
+
+  static WebSocketFlowControlParams deserialize(bindings.Message message) {
+    var decoder = new bindings.Decoder(message);
+    var result = decode(decoder);
+    if (decoder.excessHandles != null) {
+      decoder.excessHandles.forEach((h) => h.close());
+    }
+    return result;
+  }
+
+  static WebSocketFlowControlParams decode(bindings.Decoder decoder0) {
+    if (decoder0 == null) {
+      return null;
+    }
+    WebSocketFlowControlParams result = new WebSocketFlowControlParams();
+
+    var mainDataHeader = decoder0.decodeStructDataHeader();
+    if (mainDataHeader.version <= kVersions.last.version) {
+      // Scan in reverse order to optimize for more recent versions.
+      for (int i = kVersions.length - 1; i >= 0; --i) {
+        if (mainDataHeader.version >= kVersions[i].version) {
+          if (mainDataHeader.size == kVersions[i].size) {
+            // Found a match.
+            break;
+          }
+          throw new bindings.MojoCodecError(
+              'Header size doesn\'t correspond to known version size.');
+        }
+      }
+    } else if (mainDataHeader.size < kVersions.last.size) {
+      throw new bindings.MojoCodecError(
+        'Message newer than the last known version cannot be shorter than '
+        'required by the last known version.');
+    }
+    if (mainDataHeader.version >= 0) {
+      
+      result.quota = decoder0.decodeInt64(8);
+    }
+    return result;
+  }
+
+  void encode(bindings.Encoder encoder) {
+    var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
+    
+    encoder0.encodeInt64(quota, 8);
+  }
+
+  String toString() {
+    return "WebSocketFlowControlParams("
+           "quota: $quota" ")";
+  }
+
+  Map toJson() {
+    Map map = new Map();
+    map["quota"] = quota;
+    return map;
+  }
+}
+
+
+class WebSocketCloseParams extends bindings.Struct {
+  static const List<bindings.StructDataHeader> kVersions = const [
+    const bindings.StructDataHeader(24, 0)
+  ];
+  int code = 0;
+  String reason = null;
+
+  WebSocketCloseParams() : super(kVersions.last.size);
+
+  static WebSocketCloseParams deserialize(bindings.Message message) {
+    var decoder = new bindings.Decoder(message);
+    var result = decode(decoder);
+    if (decoder.excessHandles != null) {
+      decoder.excessHandles.forEach((h) => h.close());
+    }
+    return result;
+  }
+
+  static WebSocketCloseParams decode(bindings.Decoder decoder0) {
+    if (decoder0 == null) {
+      return null;
+    }
+    WebSocketCloseParams result = new WebSocketCloseParams();
+
+    var mainDataHeader = decoder0.decodeStructDataHeader();
+    if (mainDataHeader.version <= kVersions.last.version) {
+      // Scan in reverse order to optimize for more recent versions.
+      for (int i = kVersions.length - 1; i >= 0; --i) {
+        if (mainDataHeader.version >= kVersions[i].version) {
+          if (mainDataHeader.size == kVersions[i].size) {
+            // Found a match.
+            break;
+          }
+          throw new bindings.MojoCodecError(
+              'Header size doesn\'t correspond to known version size.');
+        }
+      }
+    } else if (mainDataHeader.size < kVersions.last.size) {
+      throw new bindings.MojoCodecError(
+        'Message newer than the last known version cannot be shorter than '
+        'required by the last known version.');
+    }
+    if (mainDataHeader.version >= 0) {
+      
+      result.code = decoder0.decodeUint16(8);
+    }
+    if (mainDataHeader.version >= 0) {
+      
+      result.reason = decoder0.decodeString(16, false);
+    }
+    return result;
+  }
+
+  void encode(bindings.Encoder encoder) {
+    var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
+    
+    encoder0.encodeUint16(code, 8);
+    
+    encoder0.encodeString(reason, 16, false);
+  }
+
+  String toString() {
+    return "WebSocketCloseParams("
+           "code: $code" ", "
+           "reason: $reason" ")";
+  }
+
+  Map toJson() {
+    Map map = new Map();
+    map["code"] = code;
+    map["reason"] = reason;
+    return map;
+  }
+}
+
+
+class WebSocketClientDidConnectParams extends bindings.Struct {
+  static const List<bindings.StructDataHeader> kVersions = const [
+    const bindings.StructDataHeader(32, 0)
+  ];
+  String selectedSubprotocol = null;
+  String extensions = null;
+  core.MojoDataPipeConsumer receiveStream = null;
+
+  WebSocketClientDidConnectParams() : super(kVersions.last.size);
+
+  static WebSocketClientDidConnectParams deserialize(bindings.Message message) {
+    var decoder = new bindings.Decoder(message);
+    var result = decode(decoder);
+    if (decoder.excessHandles != null) {
+      decoder.excessHandles.forEach((h) => h.close());
+    }
+    return result;
+  }
+
+  static WebSocketClientDidConnectParams decode(bindings.Decoder decoder0) {
+    if (decoder0 == null) {
+      return null;
+    }
+    WebSocketClientDidConnectParams result = new WebSocketClientDidConnectParams();
+
+    var mainDataHeader = decoder0.decodeStructDataHeader();
+    if (mainDataHeader.version <= kVersions.last.version) {
+      // Scan in reverse order to optimize for more recent versions.
+      for (int i = kVersions.length - 1; i >= 0; --i) {
+        if (mainDataHeader.version >= kVersions[i].version) {
+          if (mainDataHeader.size == kVersions[i].size) {
+            // Found a match.
+            break;
+          }
+          throw new bindings.MojoCodecError(
+              'Header size doesn\'t correspond to known version size.');
+        }
+      }
+    } else if (mainDataHeader.size < kVersions.last.size) {
+      throw new bindings.MojoCodecError(
+        'Message newer than the last known version cannot be shorter than '
+        'required by the last known version.');
+    }
+    if (mainDataHeader.version >= 0) {
+      
+      result.selectedSubprotocol = decoder0.decodeString(8, false);
+    }
+    if (mainDataHeader.version >= 0) {
+      
+      result.extensions = decoder0.decodeString(16, false);
+    }
+    if (mainDataHeader.version >= 0) {
+      
+      result.receiveStream = decoder0.decodeConsumerHandle(24, false);
+    }
+    return result;
+  }
+
+  void encode(bindings.Encoder encoder) {
+    var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
+    
+    encoder0.encodeString(selectedSubprotocol, 8, false);
+    
+    encoder0.encodeString(extensions, 16, false);
+    
+    encoder0.encodeConsumerHandle(receiveStream, 24, false);
+  }
+
+  String toString() {
+    return "WebSocketClientDidConnectParams("
+           "selectedSubprotocol: $selectedSubprotocol" ", "
+           "extensions: $extensions" ", "
+           "receiveStream: $receiveStream" ")";
+  }
+
+  Map toJson() {
+    throw new bindings.MojoCodecError(
+        'Object containing handles cannot be encoded to JSON.');
+  }
+}
+
+
+class WebSocketClientDidReceiveDataParams extends bindings.Struct {
+  static const List<bindings.StructDataHeader> kVersions = const [
+    const bindings.StructDataHeader(24, 0)
+  ];
+  bool fin = false;
+  WebSocketMessageType type = null;
+  int numBytes = 0;
+
+  WebSocketClientDidReceiveDataParams() : super(kVersions.last.size);
+
+  static WebSocketClientDidReceiveDataParams deserialize(bindings.Message message) {
+    var decoder = new bindings.Decoder(message);
+    var result = decode(decoder);
+    if (decoder.excessHandles != null) {
+      decoder.excessHandles.forEach((h) => h.close());
+    }
+    return result;
+  }
+
+  static WebSocketClientDidReceiveDataParams decode(bindings.Decoder decoder0) {
+    if (decoder0 == null) {
+      return null;
+    }
+    WebSocketClientDidReceiveDataParams result = new WebSocketClientDidReceiveDataParams();
+
+    var mainDataHeader = decoder0.decodeStructDataHeader();
+    if (mainDataHeader.version <= kVersions.last.version) {
+      // Scan in reverse order to optimize for more recent versions.
+      for (int i = kVersions.length - 1; i >= 0; --i) {
+        if (mainDataHeader.version >= kVersions[i].version) {
+          if (mainDataHeader.size == kVersions[i].size) {
+            // Found a match.
+            break;
+          }
+          throw new bindings.MojoCodecError(
+              'Header size doesn\'t correspond to known version size.');
+        }
+      }
+    } else if (mainDataHeader.size < kVersions.last.size) {
+      throw new bindings.MojoCodecError(
+        'Message newer than the last known version cannot be shorter than '
+        'required by the last known version.');
+    }
+    if (mainDataHeader.version >= 0) {
+      
+      result.fin = decoder0.decodeBool(8, 0);
+    }
+    if (mainDataHeader.version >= 0) {
+      
+        result.type = WebSocketMessageType.decode(decoder0, 12);
+        if (result.type == null) {
+          throw new bindings.MojoCodecError(
+            'Trying to decode null union for non-nullable WebSocketMessageType.');
+        }
+    }
+    if (mainDataHeader.version >= 0) {
+      
+      result.numBytes = decoder0.decodeUint32(16);
+    }
+    return result;
+  }
+
+  void encode(bindings.Encoder encoder) {
+    var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
+    
+    encoder0.encodeBool(fin, 8, 0);
+    
+    encoder0.encodeEnum(type, 12);
+    
+    encoder0.encodeUint32(numBytes, 16);
+  }
+
+  String toString() {
+    return "WebSocketClientDidReceiveDataParams("
+           "fin: $fin" ", "
+           "type: $type" ", "
+           "numBytes: $numBytes" ")";
+  }
+
+  Map toJson() {
+    Map map = new Map();
+    map["fin"] = fin;
+    map["type"] = type;
+    map["numBytes"] = numBytes;
+    return map;
+  }
+}
+
+
+class WebSocketClientDidReceiveFlowControlParams extends bindings.Struct {
+  static const List<bindings.StructDataHeader> kVersions = const [
+    const bindings.StructDataHeader(16, 0)
+  ];
+  int quota = 0;
+
+  WebSocketClientDidReceiveFlowControlParams() : super(kVersions.last.size);
+
+  static WebSocketClientDidReceiveFlowControlParams deserialize(bindings.Message message) {
+    var decoder = new bindings.Decoder(message);
+    var result = decode(decoder);
+    if (decoder.excessHandles != null) {
+      decoder.excessHandles.forEach((h) => h.close());
+    }
+    return result;
+  }
+
+  static WebSocketClientDidReceiveFlowControlParams decode(bindings.Decoder decoder0) {
+    if (decoder0 == null) {
+      return null;
+    }
+    WebSocketClientDidReceiveFlowControlParams result = new WebSocketClientDidReceiveFlowControlParams();
+
+    var mainDataHeader = decoder0.decodeStructDataHeader();
+    if (mainDataHeader.version <= kVersions.last.version) {
+      // Scan in reverse order to optimize for more recent versions.
+      for (int i = kVersions.length - 1; i >= 0; --i) {
+        if (mainDataHeader.version >= kVersions[i].version) {
+          if (mainDataHeader.size == kVersions[i].size) {
+            // Found a match.
+            break;
+          }
+          throw new bindings.MojoCodecError(
+              'Header size doesn\'t correspond to known version size.');
+        }
+      }
+    } else if (mainDataHeader.size < kVersions.last.size) {
+      throw new bindings.MojoCodecError(
+        'Message newer than the last known version cannot be shorter than '
+        'required by the last known version.');
+    }
+    if (mainDataHeader.version >= 0) {
+      
+      result.quota = decoder0.decodeInt64(8);
+    }
+    return result;
+  }
+
+  void encode(bindings.Encoder encoder) {
+    var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
+    
+    encoder0.encodeInt64(quota, 8);
+  }
+
+  String toString() {
+    return "WebSocketClientDidReceiveFlowControlParams("
+           "quota: $quota" ")";
+  }
+
+  Map toJson() {
+    Map map = new Map();
+    map["quota"] = quota;
+    return map;
+  }
+}
+
+
+class WebSocketClientDidFailParams extends bindings.Struct {
+  static const List<bindings.StructDataHeader> kVersions = const [
+    const bindings.StructDataHeader(16, 0)
+  ];
+  String message = null;
+
+  WebSocketClientDidFailParams() : super(kVersions.last.size);
+
+  static WebSocketClientDidFailParams deserialize(bindings.Message message) {
+    var decoder = new bindings.Decoder(message);
+    var result = decode(decoder);
+    if (decoder.excessHandles != null) {
+      decoder.excessHandles.forEach((h) => h.close());
+    }
+    return result;
+  }
+
+  static WebSocketClientDidFailParams decode(bindings.Decoder decoder0) {
+    if (decoder0 == null) {
+      return null;
+    }
+    WebSocketClientDidFailParams result = new WebSocketClientDidFailParams();
+
+    var mainDataHeader = decoder0.decodeStructDataHeader();
+    if (mainDataHeader.version <= kVersions.last.version) {
+      // Scan in reverse order to optimize for more recent versions.
+      for (int i = kVersions.length - 1; i >= 0; --i) {
+        if (mainDataHeader.version >= kVersions[i].version) {
+          if (mainDataHeader.size == kVersions[i].size) {
+            // Found a match.
+            break;
+          }
+          throw new bindings.MojoCodecError(
+              'Header size doesn\'t correspond to known version size.');
+        }
+      }
+    } else if (mainDataHeader.size < kVersions.last.size) {
+      throw new bindings.MojoCodecError(
+        'Message newer than the last known version cannot be shorter than '
+        'required by the last known version.');
+    }
+    if (mainDataHeader.version >= 0) {
+      
+      result.message = decoder0.decodeString(8, false);
+    }
+    return result;
+  }
+
+  void encode(bindings.Encoder encoder) {
+    var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
+    
+    encoder0.encodeString(message, 8, false);
+  }
+
+  String toString() {
+    return "WebSocketClientDidFailParams("
+           "message: $message" ")";
+  }
+
+  Map toJson() {
+    Map map = new Map();
+    map["message"] = message;
+    return map;
+  }
+}
+
+
+class WebSocketClientDidCloseParams extends bindings.Struct {
+  static const List<bindings.StructDataHeader> kVersions = const [
+    const bindings.StructDataHeader(24, 0)
+  ];
+  bool wasClean = false;
+  int code = 0;
+  String reason = null;
+
+  WebSocketClientDidCloseParams() : super(kVersions.last.size);
+
+  static WebSocketClientDidCloseParams deserialize(bindings.Message message) {
+    var decoder = new bindings.Decoder(message);
+    var result = decode(decoder);
+    if (decoder.excessHandles != null) {
+      decoder.excessHandles.forEach((h) => h.close());
+    }
+    return result;
+  }
+
+  static WebSocketClientDidCloseParams decode(bindings.Decoder decoder0) {
+    if (decoder0 == null) {
+      return null;
+    }
+    WebSocketClientDidCloseParams result = new WebSocketClientDidCloseParams();
+
+    var mainDataHeader = decoder0.decodeStructDataHeader();
+    if (mainDataHeader.version <= kVersions.last.version) {
+      // Scan in reverse order to optimize for more recent versions.
+      for (int i = kVersions.length - 1; i >= 0; --i) {
+        if (mainDataHeader.version >= kVersions[i].version) {
+          if (mainDataHeader.size == kVersions[i].size) {
+            // Found a match.
+            break;
+          }
+          throw new bindings.MojoCodecError(
+              'Header size doesn\'t correspond to known version size.');
+        }
+      }
+    } else if (mainDataHeader.size < kVersions.last.size) {
+      throw new bindings.MojoCodecError(
+        'Message newer than the last known version cannot be shorter than '
+        'required by the last known version.');
+    }
+    if (mainDataHeader.version >= 0) {
+      
+      result.wasClean = decoder0.decodeBool(8, 0);
+    }
+    if (mainDataHeader.version >= 0) {
+      
+      result.code = decoder0.decodeUint16(10);
+    }
+    if (mainDataHeader.version >= 0) {
+      
+      result.reason = decoder0.decodeString(16, false);
+    }
+    return result;
+  }
+
+  void encode(bindings.Encoder encoder) {
+    var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
+    
+    encoder0.encodeBool(wasClean, 8, 0);
+    
+    encoder0.encodeUint16(code, 10);
+    
+    encoder0.encodeString(reason, 16, false);
+  }
+
+  String toString() {
+    return "WebSocketClientDidCloseParams("
+           "wasClean: $wasClean" ", "
+           "code: $code" ", "
+           "reason: $reason" ")";
+  }
+
+  Map toJson() {
+    Map map = new Map();
+    map["wasClean"] = wasClean;
+    map["code"] = code;
+    map["reason"] = reason;
+    return map;
+  }
+}
+
+const int kWebSocket_connect_name = 0;
+const int kWebSocket_send_name = 1;
+const int kWebSocket_flowControl_name = 2;
+const int kWebSocket_close_name = 3;
+
+const String WebSocketName =
+      'mojo::WebSocket';
+  class WebSocketMessageType extends bindings.MojoEnum {
+  static const CONTINUATION = const WebSocketMessageType._(0);
+  static const TEXT = const WebSocketMessageType._(1);
+  static const BINARY = const WebSocketMessageType._(2);
+
+  const WebSocketMessageType._(int v) : super(v);
+
+  static const Map<String, WebSocketMessageType> valuesMap = const {
+    "CONTINUATION": CONTINUATION,
+    "TEXT": TEXT,
+    "BINARY": BINARY,
+  };
+  static const List<WebSocketMessageType> values = const [
+    CONTINUATION,
+    TEXT,
+    BINARY,
+  ];
+
+  static WebSocketMessageType valueOf(String name) => valuesMap[name];
+
+  factory WebSocketMessageType(int v) {
+    switch (v) {
+      case 0:
+        return CONTINUATION;
+      case 1:
+        return TEXT;
+      case 2:
+        return BINARY;
+      default:
+        return null;
+    }
+  }
+
+  static WebSocketMessageType decode(bindings.Decoder decoder0, int offset) {
+    int v = decoder0.decodeUint32(offset);
+    WebSocketMessageType result = new WebSocketMessageType(v);
+    if (result == null) {
+      throw new bindings.MojoCodecError(
+          'Bad value $v for enum WebSocketMessageType.');
+    }
+    return result;
+  }
+
+  String toString() {
+    switch(this) {
+      case CONTINUATION:
+        return 'WebSocketMessageType.CONTINUATION';
+      case TEXT:
+        return 'WebSocketMessageType.TEXT';
+      case BINARY:
+        return 'WebSocketMessageType.BINARY';
+    }
+  }
+
+  int toJson() => value;
+}
+
+abstract class WebSocket {
+  void connect(String url, List<String> protocols, String origin, core.MojoDataPipeConsumer sendStream, Object client);
+  void send(bool fin, WebSocketMessageType type, int numBytes);
+  void flowControl(int quota);
+  void close(int code, String reason);
+
+  static const ABNORMAL_CLOSE_CODE = 1006;
+}
+
+
+class WebSocketProxyImpl extends bindings.Proxy {
+  WebSocketProxyImpl.fromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint) : super.fromEndpoint(endpoint);
+
+  WebSocketProxyImpl.fromHandle(core.MojoHandle handle) :
+      super.fromHandle(handle);
+
+  WebSocketProxyImpl.unbound() : super.unbound();
+
+  static WebSocketProxyImpl newFromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint) {
+    assert(endpoint.setDescription("For WebSocketProxyImpl"));
+    return new WebSocketProxyImpl.fromEndpoint(endpoint);
+  }
+
+  String get name => WebSocketName;
+
+  void handleResponse(bindings.ServiceMessage message) {
+    switch (message.header.type) {
+      default:
+        proxyError("Unexpected message type: ${message.header.type}");
+        close(immediate: true);
+        break;
+    }
+  }
+
+  String toString() {
+    var superString = super.toString();
+    return "WebSocketProxyImpl($superString)";
+  }
+}
+
+
+class _WebSocketProxyCalls implements WebSocket {
+  WebSocketProxyImpl _proxyImpl;
+
+  _WebSocketProxyCalls(this._proxyImpl);
+    void connect(String url, List<String> protocols, String origin, core.MojoDataPipeConsumer sendStream, Object client) {
+      if (!_proxyImpl.isBound) {
+        _proxyImpl.proxyError("The Proxy is closed.");
+        return;
+      }
+      var params = new WebSocketConnectParams();
+      params.url = url;
+      params.protocols = protocols;
+      params.origin = origin;
+      params.sendStream = sendStream;
+      params.client = client;
+      _proxyImpl.sendMessage(params, kWebSocket_connect_name);
+    }
+  
+    void send(bool fin, WebSocketMessageType type, int numBytes) {
+      if (!_proxyImpl.isBound) {
+        _proxyImpl.proxyError("The Proxy is closed.");
+        return;
+      }
+      var params = new WebSocketSendParams();
+      params.fin = fin;
+      params.type = type;
+      params.numBytes = numBytes;
+      _proxyImpl.sendMessage(params, kWebSocket_send_name);
+    }
+  
+    void flowControl(int quota) {
+      if (!_proxyImpl.isBound) {
+        _proxyImpl.proxyError("The Proxy is closed.");
+        return;
+      }
+      var params = new WebSocketFlowControlParams();
+      params.quota = quota;
+      _proxyImpl.sendMessage(params, kWebSocket_flowControl_name);
+    }
+  
+    void close(int code, String reason) {
+      if (!_proxyImpl.isBound) {
+        _proxyImpl.proxyError("The Proxy is closed.");
+        return;
+      }
+      var params = new WebSocketCloseParams();
+      params.code = code;
+      params.reason = reason;
+      _proxyImpl.sendMessage(params, kWebSocket_close_name);
+    }
+  
+}
+
+
+class WebSocketProxy implements bindings.ProxyBase {
+  final bindings.Proxy impl;
+  WebSocket ptr;
+  final String name = WebSocketName;
+
+  WebSocketProxy(WebSocketProxyImpl proxyImpl) :
+      impl = proxyImpl,
+      ptr = new _WebSocketProxyCalls(proxyImpl);
+
+  WebSocketProxy.fromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint) :
+      impl = new WebSocketProxyImpl.fromEndpoint(endpoint) {
+    ptr = new _WebSocketProxyCalls(impl);
+  }
+
+  WebSocketProxy.fromHandle(core.MojoHandle handle) :
+      impl = new WebSocketProxyImpl.fromHandle(handle) {
+    ptr = new _WebSocketProxyCalls(impl);
+  }
+
+  WebSocketProxy.unbound() :
+      impl = new WebSocketProxyImpl.unbound() {
+    ptr = new _WebSocketProxyCalls(impl);
+  }
+
+  factory WebSocketProxy.connectToService(
+      bindings.ServiceConnector s, String url) {
+    WebSocketProxy p = new WebSocketProxy.unbound();
+    s.connectToService(url, p);
+    return p;
+  }
+
+  static WebSocketProxy newFromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint) {
+    assert(endpoint.setDescription("For WebSocketProxy"));
+    return new WebSocketProxy.fromEndpoint(endpoint);
+  }
+
+  Future close({bool immediate: false}) => impl.close(immediate: immediate);
+
+  Future responseOrError(Future f) => impl.responseOrError(f);
+
+  Future get errorFuture => impl.errorFuture;
+
+  int get version => impl.version;
+
+  Future<int> queryVersion() => impl.queryVersion();
+
+  void requireVersion(int requiredVersion) {
+    impl.requireVersion(requiredVersion);
+  }
+
+  String toString() {
+    return "WebSocketProxy($impl)";
+  }
+}
+
+
+class WebSocketStub extends bindings.Stub {
+  WebSocket _impl = null;
+
+  WebSocketStub.fromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint, [this._impl])
+      : super.fromEndpoint(endpoint);
+
+  WebSocketStub.fromHandle(core.MojoHandle handle, [this._impl])
+      : super.fromHandle(handle);
+
+  WebSocketStub.unbound() : super.unbound();
+
+  static WebSocketStub newFromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint) {
+    assert(endpoint.setDescription("For WebSocketStub"));
+    return new WebSocketStub.fromEndpoint(endpoint);
+  }
+
+  static const String name = WebSocketName;
+
+
+
+  dynamic handleMessage(bindings.ServiceMessage message) {
+    if (bindings.ControlMessageHandler.isControlMessage(message)) {
+      return bindings.ControlMessageHandler.handleMessage(this,
+                                                          0,
+                                                          message);
+    }
+    assert(_impl != null);
+    switch (message.header.type) {
+      case kWebSocket_connect_name:
+        var params = WebSocketConnectParams.deserialize(
+            message.payload);
+        _impl.connect(params.url, params.protocols, params.origin, params.sendStream, params.client);
+        break;
+      case kWebSocket_send_name:
+        var params = WebSocketSendParams.deserialize(
+            message.payload);
+        _impl.send(params.fin, params.type, params.numBytes);
+        break;
+      case kWebSocket_flowControl_name:
+        var params = WebSocketFlowControlParams.deserialize(
+            message.payload);
+        _impl.flowControl(params.quota);
+        break;
+      case kWebSocket_close_name:
+        var params = WebSocketCloseParams.deserialize(
+            message.payload);
+        _impl.close(params.code, params.reason);
+        break;
+      default:
+        throw new bindings.MojoCodecError("Unexpected message name");
+        break;
+    }
+    return null;
+  }
+
+  WebSocket get impl => _impl;
+  set impl(WebSocket d) {
+    assert(_impl == null);
+    _impl = d;
+  }
+
+  String toString() {
+    var superString = super.toString();
+    return "WebSocketStub($superString)";
+  }
+
+  int get version => 0;
+}
+
+const int kWebSocketClient_didConnect_name = 0;
+const int kWebSocketClient_didReceiveData_name = 1;
+const int kWebSocketClient_didReceiveFlowControl_name = 2;
+const int kWebSocketClient_didFail_name = 3;
+const int kWebSocketClient_didClose_name = 4;
+
+const String WebSocketClientName =
+      'mojo::WebSocketClient';
+
+abstract class WebSocketClient {
+  void didConnect(String selectedSubprotocol, String extensions, core.MojoDataPipeConsumer receiveStream);
+  void didReceiveData(bool fin, WebSocketMessageType type, int numBytes);
+  void didReceiveFlowControl(int quota);
+  void didFail(String message);
+  void didClose(bool wasClean, int code, String reason);
+
+}
+
+
+class WebSocketClientProxyImpl extends bindings.Proxy {
+  WebSocketClientProxyImpl.fromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint) : super.fromEndpoint(endpoint);
+
+  WebSocketClientProxyImpl.fromHandle(core.MojoHandle handle) :
+      super.fromHandle(handle);
+
+  WebSocketClientProxyImpl.unbound() : super.unbound();
+
+  static WebSocketClientProxyImpl newFromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint) {
+    assert(endpoint.setDescription("For WebSocketClientProxyImpl"));
+    return new WebSocketClientProxyImpl.fromEndpoint(endpoint);
+  }
+
+  String get name => WebSocketClientName;
+
+  void handleResponse(bindings.ServiceMessage message) {
+    switch (message.header.type) {
+      default:
+        proxyError("Unexpected message type: ${message.header.type}");
+        close(immediate: true);
+        break;
+    }
+  }
+
+  String toString() {
+    var superString = super.toString();
+    return "WebSocketClientProxyImpl($superString)";
+  }
+}
+
+
+class _WebSocketClientProxyCalls implements WebSocketClient {
+  WebSocketClientProxyImpl _proxyImpl;
+
+  _WebSocketClientProxyCalls(this._proxyImpl);
+    void didConnect(String selectedSubprotocol, String extensions, core.MojoDataPipeConsumer receiveStream) {
+      if (!_proxyImpl.isBound) {
+        _proxyImpl.proxyError("The Proxy is closed.");
+        return;
+      }
+      var params = new WebSocketClientDidConnectParams();
+      params.selectedSubprotocol = selectedSubprotocol;
+      params.extensions = extensions;
+      params.receiveStream = receiveStream;
+      _proxyImpl.sendMessage(params, kWebSocketClient_didConnect_name);
+    }
+  
+    void didReceiveData(bool fin, WebSocketMessageType type, int numBytes) {
+      if (!_proxyImpl.isBound) {
+        _proxyImpl.proxyError("The Proxy is closed.");
+        return;
+      }
+      var params = new WebSocketClientDidReceiveDataParams();
+      params.fin = fin;
+      params.type = type;
+      params.numBytes = numBytes;
+      _proxyImpl.sendMessage(params, kWebSocketClient_didReceiveData_name);
+    }
+  
+    void didReceiveFlowControl(int quota) {
+      if (!_proxyImpl.isBound) {
+        _proxyImpl.proxyError("The Proxy is closed.");
+        return;
+      }
+      var params = new WebSocketClientDidReceiveFlowControlParams();
+      params.quota = quota;
+      _proxyImpl.sendMessage(params, kWebSocketClient_didReceiveFlowControl_name);
+    }
+  
+    void didFail(String message) {
+      if (!_proxyImpl.isBound) {
+        _proxyImpl.proxyError("The Proxy is closed.");
+        return;
+      }
+      var params = new WebSocketClientDidFailParams();
+      params.message = message;
+      _proxyImpl.sendMessage(params, kWebSocketClient_didFail_name);
+    }
+  
+    void didClose(bool wasClean, int code, String reason) {
+      if (!_proxyImpl.isBound) {
+        _proxyImpl.proxyError("The Proxy is closed.");
+        return;
+      }
+      var params = new WebSocketClientDidCloseParams();
+      params.wasClean = wasClean;
+      params.code = code;
+      params.reason = reason;
+      _proxyImpl.sendMessage(params, kWebSocketClient_didClose_name);
+    }
+  
+}
+
+
+class WebSocketClientProxy implements bindings.ProxyBase {
+  final bindings.Proxy impl;
+  WebSocketClient ptr;
+  final String name = WebSocketClientName;
+
+  WebSocketClientProxy(WebSocketClientProxyImpl proxyImpl) :
+      impl = proxyImpl,
+      ptr = new _WebSocketClientProxyCalls(proxyImpl);
+
+  WebSocketClientProxy.fromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint) :
+      impl = new WebSocketClientProxyImpl.fromEndpoint(endpoint) {
+    ptr = new _WebSocketClientProxyCalls(impl);
+  }
+
+  WebSocketClientProxy.fromHandle(core.MojoHandle handle) :
+      impl = new WebSocketClientProxyImpl.fromHandle(handle) {
+    ptr = new _WebSocketClientProxyCalls(impl);
+  }
+
+  WebSocketClientProxy.unbound() :
+      impl = new WebSocketClientProxyImpl.unbound() {
+    ptr = new _WebSocketClientProxyCalls(impl);
+  }
+
+  factory WebSocketClientProxy.connectToService(
+      bindings.ServiceConnector s, String url) {
+    WebSocketClientProxy p = new WebSocketClientProxy.unbound();
+    s.connectToService(url, p);
+    return p;
+  }
+
+  static WebSocketClientProxy newFromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint) {
+    assert(endpoint.setDescription("For WebSocketClientProxy"));
+    return new WebSocketClientProxy.fromEndpoint(endpoint);
+  }
+
+  Future close({bool immediate: false}) => impl.close(immediate: immediate);
+
+  Future responseOrError(Future f) => impl.responseOrError(f);
+
+  Future get errorFuture => impl.errorFuture;
+
+  int get version => impl.version;
+
+  Future<int> queryVersion() => impl.queryVersion();
+
+  void requireVersion(int requiredVersion) {
+    impl.requireVersion(requiredVersion);
+  }
+
+  String toString() {
+    return "WebSocketClientProxy($impl)";
+  }
+}
+
+
+class WebSocketClientStub extends bindings.Stub {
+  WebSocketClient _impl = null;
+
+  WebSocketClientStub.fromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint, [this._impl])
+      : super.fromEndpoint(endpoint);
+
+  WebSocketClientStub.fromHandle(core.MojoHandle handle, [this._impl])
+      : super.fromHandle(handle);
+
+  WebSocketClientStub.unbound() : super.unbound();
+
+  static WebSocketClientStub newFromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint) {
+    assert(endpoint.setDescription("For WebSocketClientStub"));
+    return new WebSocketClientStub.fromEndpoint(endpoint);
+  }
+
+  static const String name = WebSocketClientName;
+
+
+
+  dynamic handleMessage(bindings.ServiceMessage message) {
+    if (bindings.ControlMessageHandler.isControlMessage(message)) {
+      return bindings.ControlMessageHandler.handleMessage(this,
+                                                          0,
+                                                          message);
+    }
+    assert(_impl != null);
+    switch (message.header.type) {
+      case kWebSocketClient_didConnect_name:
+        var params = WebSocketClientDidConnectParams.deserialize(
+            message.payload);
+        _impl.didConnect(params.selectedSubprotocol, params.extensions, params.receiveStream);
+        break;
+      case kWebSocketClient_didReceiveData_name:
+        var params = WebSocketClientDidReceiveDataParams.deserialize(
+            message.payload);
+        _impl.didReceiveData(params.fin, params.type, params.numBytes);
+        break;
+      case kWebSocketClient_didReceiveFlowControl_name:
+        var params = WebSocketClientDidReceiveFlowControlParams.deserialize(
+            message.payload);
+        _impl.didReceiveFlowControl(params.quota);
+        break;
+      case kWebSocketClient_didFail_name:
+        var params = WebSocketClientDidFailParams.deserialize(
+            message.payload);
+        _impl.didFail(params.message);
+        break;
+      case kWebSocketClient_didClose_name:
+        var params = WebSocketClientDidCloseParams.deserialize(
+            message.payload);
+        _impl.didClose(params.wasClean, params.code, params.reason);
+        break;
+      default:
+        throw new bindings.MojoCodecError("Unexpected message name");
+        break;
+    }
+    return null;
+  }
+
+  WebSocketClient get impl => _impl;
+  set impl(WebSocketClient d) {
+    assert(_impl == null);
+    _impl = d;
+  }
+
+  String toString() {
+    var superString = super.toString();
+    return "WebSocketClientStub($superString)";
+  }
+
+  int get version => 0;
+}
+
+