Expose the new _getSourceReport api in the service protocol.

runtime/vm/service.cc

 // Copyright (c) 2013, 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.
 
 #include "vm/service.h"
 
 #include "include/dart_api.h"
 #include "include/dart_native_api.h"
 #include "platform/globals.h"
 
@@ skipping 12 matching lines @@
 #include "vm/object.h"
 #include "vm/object_graph.h"
 #include "vm/object_id_ring.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/port.h"
 #include "vm/profiler_service.h"
 #include "vm/reusable_handles.h"
 #include "vm/service_event.h"
 #include "vm/service_isolate.h"
+#include "vm/source_report.h"
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
 #include "vm/unicode.h"
 #include "vm/version.h"
 
 namespace dart {
 
 #define Z (T->zone())
 
 
@@ skipping 511 matching lines @@
   for (i = 0; enums[i] != NULL; i++) {
     if (strcmp(value, enums[i]) == 0) {
       return values[i];
     }
   }
   // Default value.
   return values[i];
 }
 
 
+class EnumListParameter : public MethodParameter {
+ public:
+  EnumListParameter(const char* name, bool required, const char* const* enums)
+      : MethodParameter(name, required),
+        enums_(enums) {
+  }
+
+  virtual bool Validate(const char* value) const {
+    return ElementCount(value, enums_) >= 0;
+  }
+
+  static const char** Parse(Zone* zone,
+                            const char* value_in,
+                            const char* const* enums) {

[Cutch, 2016/01/06 19:18:26]

Why pass in enums again? You store it in the constructor.

[turnidge, 2016/01/06 20:58:13]

The rest of our Parse methods are static and I was going for consistency.  I
have changed it to an instance method and I have arranged to keep a
reports_parameter static global.

+    const char* kJsonChars = " \t\r\n[,]";
+
+    // Make a writeable copy of the value.
+    char* value = zone->MakeCopyOfString(value_in);
+    intptr_t element_count = ElementCount(value, enums);
+    intptr_t element_pos = 0;
+
+    // Allocate our element array.  +1 for NULL terminator.
+    char** elements = zone->Alloc<char*>(element_count + 1);
+    elements[element_count] = NULL;
+
+    // Parse the string destructively.  Build the list of elements.

[Cutch, 2016/01/06 19:18:26]

Zone allocation is cheap, consider doing this without modifying the source
string?

[turnidge, 2016/01/06 20:58:12]

This already is a copy of the string, check out the call to MakeCopyOfString
above.

+    while (element_pos < element_count) {
+      // Skip to the next element.
+      value += strspn(value, kJsonChars);
+
+      intptr_t len = strcspn(value, kJsonChars);
+      ASSERT(len > 0);  // We rely on the parameter being validated already.
+      value[len] = '\0';
+      elements[element_pos++] = value;
+
+      // Advance.  +1 for null terminator.
+      value += (len + 1);
+    }
+    return const_cast<const char**>(elements);
+  }
+
+ private:
+  // Returns number of elements in the list.  -1 on parse error.
+  static intptr_t ElementCount(const char* value, const char* const* enums) {
+    if (value == NULL) {
+      return -1;
+    }
+    const char* cp = value;

[Cutch, 2016/01/06 19:18:26]

Skip whitespace before checking for '['

[turnidge, 2016/01/06 20:58:12]

The whitespace will be trimmed already by the time it gets this deep into the C
code.  But it is easy to add so I did.

+    if (*cp++ != '[') {
+      // Missing initial [.
+      return -1;
+    }
+    bool closed = false;
+    bool element_allowed = true;
+    intptr_t element_count = 0;
+    while (true) {
+      // Skip json whitespace.
+      cp += strspn(cp, " \t\r\n");

[Cutch, 2016/01/06 19:18:25]

Pull this constant string out to a kWhitespaceChars

[turnidge, 2016/01/06 20:58:12]

Done.

+      switch (*cp) {
+        case '\0':
+          return closed ? element_count : -1;
+        case ']':
+          closed = true;
+          cp++;
+          break;
+        case ',':
+          if (element_allowed) {
+            return -1;
+          }
+          element_allowed = true;
+          cp++;
+          break;
+        default:
+          if (!element_allowed) {
+            return -1;
+          }
+          bool valid_enum = false;
+          for (intptr_t i = 0; enums[i] != NULL; i++) {

[Cutch, 2016/01/06 19:18:26]

Maybe allow for enums to be NULL so that an arbitrary list could be parsed?

[turnidge, 2016/01/06 20:58:12]

Done.

+            intptr_t len = strlen(enums[i]);
+            if (strncmp(cp, enums[i], len) == 0) {
+              element_count++;
+              valid_enum = true;
+              cp += len;
+              element_allowed = false;  // we need a comma first.
+              break;
+            }
+          }
+          if (!valid_enum) {
+            return -1;
+          }
+          break;
+      }
+    }
+  }
+
+  const char* const* enums_;
+};
+
+
 typedef bool (*ServiceMethodEntry)(Thread* thread, JSONStream* js);
 
 
 struct ServiceMethodDescriptor {
   const char* name;
   const ServiceMethodEntry entry;
   const MethodParameter* const * parameters;
 };
 
 
