Add support for file locking

sdk/lib/io/file_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;
 
 // Read the file in blocks of size 64k.
 const int _BLOCK_SIZE = 64 * 1024;
 
 
@@ skipping 922 matching lines @@
   external static _flush(int id);
 
   void flushSync() {
     _checkAvailable();
     var result = _flush(_id);
     if (result is OSError) {
       throw new FileSystemException("flush failed", path, result);
     }
   }
 
+  static final int LOCK_UNLOCK = 0;
+  static final int LOCK_SHARED = 1;
+  static final int LOCK_EXCLUSIVE = 2;
+
+  Future<RandomAccessFile> lock(
+      [FileLock mode = FileLock.EXCLUSIVE, int start = 0, int end]) {
+    if ((start != null && start is !int) ||
+        (end != null && end is !int) ||
+         mode is !FileLock) {
+      throw new ArgumentError();
+    }
+    if (start == null) start = 0;
+    if (end == null) end = -1;
+    if (start < 0 || end < -1 || (end != -1 && start >= end)) {
+      throw new ArgumentError();
+    }
+    int lock = mode == FileLock.EXCLUSIVE ? LOCK_EXCLUSIVE : LOCK_SHARED;
+    return _dispatch(_FILE_LOCK, [_id, lock, start, end])
+        .then((response) {
+          if (_isErrorResponse(response)) {
+            throw _exceptionFromResponse(response, 'lock failed', path);
+          }
+          return this;
+        });
+  }
+
+  Future<RandomAccessFile> unlock([int start = 0, int end]) {
+    if ((start != null && start is !int) ||
+        (end != null && end is !int)) {
+      throw new ArgumentError();
+    }
+    if (start == null) start = 0;
+    if (end == null) end = -1;
+    if (start == end) throw new ArgumentError();
+    return _dispatch(_FILE_LOCK, [_id, LOCK_UNLOCK, start, end])
+        .then((response) {
+          if (_isErrorResponse(response)) {
+            throw _exceptionFromResponse(response, 'unlock failed', path);
+          }
+          return this;
+        });
+  }
+
+  external static _lock(int id, int lock, int start, int end);
+
+  void lockSync([FileLock mode = FileLock.EXCLUSIVE, int start = 0, int end]) {
+    _checkAvailable();
+    if ((start != null && start is !int) ||
+        (end != null && end is !int) ||
+         mode is !FileLock) {
+      throw new ArgumentError();
+    }
+    if (start == null) start = 0;
+    if (end == null) end = -1;
+    if (start < 0 || end < -1 || (end != -1 && start >= end)) {
+      throw new ArgumentError();
+    }
+    int lock = mode == FileLock.EXCLUSIVE ? LOCK_EXCLUSIVE : LOCK_SHARED;
+    var result = _lock(_id, lock, start, end);
+    if (result is OSError) {
+      throw new FileSystemException('lock failed', path, result);
+    }
+  }
+
+  void unlockSync([int start = 0, int end]) {
+    _checkAvailable();
+    if ((start != null && start is !int) ||
+        (end != null && end is !int)) {
+      throw new ArgumentError();
+    }
+    if (start == null) start = 0;
+    if (end == null) end = -1;
+    if (start == end) throw new ArgumentError();
+    var result = _lock(_id, LOCK_UNLOCK, start, end);
+    if (result is OSError) {
+      throw new FileSystemException('unlock failed', path, result);
+    }
+  }
+
   bool get closed => _id == 0;
 
   Future _dispatch(int request, List data, { bool markClosed: false }) {
     if (closed) {
       return new Future.error(new FileSystemException("File closed", path));
     }
     if (_asyncDispatched) {
       var msg = "An async operation is currently pending";
       return new Future.error(new FileSystemException(msg, path));
     }
@@ skipping 12 matching lines @@
   void _checkAvailable() {
     if (_asyncDispatched) {
       throw new FileSystemException("An async operation is currently pending",
                                     path);
     }
     if (closed) {
       throw new FileSystemException("File closed", path);
     }
   }
 }