Make reloadSources service RPC public

runtime/observatory/tests/service/service_test_common.dart

 // Copyright (c) 2016, 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.
 
 library service_test_common;
 
 import 'dart:async';
 import 'package:observatory/models.dart' as M;
 import 'package:observatory/service_common.dart';
 import 'package:unittest/unittest.dart';
@@ skipping 126 matching lines @@
 bool isEventOfKind(M.Event event, String kind) {
   switch (kind) {
     case ServiceEvent.kPauseBreakpoint:
       return event is M.PauseBreakpointEvent;
     case ServiceEvent.kPauseException:
       return event is M.PauseExceptionEvent;
     case ServiceEvent.kPauseExit:
       return event is M.PauseExitEvent;
     case ServiceEvent.kPauseStart:
       return event is M.PauseStartEvent;
+    case ServiceEvent.kPausePostRequest:
+      return event is M.PausePostRequestEvent;
     default:
       return false;
   }
 }
 
 Future<Isolate> hasPausedFor(Isolate isolate, String kind) {
   // Set up a listener to wait for breakpoint events.
   Completer completer = new Completer();
   isolate.vm.getEventStream(VM.kDebugStream).then((stream) {
     var subscription;
@@ skipping 24 matching lines @@
     });
   });
 
   return completer.future;  // Will complete when breakpoint hit.
 }
 
 Future<Isolate> hasStoppedAtBreakpoint(Isolate isolate) {
   return hasPausedFor(isolate, ServiceEvent.kPauseBreakpoint);
 }
 
+Future<Isolate> hasStoppedPostRequest(Isolate isolate) {
+  return hasPausedFor(isolate, ServiceEvent.kPausePostRequest);
+}
+
 Future<Isolate> hasStoppedWithUnhandledException(Isolate isolate) {
   return hasPausedFor(isolate, ServiceEvent.kPauseException);
 }
 
 Future<Isolate> hasStoppedAtExit(Isolate isolate) {
   return hasPausedFor(isolate, ServiceEvent.kPauseExit);
 }
 
 Future<Isolate> hasPausedAtStart(Isolate isolate) {
   return hasPausedFor(isolate, ServiceEvent.kPauseStart);
 }
 
+IsolateTest reloadSources([bool pause = false]) {
+    return (Isolate isolate) async {
+      Map<String, dynamic> params = <String, dynamic>{ };
+      if (pause == true) {
+        params['pause'] = pause;
+      }
+      return isolate.invokeRpc('reloadSources', params);
+    };
+}
+
 // Currying is your friend.
 IsolateTest setBreakpointAtLine(int line) {
   return (Isolate isolate) async {
     print("Setting breakpoint for line $line");
     Library lib = await isolate.rootLibrary.load();
     Script script = lib.scripts.single;
 
     Breakpoint bpt = await isolate.addBreakpoint(script, line);
     print("Breakpoint is $bpt");
     expect(bpt, isNotNull);
@@ skipping 113 matching lines @@
   await isolate.stepInto();
   return hasStoppedAtBreakpoint(isolate);
 }
 
 Future<Isolate> stepOut(Isolate isolate) async {
   await isolate.stepOut();
   return hasStoppedAtBreakpoint(isolate);
 }
 
 
+Future isolateIsRunning(Isolate isolate) async {
+  await isolate.reload();
+  expect(isolate.running, true);
+}
+
 Future<Class> getClassFromRootLib(Isolate isolate, String className) async {
   Library rootLib = await isolate.rootLibrary.load();
   for (var i = 0; i < rootLib.classes.length; i++) {
     Class cls = rootLib.classes[i];
     if (cls.name == className) {
       return cls;
     }
   }
   return null;
 }
 
 
 Future<Instance> rootLibraryFieldValue(Isolate isolate,
                                        String fieldName) async {
   Library rootLib = await isolate.rootLibrary.load();
   Field field = rootLib.variables.singleWhere((v) => v.name == fieldName);
   await field.load();
   Instance value = field.staticValue;
   await value.load();
   return value;
 }