Allow Dart code to register service protocol handlers

runtime/observatory/tests/service/developer_extension_test.dart

Index: runtime/observatory/tests/service/developer_extension_test.dart
diff --git a/runtime/observatory/tests/service/developer_extension_test.dart b/runtime/observatory/tests/service/developer_extension_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..48ebb86dab0526d03e4cc5ccbbe2ff88dbc2d4f3
--- /dev/null
+++ b/runtime/observatory/tests/service/developer_extension_test.dart
@@ -0,0 +1,102 @@
+// 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.
+// VMOptions=--error_on_bad_type --error_on_bad_override
+
+import 'dart:async';
+import 'dart:convert';
+import 'dart:developer';
+import 'package:observatory/service_io.dart';
+import 'package:observatory/cpu_profile.dart';
+import 'package:unittest/unittest.dart';
+
+import 'test_helper.dart';
+
+Future<ServiceExtensionResponse> Handler(String method,
+                                         Map paremeters) {

[turnidge, 2015/08/06 18:12:54]

Reminder to run the tests in --checked mode before committing.

[Cutch, 2015/08/06 23:20:18]

Done.

+  switch (method) {
+    case '__delay':
+      Completer c = new Completer();
+      new Timer(new Duration(seconds: 1), () {
+        c.complete(new ServiceExtensionResponse.result(JSON.encode({
+            'type': '_delayedType',
+            'method': method,
+            'parameters': paremeters,
+          })));
+      });
+      return c.future;
+    case '__error':
+      return new ServiceExtensionResponse.error(
+          ServiceExtensionResponse.kExtensionErrorMin,
+          'My error detail.');
+    case '__exception':
+      throw "I always throw!";
+    case '__success':
+      return new ServiceExtensionResponse.result(JSON.encode({
+        'type': '_extensionType',
+        'method': method,
+        'parameters': paremeters,
+      }));
+    case '__null':
+      return null;
+  }
+}
+
+void test() {
+  registerExtension('__delay', Handler);
+  registerExtension('__error', Handler);
+  registerExtension('__exception', Handler);
+  registerExtension('__null', Handler);
+  registerExtension('__success', Handler);
+  bool exceptionThrown = false;
+  try {
+    registerException('__delay', Handler);
+  } catch (e) {
+    exceptionThrown = true;
+  }
+  expect(exceptionThrown, isTrue);
+}
+
+var tests = [
+  // Initial.
+  (Isolate isolate) async {
+    var result;
+
+    result = await isolate.invokeRpcNoUpgrade('__delay', {});
+    expect(result['type'], equals('_delayedType'));
+    expect(result['method'], equals('__delay'));
+    expect(result['parameters']['isolateId'], isNotNull);
+
+    try {
+      await isolate.invokeRpcNoUpgrade('__error', {});
+    } on ServerRpcException catch (e, st) {
+      expect(e.code, equals(ServiceExtensionResponse.kExtensionErrorMin));
+      expect(e.message, equals('My error detail.'));
+    }
+
+    try {
+      await isolate.invokeRpcNoUpgrade('__exception', {});
+    } on ServerRpcException catch (e, st) {
+      expect(e.code, equals(ServiceExtensionResponse.kExtensionError));
+      expect(e.message.startsWith('I always throw!\n'), isTrue);
+    }
+
+    try {
+      await isolate.invokeRpcNoUpgrade('__null', {});
+    } on ServerRpcException catch (e, st) {
+      expect(e.code, equals(ServiceExtensionResponse.kExtensionError));
+      expect(e.message, equals('Extension handler returned null'));
+    }
+
+    result = await isolate.invokeRpcNoUpgrade('__success',
+                                              {'apple': 'banana'});
+    expect(result['type'], equals('_extensionType'));
+    expect(result['method'], equals('__success'));
+    expect(result['parameters']['isolateId'], isNotNull);
+    expect(result['parameters']['apple'], equals('banana'));
+
+
+  },
+];
+
+main(args) async => runIsolateTests(args, tests, testeeBefore:test);