Coverage API revamp

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 "platform/globals.h"
 
 #include "vm/compiler.h"
@@ skipping 133 matching lines @@
   }
 
  private:
   char* name_;
   Dart_ServiceRequestCallback callback_;
   void* user_data_;
   EmbedderServiceHandler* next_;
 };
 
 
+class LibraryCoverageFilter : public CoverageFilter {
+ public:
+  explicit LibraryCoverageFilter(const Library& lib) : lib_(lib) {}
+  ~LibraryCoverageFilter() {}

[Cutch, 2014/06/27 17:20:12]

These destructors aren't necessary.

[Michael Lippautz (Google), 2014/06/27 17:51:24]

Done.

+  bool ShouldOutputCoverageFor(const Library& lib,
+                               const String& script_url,
+                               const Class& cls,
+                               const Function& func) const {
+    return lib.raw() == lib_.raw();
+  }
+ private:
+  const Library& lib_;
+};
+
+
+class ScriptCoverageFilter : public CoverageFilter {
+ public:
+  explicit ScriptCoverageFilter(const String& script_url)
+      : script_url_(script_url) {}
+  ~ScriptCoverageFilter() {}
+  bool ShouldOutputCoverageFor(const Library& lib,
+                               const String& script_url,
+                               const Class& cls,
+                               const Function& func) const {
+    return script_url_.Equals(script_url);
+  }
+ private:
+  const String& script_url_;
+};
+
+
+class ClassCoverageFilter : public CoverageFilter {
+ public:
+  explicit ClassCoverageFilter(const Class& cls) : cls_(cls) {}
+  ~ClassCoverageFilter() {}
+  bool ShouldOutputCoverageFor(const Library& lib,
+                               const String& script_url,
+                               const Class& cls,
+                               const Function& func) const {
+    return cls.raw() == cls_.raw();
+  }
+ private:
+  const Class& cls_;
+};
+
+
 static uint8_t* allocator(uint8_t* ptr, intptr_t old_size, intptr_t new_size) {
   void* new_ptr = realloc(reinterpret_cast<void*>(ptr), new_size);
   return reinterpret_cast<uint8_t*>(new_ptr);
 }
 
 
 static void SendIsolateServiceMessage(Dart_NativeArguments args) {
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   Isolate* isolate = arguments->isolate();
   StackZone zone(isolate);
@@ skipping 1036 matching lines @@
   jsobj.AddProperty("totalCount", count);
   jsobj.AddProperty("sampleCount", storage.Length());
   jsobj.AddProperty("sample", storage);
   return true;
 }
 
 
 static bool HandleClassesCoverage(Isolate* isolate,
                                   const Class& cls,
                                   JSONStream* stream) {
-  CodeCoverage::PrintJSONForClass(cls, stream);
+  ClassCoverageFilter cf(cls);
+  CodeCoverage::PrintJSON(isolate, stream, &cf);
   return true;
 }
 
 
 static bool HandleClasses(Isolate* isolate, JSONStream* js) {
   if (js->num_arguments() == 1) {
     ClassTable* table = isolate->class_table();
     JSONObject jsobj(js);
     table->PrintToJSONObject(&jsobj);
     return true;
@@ skipping 62 matching lines @@
                                                      Array::empty_array(),
                                                      Array::empty_array()));
   result.PrintJSON(js, true);
   return true;
 }
 
 
 static bool HandleLibrariesCoverage(Isolate* isolate,
                                     const Library& lib,
                                     JSONStream* js) {
-  CodeCoverage::PrintJSONForLibrary(lib, Script::Handle(), js);
+  LibraryCoverageFilter lf(lib);
+  CodeCoverage::PrintJSON(isolate, js, &lf);
   return true;
 }
 
 
 static bool HandleLibraries(Isolate* isolate, JSONStream* js) {
   // TODO(johnmccutchan): Support fields and functions on libraries.
   REQUIRE_COLLECTION_ID("libraries");
   const GrowableObjectArray& libs =
       GrowableObjectArray::Handle(isolate->object_store()->libraries());
   ASSERT(!libs.IsNull());
@@ skipping 184 matching lines @@
 
 
 static bool HandleScriptsFetch(
     Isolate* isolate, const Script& script, JSONStream* js) {
   script.PrintJSON(js, false);
   return true;
 }
 
 
 static bool HandleScriptsCoverage(
-    Isolate* isolate, const Script& script, JSONStream* js) {
-  CodeCoverage::PrintJSONForScript(script, js);
+    Isolate* isolate, const String& script_url, JSONStream* js) {
+  ScriptCoverageFilter sf(script_url);
+  CodeCoverage::PrintJSON(isolate, js, &sf);
   return true;
 }
 
 
 static bool HandleScripts(Isolate* isolate, JSONStream* js) {
   if (js->num_arguments() == 1) {
     // Enumerate all scripts.
     return HandleScriptsEnumerate(isolate, js);
   }
   // Subcommands of scripts require a valid script id.
   const String& id = String::Handle(String::New(js->GetArgument(1)));
   ASSERT(!id.IsNull());
   // The id is the url of the script % encoded, decode it.
   String& requested_url = String::Handle(String::DecodeURI(id));
   Script& script = Script::Handle();
-  script = Script::FindByUrl(requested_url);
-  if (script.IsNull()) {
+  // There may exist more than one script object for a given url. Since they all
+  // have the same properties (source, tokens) we don't care which one we get.
+  const GrowableObjectArray& libs = GrowableObjectArray::Handle(
+      isolate, isolate->object_store()->libraries());
+  Library& lib = Library::Handle();
+  String& script_url = String::Handle();
+  bool found = false;
+  for (intptr_t i = 0; !found && (i < libs.Length()); i++) {
+    lib ^= libs.At(i);
+    ASSERT(!lib.IsNull());
+    const Array& loaded_scripts = Array::Handle(lib.LoadedScripts());
+    ASSERT(!loaded_scripts.IsNull());
+    for (intptr_t j = 0; !found && (j < loaded_scripts.Length()); j++) {
+      script ^= loaded_scripts.At(j);
+      ASSERT(!script.IsNull());
+      script_url ^= script.url();
+      if (script_url.Equals(requested_url)) {
+        found = true;
+      }
+    }
+  }
+  if (!found) {
     PrintErrorWithKind(js, "NotFoundError", "Cannot find script %s",
                        requested_url.ToCString());
     return true;
   }
   if (js->num_arguments() == 2) {
     // If no subcommand is given, just fetch the script.
     return HandleScriptsFetch(isolate, script, js);
   } else if (js->num_arguments() == 3) {
     const char* arg = js->GetArgument(2);
     if (strcmp(arg, "coverage") == 0) {
-      return HandleScriptsCoverage(isolate, script, js);
+      return HandleScriptsCoverage(isolate, requested_url, js);
     }
     PrintError(js, "Unrecognized subcommand '%s'", arg);
     return true;
   } else {
     PrintError(js, "Command too long");
     return true;
   }
 }
 
 
@@ skipping 181 matching lines @@
     } else {
       PrintError(js, "Invalid tags option value: %s\n", tags_option);
       return true;
     }
   }
   Profiler::PrintJSON(isolate, js, full_profile, tag_order);
   return true;
 }
 
 static bool HandleCoverage(Isolate* isolate, JSONStream* js) {
-  CodeCoverage::PrintJSON(isolate, js);
+  CodeCoverage::PrintJSON(isolate, js, NULL);
   return true;
 }
 
 
 static bool HandleAllocationProfile(Isolate* isolate, JSONStream* js) {
   bool should_reset_accumulator = false;
   bool should_collect = false;
   if (js->num_arguments() != 1) {
     PrintError(js, "Command too long");
     return true;
@@ skipping 462 matching lines @@
   while (current != NULL) {
     if (strcmp(name, current->name()) == 0) {
       return current;
     }
     current = current->next();
   }
   return NULL;
 }
 
 }  // namespace dart