Removed fixed dependencies

packages/isolate/lib/runner.dart

Index: packages/isolate/lib/runner.dart
diff --git a/packages/isolate/lib/runner.dart b/packages/isolate/lib/runner.dart
new file mode 100644
index 0000000000000000000000000000000000000000..46cee67458c55fe29ab919a59374922d751b3275
--- /dev/null
+++ b/packages/isolate/lib/runner.dart
@@ -0,0 +1,53 @@
+// Copyright (c) 2015, 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.
+
+/// A [Runner] runs a function, potentially in a different scope
+/// or even isolate.
+library isolate.runner;
+
+import 'dart:async' show Future;
+
+/// Calls a function with an argument.
+///
+/// The function can be run in a different place from where the `Runner`
+/// resides, e.g., in a different isolate.
+class Runner {
+  /// Request that [function] be called with the provided arguments.
+  ///
+  /// The arguments will be applied to the function in the same way as by
+  /// [Function.apply], but it may happen in a different isolate or setting.
+  ///
+  /// It's necessary that the function can be sent through a [SendPort]
+  /// if the call is performed in another isolate.
+  /// That means the other isolate should be created using [Isolate.spawn]
+  /// so that it is running the same code as the sending isolate,
+  /// and the function must be a static or top-level function.
+  ///
+  /// Waits for the result of the call, and completes the returned future
+  /// with the result, whether it's a value or an error.
+  ///
+  /// If the returned future does not complete before `timeLimit` has passed,
+  /// the [onTimeout] action is executed instead, and its result (whether it
+  /// returns or throws) is used as the result of the returned future.
+  ///
+  /// If `onTimeout` is omitted, a timeout will cause the returned future to
+  /// complete with a [TimeoutException].
+  ///
+  /// The default implementation runs the function in the current isolate.
+  Future run(function(argument), Object argument,
+             {Duration timeout, onTimeout()}) {
+    Future result = new Future.sync(() => function(argument));
+    if (timeout != null) {
+      result = result.timeout(timeout, onTimeout: onTimeout);
+    }
+    return result;
+  }
+
+  /// Stop the runner.
+  ///
+  /// If the runner has allocated resources, e.g., an isolate, it should
+  /// be released. No further calls to [run] should be made after calling
+  /// stop.
+  Future close() => new Future.value();
+}