add sendRequest to VMIsolateRef

lib/src/stream_manager.dart

 // 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.
 
 import 'dart:async';
 
 import 'package:json_rpc_2/json_rpc_2.dart' as rpc;
 
 /// A class that exposes the service protocol's event streams.
 ///
@@ skipping 23 matching lines @@
   StreamController<Map> _gcController;
 
   /// Data written to standard output.
   Stream<Map> get stdout => _stdoutController.stream;
   StreamController<Map> _stdoutController;
 
   /// Data written to standard error.
   Stream<Map> get stderr => _stderrController.stream;
   StreamController<Map> _stderrController;
 
+  /// Custom events posted via `postEvent` from the `dart:developer` package.
+  Stream<Map> get extension => _extensionController.stream;
+  StreamController<Map> _extensionController;
+
   /// A subscription to [debug].
   ///
   /// This subscription fires no events, but it exists as long as there's also a
   /// subscription to [stdout] or [stderr] to work around sdk#24350.
   StreamSubscription _debugSubscription;
 
   StreamManager(this._peer) {
     _isolateController = _controller("Isolate");
     _vmController = _controller("VM");
     _debugController = _controller("Debug");
     _gcController = _controller("GC");
     _stdoutController = _controller("Stdout");
     _stderrController = _controller("Stderr");
+    _extensionController = _controller("Extension");
 
     _peer.registerMethod("streamNotify", (params) {
       switch (params["streamId"].asString) {
         case "VM":
           _vmController.add(params["event"].asMap);
           break;
         case "Isolate":
           _isolateController.add(params["event"].asMap);
           break;
         case "Debug":
           _debugController.add(params["event"].asMap);
           break;
         case "GC":
           _gcController.add(params["event"].asMap);
           break;
         case "Stdout":
           _stdoutController.add(params["event"].asMap);
           break;
         case "Stderr":
           _stderrController.add(params["event"].asMap);
           break;
+        case "Extension":
+          _extensionController.add(params["event"].asMap);
+          break;
       }
     });
 
     _peer.done.then((_) {
       _vmController.close();
       _isolateController.close();
       _debugController.close();
       _gcController.close();
       _stderrController.close();
       _stdoutController.close();
+      _extensionController.close();
     }, onError: (_) {});
   }
 
   /// Returns a broadcast [StreamController] for the stream with [streamID].
   ///
   /// This controller subscribes to the stream when it has a listener and
   /// unsubscribes once it has no listeners.
   StreamController<Map> _controller(String streamID) {
     var controller;
     controller = new StreamController.broadcast(sync: true, onListen: () {
@@ skipping 22 matching lines @@
       _peer.sendRequest("streamCancel", {
         "streamId": streamID
       }).catchError((_) {
         // Do nothing if canceling the stream failed, since no one's listening
         // to it anyway.
       });
     });
     return controller;
   }
 }