Tidy up the service protocol. Begin improving the documentation.

runtime/observatory/test/call_site_data_test.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.
 // VMOptions=--compile-all --error_on_bad_type --error_on_bad_override --checked
 
 library call_site_data_test;
 
 import 'package:observatory/service_io.dart';
 import 'package:unittest/unittest.dart';
 import 'test_helper.dart';
@@ skipping 71 matching lines @@
   return callSite['cacheEntries'].map((entry) {
     return "${entry['receiverContainer']['name']}:${entry['count']}";
   }).toSet();
 }
 
 
 testMonomorphic(Isolate isolate) async {
   Library lib = await isolate.rootLib.load();
   ServiceFunction func =
      lib.functions.singleWhere((f) => f.name == 'monomorphic');
-  Map response = await isolate.invokeRpcNoUpgrade('getCallSiteData',
+  Map response = await isolate.invokeRpcNoUpgrade('_getCallSiteData',
                                                   { 'targetId': func.id });
   expect(response['type'], equals('CodeCoverage'));
   Map callSite = response['coverage'].single['callSites'].single;
   expect(callSite['name'], equals('foo'));
   expect(stringifyCacheEntries(callSite),
          equals(['A:10'].toSet()));
 }
 
 testPolymorphic(Isolate isolate) async {
   Library lib = await isolate.rootLib.load();
   ServiceFunction func =
      lib.functions.singleWhere((f) => f.name == 'polymorphic');
-  Map response = await isolate.invokeRpcNoUpgrade('getCallSiteData',
+  Map response = await isolate.invokeRpcNoUpgrade('_getCallSiteData',
                                                   { 'targetId': func.id });
   expect(response['type'], equals('CodeCoverage'));
   Map callSite = response['coverage'].single['callSites'].single;
   expect(callSite['name'], equals('foo'));
   expect(stringifyCacheEntries(callSite),
          equals(['A:10', 'B:20', 'C:30'].toSet()));
 }
 
 testMegamorphic(Isolate isolate) async {
   Library lib = await isolate.rootLib.load();
   ServiceFunction func =
      lib.functions.singleWhere((f) => f.name == 'megamorphic');
-  Map response = await isolate.invokeRpcNoUpgrade('getCallSiteData',
+  Map response = await isolate.invokeRpcNoUpgrade('_getCallSiteData',
                                                   { 'targetId': func.id });
   expect(response['type'], equals('CodeCoverage'));
   Map callSite = response['coverage'].single['callSites'].single;
   expect(callSite['name'], equals('foo'));
   expect(stringifyCacheEntries(callSite),
          equals(['A:10', 'B:20', 'C:30', 'D:40',
                  'E:50', 'F:60', 'G:70', 'H:80'].toSet()));
 }
 
 testStaticCall(Isolate isolate) async {
   Library lib = await isolate.rootLib.load();
   ServiceFunction func =
      lib.functions.singleWhere((f) => f.name == 'staticCall');
-  Map response = await isolate.invokeRpcNoUpgrade('getCallSiteData',
+  Map response = await isolate.invokeRpcNoUpgrade('_getCallSiteData',
                                                   { 'targetId': func.id });
   expect(response['type'], equals('CodeCoverage'));
   Map callSite = response['coverage'].single['callSites'].single;
   expect(callSite['name'], equals('staticMethod'));
   expect(stringifyCacheEntries(callSite),
          equals(['Static:10'].toSet()));
 }
 
 testConstructorCall(Isolate isolate) async {
   Library lib = await isolate.rootLib.load();
   ServiceFunction func =
      lib.functions.singleWhere((f) => f.name == 'constructorCall');
-  Map response = await isolate.invokeRpcNoUpgrade('getCallSiteData',
+  Map response = await isolate.invokeRpcNoUpgrade('_getCallSiteData',
                                                   { 'targetId': func.id });
   expect(response['type'], equals('CodeCoverage'));
   Map callSite = response['coverage'].single['callSites'].single;
   expect(callSite['name'], equals('Static.'));
   expect(stringifyCacheEntries(callSite),
          equals(['Static:10'].toSet()));
 }
 
 testTopLevelCall(Isolate isolate) async {
   Library lib = await isolate.rootLib.load();
   ServiceFunction func =
      lib.functions.singleWhere((f) => f.name == 'topLevelCall');
-  Map response = await isolate.invokeRpcNoUpgrade('getCallSiteData',
+  Map response = await isolate.invokeRpcNoUpgrade('_getCallSiteData',
                                                   { 'targetId': func.id });
   expect(response['type'], equals('CodeCoverage'));
   Map callSite = response['coverage'].single['callSites'].single;
   expect(callSite['name'], equals('topLevelMethod'));
   expect(stringifyCacheEntries(callSite),
          equals(['call_site_data_test:10'].toSet()));
 }
 
 testSuperCall(Isolate isolate) async {
   Library lib = await isolate.rootLib.load();
   Class cls = await lib.classes.singleWhere((f) => f.name == 'Sub').load();
   ServiceFunction func = cls.functions.singleWhere((f) => f.name == 'bar');
-  Map response = await isolate.invokeRpcNoUpgrade('getCallSiteData',
+  Map response = await isolate.invokeRpcNoUpgrade('_getCallSiteData',
                                                   { 'targetId': func.id });
   expect(response['type'], equals('CodeCoverage'));
   Map callSite = response['coverage'].single['callSites'].single;
   expect(callSite['name'], equals('bar'));
   expect(stringifyCacheEntries(callSite),
          equals(['Super:15'].toSet()));
 }
 
 var tests = [
     testMonomorphic,
     testPolymorphic,
     testMegamorphic,
     testStaticCall,
     testConstructorCall,
     testTopLevelCall,
     testSuperCall ];
 
 main(args) => runIsolateTests(args, tests, testeeBefore: script);