[debugger] implement inspector-facing API for code coverage.

src/debug/debug-coverage.h

 // Copyright 2017 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_DEBUG_DEBUG_COVERAGE_H_
 #define V8_DEBUG_DEBUG_COVERAGE_H_
 
 #include <vector>
 
-#include "src/allocation.h"
 #include "src/debug/debug-interface.h"
 #include "src/objects.h"
 
 namespace v8 {
 namespace internal {
 
 // Forward declaration.
 class Isolate;
 
-class Coverage : public AllStatic {
+struct CoverageRange {
+  CoverageRange(int s, int e, uint32_t c, Handle<String> n)
+      : start(s), end(e), count(c), name(n) {}
+  int start;
+  int end;
+  uint32_t count;
+  Handle<String> name;
+  std::vector<CoverageRange> inner;
+};
+
+struct CoverageScript {
+  // Initialize top-level function in case it has been garbage-collected.
+  CoverageScript(Isolate* isolate, Handle<Script> s, int source_length);
+  Handle<Script> script;
+  CoverageRange toplevel;
+};
+
+class Coverage : public std::vector<CoverageScript> {

[kozy, 2017/02/15 16:33:41]

I think that std::vector has non-virtual destructor. This code looks suspicious
to me.

[Yang, 2017/02/15 16:42:41]

I'm not using any polymorphism here. The destructor of std::vector should run
after debug::Coverage.

  public:
-  struct Range {
-    Range(int s, int e, uint32_t c) : start(s), end(e), count(c) {}
-    int start;
-    int end;
-    uint32_t count;
-    std::vector<uint16_t> name;
-    std::vector<Range> inner;
-  };
-
-  struct ScriptData {
-    // Initialize top-level function in case it has been garbage-collected.
-    ScriptData(Handle<Script> s, int source_length)
-        : script(s), toplevel(0, source_length, 1) {}
-    Handle<Script> script;
-    Range toplevel;
-  };
-
-  V8_EXPORT_PRIVATE static std::vector<ScriptData> Collect(Isolate* isolate);
+  // Allocate a new Coverage object and populate with result.
+  // The ownership is transferred to the caller.
+  static Coverage* Collect(Isolate* isolate);
 
   // Enable precise code coverage. This disables optimization and makes sure
   // invocation count is not affected by GC.
-  V8_EXPORT_PRIVATE static void EnablePrecise(Isolate* isolate);
-  V8_EXPORT_PRIVATE static void DisablePrecise(Isolate* isolate);
+  static void TogglePrecise(Isolate* isolate, bool enable);
+
+ private:
+  Coverage() {}
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_DEBUG_DEBUG_COVERAGE_H_