Migrate dart2js stubs for dart:io

tool/input_sdk/patch/io_patch.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.
 
 import 'dart:_js_helper' show patch;
 
 @patch
 class _Directory {
   @patch
   static _current() {
@@ skipping 21 matching lines @@
   }
   @patch
   static _deleteNative(String path, bool recursive) {
     throw new UnsupportedError("Directory._deleteNative");
   }
   @patch
   static _rename(String path, String newPath) {
     throw new UnsupportedError("Directory._rename");
   }
   @patch
-  static List _list(String path, bool recursive, bool followLinks) {
+  static void _fillWithDirectoryListing(
+      List<FileSystemEntity> list, String path, bool recursive,
+      bool followLinks) {
+    throw new UnsupportedError("Directory._fillWithDirectoryListing");
+  }
+}
+
+@patch
+class _AsyncDirectoryListerOps {
+  @patch
+  factory _AsyncDirectoryListerOps(int pointer) {
     throw new UnsupportedError("Directory._list");
   }
 }
 
 @patch
 class _EventHandler {
   @patch
   static void _sendData(Object sender,
                         SendPort sendPort,
                         int data) {
@@ skipping 75 matching lines @@
   static _open(String path, int mode) {
     throw new UnsupportedError("File._open");
   }
   @patch
   static int _openStdio(int fd) {
     throw new UnsupportedError("File._openStdio");
   }
 }
 
 @patch
-class _RandomAccessFile {
+class _RandomAccessFileOps {
   @patch
-  static int _close(int id) {
-    throw new UnsupportedError("RandomAccessFile._close");
-  }
-  @patch
-  static int _getFD(int id) {
-    throw new UnsupportedError("RandomAccessFile._getFD");
-  }
-  @patch
-  static _readByte(int id) {
-    throw new UnsupportedError("RandomAccessFile._readByte");
-  }
-  @patch
-  static _read(int id, int bytes) {
-    throw new UnsupportedError("RandomAccessFile._read");
-  }
-  @patch
-  static _readInto(int id, List<int> buffer, int start, int end) {
-    throw new UnsupportedError("RandomAccessFile._readInto");
-  }
-  @patch
-  static _writeByte(int id, int value) {
-    throw new UnsupportedError("RandomAccessFile._writeByte");
-  }
-  @patch
-  static _writeFrom(int id, List<int> buffer, int start, int end) {
-    throw new UnsupportedError("RandomAccessFile._writeFrom");
-  }
-  @patch
-  static _position(int id) {
-    throw new UnsupportedError("RandomAccessFile._position");
-  }
-  @patch
-  static _setPosition(int id, int position) {
-    throw new UnsupportedError("RandomAccessFile._setPosition");
-  }
-  @patch
-  static _truncate(int id, int length) {
-    throw new UnsupportedError("RandomAccessFile._truncate");
-  }
-  @patch
-  static _length(int id) {
-    throw new UnsupportedError("RandomAccessFile._length");
-  }
-  @patch
-  static _flush(int id) {
-    throw new UnsupportedError("RandomAccessFile._flush");
-  }
-  @patch
-  static _lock(int id, int lock, int start, int end) {
-    throw new UnsupportedError("RandomAccessFile._lock");
+  factory _RandomAccessFileOps(int pointer) {
+    throw new UnsupportedError("RandomAccessFile");
   }
 }
 
 @patch
 class _IOCrypto {
   @patch
   static Uint8List getRandomBytes(int count) {
     throw new UnsupportedError("_IOCrypto.getRandomBytes");
   }
 }
@@ skipping 14 matching lines @@
   }
   @patch
   static _localHostname() {
     throw new UnsupportedError("Platform._localHostname");
   }
   @patch
   static _executable() {
     throw new UnsupportedError("Platform._executable");
   }
   @patch
+  static _resolvedExecutable() {
+    throw new UnsupportedError("Platform._resolvedExecutable");
+  }
+  @patch
   static List<String> _executableArguments() {
     throw new UnsupportedError("Platform._executableArguments");
   }
   @patch
   static String _packageRoot() {
     throw new UnsupportedError("Platform._packageRoot");
   }
   @patch
+  static String _packageConfig() {
+    throw new UnsupportedError("Platform._packageConfig");
+  }
+  @patch
   static _environment() {
     throw new UnsupportedError("Platform._environment");
   }
   @patch
   static String _version() {
     throw new UnsupportedError("Platform._version");
   }
 }
 
 @patch
@@ skipping 26 matching lines @@
 
 @patch
 class Process {
   @patch
   static Future<Process> start(
       String executable,
       List<String> arguments,
       {String workingDirectory,
        Map<String, String> environment,
        bool includeParentEnvironment: true,
-       bool runInShell: false}) {
+       bool runInShell: false,
+       ProcessStartMode mode: ProcessStartMode.NORMAL}) {
     throw new UnsupportedError("Process.start");
   }
 
   @patch
   static Future<ProcessResult> run(
       String executable,
       List<String> arguments,
       {String workingDirectory,
        Map<String, String> environment,
        bool includeParentEnvironment: true,
        bool runInShell: false,
        Encoding stdoutEncoding: SYSTEM_ENCODING,
        Encoding stderrEncoding: SYSTEM_ENCODING}) {
     throw new UnsupportedError("Process.run");
   }
 
   @patch
   static ProcessResult runSync(
       String executable,
       List<String> arguments,
       {String workingDirectory,
        Map<String, String> environment,
        bool includeParentEnvironment: true,
        bool runInShell: false,
        Encoding stdoutEncoding: SYSTEM_ENCODING,
        Encoding stderrEncoding: SYSTEM_ENCODING}) {
     throw new UnsupportedError("Process.runSync");
   }
+
+  @patch
+  static bool killPid(
+      int pid, [ProcessSignal signal = ProcessSignal.SIGTERM]) {
+    throw new UnsupportedError("Process.killPid");
+  }
 }
 
 @patch
 class InternetAddress {
   @patch
   static InternetAddress get LOOPBACK_IP_V4 {
     throw new UnsupportedError("InternetAddress.LOOPBACK_IP_V4");
   }
   @patch
   static InternetAddress get LOOPBACK_IP_V6 {
     throw new UnsupportedError("InternetAddress.LOOPBACK_IP_V6");
   }
   @patch
   static InternetAddress get ANY_IP_V4 {
     throw new UnsupportedError("InternetAddress.ANY_IP_V4");
   }
   @patch
   static InternetAddress get ANY_IP_V6 {
     throw new UnsupportedError("InternetAddress.ANY_IP_V6");
   }
   @patch
   factory InternetAddress(String address) {
     throw new UnsupportedError("InternetAddress");
   }
   @patch
   static Future<List<InternetAddress>> lookup(
       String host, {InternetAddressType type: InternetAddressType.ANY}) {
     throw new UnsupportedError("InternetAddress.lookup");
   }
+  @patch
+  static InternetAddress _cloneWithNewHost(
+      InternetAddress address, String host) {
+    throw new UnsupportedError("InternetAddress._cloneWithNewHost");
+  }
 }
 
 @patch
 class NetworkInterface {
   @patch
+  static bool get listSupported {
+    throw new UnsupportedError("NetworkInterface.listSupported");
+  }
+  @patch
   static Future<List<NetworkInterface>> list({
       bool includeLoopback: false,
       bool includeLinkLocal: false,
       InternetAddressType type: InternetAddressType.ANY}) {
     throw new UnsupportedError("NetworkInterface.list");
   }
 }
 
 @patch
 class RawServerSocket {
   @patch
   static Future<RawServerSocket> bind(address,
                                       int port,
                                       {int backlog: 0,
-                                       bool v6Only: false}) {
+                                       bool v6Only: false,
+                                       bool shared: false}) {
     throw new UnsupportedError("RawServerSocket.bind");
   }
 }
 
 @patch
 class ServerSocket {
   @patch
   static Future<ServerSocket> bind(address,
                                    int port,
                                    {int backlog: 0,
-                                    bool v6Only: false}) {
+                                    bool v6Only: false,
+                                    bool shared: false}) {
     throw new UnsupportedError("ServerSocket.bind");
   }
 }
 
 @patch
 class RawSocket {
   @patch
-  static Future<RawSocket> connect(host, int port) {
+  static Future<RawSocket> connect(host, int port, {sourceAddress}) {
     throw new UnsupportedError("RawSocket constructor");
   }
 }
 
 @patch
 class Socket {
   @patch
-  static Future<Socket> connect(host, int port) {
+  static Future<Socket> connect(host, int port, {sourceAddress}) {
     throw new UnsupportedError("Socket constructor");
   }
 }
 
 @patch
 class SecureSocket {
   @patch
   factory SecureSocket._(RawSecureSocket rawSocket) {
     throw new UnsupportedError("SecureSocket constructor");
   }
+}
+
+@patch
+class SecurityContext {
+  @patch
+  factory SecurityContext() {
+    throw new UnsupportedError("SecurityContext constructor");
+  }
 
   @patch
-  static void initialize({String database,
-                          String password,
-                          bool useBuiltinRoots: true}) {
-    throw new UnsupportedError("SecureSocket.initialize");
+  static SecurityContext get defaultContext {
+    throw new UnsupportedError("default SecurityContext getter");
+  }
+
+  @patch
+  static bool get alpnSupported {
+    throw new UnsupportedError("SecurityContext alpnSupported getter");
   }
 }
 
+@patch
+class X509Certificate {
+  @patch
+  factory X509Certificate._() {
+    throw new UnsupportedError("X509Certificate constructor");
+  }
+}
+
 @patch
 class RawDatagramSocket {
   @patch
   static Future<RawDatagramSocket> bind(
       host, int port, {bool reuseAddress: true}) {
     throw new UnsupportedError("RawDatagramSocket.bind");
   }
 }
 
 @patch
 class _SecureFilter {
   @patch
   factory _SecureFilter() {
     throw new UnsupportedError("_SecureFilter._SecureFilter");
   }
 }
 
 @patch
 class _StdIOUtils {
   @patch
   static Stdin _getStdioInputStream() {
     throw new UnsupportedError("StdIOUtils._getStdioInputStream");
   }
   @patch
   static _getStdioOutputStream(int fd) {
     throw new UnsupportedError("StdIOUtils._getStdioOutputStream");
   }
   @patch
-  static int _socketType(nativeSocket) {
+  static int _socketType(Socket socket) {
     throw new UnsupportedError("StdIOUtils._socketType");
   }
   @patch
   static _getStdioHandleType(int fd) {
     throw new UnsupportedError("StdIOUtils._getStdioHandleType");
   }
 }
 
 @patch
 class _WindowsCodePageDecoder {
   @patch
   static String _decodeBytes(List<int> bytes) {
     throw new UnsupportedError("_WindowsCodePageDecoder._decodeBytes");
   }
 }
 
 @patch
 class _WindowsCodePageEncoder {
   @patch
   static List<int> _encodeString(String string) {
     throw new UnsupportedError("_WindowsCodePageEncoder._encodeString");
   }
 }
 
 @patch
 class _Filter {
   @patch
-  static _Filter newZLibDeflateFilter(bool gzip, int level,
-                                      int windowBits, int memLevel,
-                                      int strategy,
-                                      List<int> dictionary, bool raw) {
-    throw new UnsupportedError("newZLibDeflateFilter");
+  static _Filter _newZLibDeflateFilter(bool gzip, int level,
+                                       int windowBits, int memLevel,
+                                       int strategy,
+                                       List<int> dictionary, bool raw) {
+    throw new UnsupportedError("_newZLibDeflateFilter");
   }
   @patch
-  static _Filter newZLibInflateFilter(int windowBits,
-                                      List<int> dictionary, bool raw) {
-    throw new UnsupportedError("newZLibInflateFilter");
+  static _Filter _newZLibInflateFilter(int windowBits,
+                                       List<int> dictionary, bool raw) {
+    throw new UnsupportedError("_newZLibInflateFilter");
   }
 }
 
 @patch
 class Stdin {
   @patch
   int readByteSync() {
     throw new UnsupportedError("Stdin.readByteSync");
   }
   @patch
@@ skipping 10 matching lines @@
   }
   @patch
   void set lineMode(bool enabled) {
     throw new UnsupportedError("Stdin.lineMode");
   }
 }
 
 @patch
 class Stdout {
   @patch
-  bool get hasTerminal {
+  bool _hasTerminal(int fd) {
     throw new UnsupportedError("Stdout.hasTerminal");
   }
   @patch
-  int get terminalColumns {
+  int _terminalColumns(int fd) {
     throw new UnsupportedError("Stdout.terminalColumns");
   }
   @patch
-  int get terminalLines {
+  int _terminalLines(int fd) {
     throw new UnsupportedError("Stdout.terminalLines");
   }
 }
 
 @patch
 class _FileSystemWatcher {
   @patch
-  static Stream<FileSystemEvent> watch(
+  static Stream<FileSystemEvent> _watch(
       String path, int events, bool recursive) {
     throw new UnsupportedError("_FileSystemWatcher.watch");
   }
   @patch
   static bool get isSupported {
     throw new UnsupportedError("_FileSystemWatcher.isSupported");
   }
 }
 
 @patch
 class _IOService {
   @patch
-  static Future dispatch(int request, List data) {
-    throw new UnsupportedError("_IOService.dispatch");
+  static Future _dispatch(int request, List data) {
+    throw new UnsupportedError("_IOService._dispatch");
   }
 }