@@ skipping 1610 matching lines @@
   NULL,
 };
 
 
 static bool GetCoverage(Thread* thread, JSONStream* js) {
   // TODO(rmacnak): Remove this response; it is subsumed by GetCallSiteData.
   return GetHitsOrSites(thread, js, false);
 }
 
 
+static const char* kCallSitesStr = "CallSites";
+static const char* kCoverageStr = "Coverage";
+
+
+static const char* const report_enum_names[] = {
+  kCallSitesStr,
+  kCoverageStr,
+  NULL,
+};
+
+
+static const MethodParameter* get_source_report_params[] = {
+  ISOLATE_PARAMETER,
+  new EnumListParameter("reports", true, report_enum_names),
+  new IdParameter("scriptId", false),
+  new UIntParameter("tokenPos", false),
+  new UIntParameter("endTokenPos", false),
+  NULL,
+};
+
+
+static bool GetSourceReport(Thread* thread, JSONStream* js) {
+  const char* reports_str = js->LookupParam("reports");
+  const char** reports =
+      EnumListParameter::Parse(thread->zone(), reports_str, report_enum_names);
+  intptr_t report_set = 0;
+  while (*reports != NULL) {
+    if (strcmp(*reports, kCallSitesStr) == 0) {
+      report_set |= SourceReport::kCallSites;
+    } else if (strcmp(*reports, kCoverageStr) == 0) {
+      report_set |= SourceReport::kCoverage;
+    }
+    reports++;
+  }
+
+  Script& script = Script::Handle();
+  intptr_t start_pos = UIntParameter::Parse(js->LookupParam("tokenPos"));
+  intptr_t end_pos = UIntParameter::Parse(js->LookupParam("endTokenPos"));
+
+  if (js->HasParam("scriptId")) {
+    // Get the target script.
+    const char* script_id_param = js->LookupParam("scriptId");
+    const Object& obj =
+        Object::Handle(LookupHeapObject(thread, script_id_param, NULL));
+    if (obj.raw() == Object::sentinel().raw() || !obj.IsScript()) {
+      PrintInvalidParamError(js, "scriptId");
+      return true;
+    }
+    script ^= obj.raw();
+  } else {
+    if (js->HasParam("tokenPos")) {
+      js->PrintError(
+          kInvalidParams,
+          "%s: the 'tokenPos' parameter requires the 'scriptId' parameter",
+          js->method());
+      return false;

[Cutch, 2016/01/06 19:18:25]

These should return true or else we will hit the UNIMPLEMENTED() call in
InvokeMethod. Also, add a test for an error case too.

[turnidge, 2016/01/06 20:58:13]

Thanks.  Done.

+    }
+    if (js->HasParam("endTokenPos")) {
+      js->PrintError(
+          kInvalidParams,
+          "%s: the 'endTokenPos' parameter requires the 'scriptId' parameter",
+          js->method());
+      return false;
+    }
+  }
+  SourceReport report(report_set);
+  report.PrintJSON(js, script, start_pos, end_pos);
+  return true;
+}
+
+
 static const MethodParameter* get_call_site_data_params[] = {
   ISOLATE_PARAMETER,
   new IdParameter("targetId", false),
   NULL,
 };
 
 
 static bool GetCallSiteData(Thread* thread, JSONStream* js) {
   return GetHitsOrSites(thread, js, true);
 }
@@ skipping 1397 matching lines @@
   { "_getObjectByAddress", GetObjectByAddress,
     get_object_by_address_params },
   { "_getPorts", GetPorts,
     get_ports_params },
   { "_getReachableSize", GetReachableSize,
     get_reachable_size_params },
   { "_getRetainedSize", GetRetainedSize,
     get_retained_size_params },
   { "_getRetainingPath", GetRetainingPath,
     get_retaining_path_params },
+  { "_getSourceReport", GetSourceReport,
+    get_source_report_params },
   { "getStack", GetStack,
     get_stack_params },
   { "_getTagProfile", GetTagProfile,
     get_tag_profile_params },
   { "_getTypeArgumentsList", GetTypeArgumentsList,
     get_type_arguments_list_params },
   { "getVersion", GetVersion,
     get_version_params },
   { "getVM", GetVM,
     get_vm_params },
@@ skipping 39 matching lines @@
     const ServiceMethodDescriptor& method = service_methods_[i];
     if (strcmp(method_name, method.name) == 0) {
       return &method;
     }
   }
   return NULL;
 }
 
 
 }  // namespace dart