[debug] introduce precise binary code coverage.

src/inspector/v8-profiler-agent-impl.cc

 // Copyright 2015 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.
 
 #include "src/inspector/v8-profiler-agent-impl.h"
 
 #include <vector>
 
 #include "src/base/atomicops.h"
 #include "src/inspector/protocol/Protocol.h"
 #include "src/inspector/string-util.h"
 #include "src/inspector/v8-debugger.h"
 #include "src/inspector/v8-inspector-impl.h"
 #include "src/inspector/v8-inspector-session-impl.h"
 #include "src/inspector/v8-stack-trace-impl.h"
 
 #include "include/v8-profiler.h"
 
 namespace v8_inspector {
 
 namespace ProfilerAgentState {
 static const char samplingInterval[] = "samplingInterval";
 static const char userInitiatedProfiling[] = "userInitiatedProfiling";
 static const char profilerEnabled[] = "profilerEnabled";
 static const char preciseCoverageStarted[] = "preciseCoverageStarted";
+static const char preciseCoverageCallCount[] = "preciseCoverageCallCount";
 }
 
 namespace {
 
 std::unique_ptr<protocol::Array<protocol::Profiler::PositionTickInfo>>
 buildInspectorObjectForPositionTicks(const v8::CpuProfileNode* node) {
   unsigned lineCount = node->GetHitLineCount();
   if (!lineCount) return nullptr;
   auto array = protocol::Array<protocol::Profiler::PositionTickInfo>::create();
   std::vector<v8::CpuProfileNode::LineTick> entries(lineCount);
@@ skipping 196 matching lines @@
   if (!m_state->booleanProperty(ProfilerAgentState::profilerEnabled, false))
     return;
   m_enabled = true;
   DCHECK(!m_profiler);
   if (m_state->booleanProperty(ProfilerAgentState::userInitiatedProfiling,
                                false)) {
     start();
   }
   if (m_state->booleanProperty(ProfilerAgentState::preciseCoverageStarted,
                                false)) {
-    startPreciseCoverage();
+    bool callCount = m_state->booleanProperty(
+        ProfilerAgentState::preciseCoverageCallCount, false);
+    startPreciseCoverage(Maybe<bool>(callCount));
   }
 }
 
 Response V8ProfilerAgentImpl::start() {
   if (m_recordingCPUProfile) return Response::OK();
   if (!m_enabled) return Response::Error("Profiler is not enabled");
   m_recordingCPUProfile = true;
   m_frontendInitiatedProfileId = nextProfileId();
   startProfiling(m_frontendInitiatedProfileId);
   m_state->setBoolean(ProfilerAgentState::userInitiatedProfiling, true);
@@ skipping 10 matching lines @@
       stopProfiling(m_frontendInitiatedProfileId, !!profile);
   if (profile) {
     *profile = std::move(cpuProfile);
     if (!profile->get()) return Response::Error("Profile is not found");
   }
   m_frontendInitiatedProfileId = String16();
   m_state->setBoolean(ProfilerAgentState::userInitiatedProfiling, false);
   return Response::OK();
 }
 
-Response V8ProfilerAgentImpl::startPreciseCoverage() {
+Response V8ProfilerAgentImpl::startPreciseCoverage(Maybe<bool> callCount) {
   if (!m_enabled) return Response::Error("Profiler is not enabled");
+  bool callCountValue = callCount.fromMaybe(false);
   m_state->setBoolean(ProfilerAgentState::preciseCoverageStarted, true);
-  v8::debug::Coverage::SelectMode(m_isolate,
-                                  v8::debug::Coverage::kPreciseCount);
+  m_state->setBoolean(ProfilerAgentState::preciseCoverageCallCount,
+                      callCountValue);
+  v8::debug::Coverage::SelectMode(
+      m_isolate, callCountValue ? v8::debug::Coverage::kPreciseCount
+                                : v8::debug::Coverage::kPreciseBinary);
   return Response::OK();
 }
 
 Response V8ProfilerAgentImpl::stopPreciseCoverage() {
   if (!m_enabled) return Response::Error("Profiler is not enabled");
   m_state->setBoolean(ProfilerAgentState::preciseCoverageStarted, false);
+  m_state->setBoolean(ProfilerAgentState::preciseCoverageCallCount, false);
   v8::debug::Coverage::SelectMode(m_isolate, v8::debug::Coverage::kBestEffort);
   return Response::OK();
 }
 
 namespace {
-Response takeCoverage(
-    v8::Isolate* isolate, bool reset_count,
+Response coverageToProtocol(
+    v8::Isolate* isolate, const v8::debug::Coverage& coverage,
     std::unique_ptr<protocol::Array<protocol::Profiler::ScriptCoverage>>*
         out_result) {
   std::unique_ptr<protocol::Array<protocol::Profiler::ScriptCoverage>> result =
       protocol::Array<protocol::Profiler::ScriptCoverage>::create();
-  v8::HandleScope handle_scope(isolate);
-  v8::debug::Coverage coverage =
-      v8::debug::Coverage::Collect(isolate, reset_count);
   for (size_t i = 0; i < coverage.ScriptCount(); i++) {
     v8::debug::Coverage::ScriptData script_data = coverage.GetScriptData(i);
     v8::Local<v8::debug::Script> script = script_data.GetScript();
     std::unique_ptr<protocol::Array<protocol::Profiler::FunctionCoverage>>
         functions =
             protocol::Array<protocol::Profiler::FunctionCoverage>::create();
     for (size_t j = 0; j < script_data.FunctionCount(); j++) {
       v8::debug::Coverage::FunctionData function_data =
           script_data.GetFunctionData(j);
       std::unique_ptr<protocol::Array<protocol::Profiler::CoverageRange>>
@@ skipping 28 matching lines @@
 }
 }  // anonymous namespace
 
 Response V8ProfilerAgentImpl::takePreciseCoverage(
     std::unique_ptr<protocol::Array<protocol::Profiler::ScriptCoverage>>*
         out_result) {
   if (!m_state->booleanProperty(ProfilerAgentState::preciseCoverageStarted,
                                 false)) {
     return Response::Error("Precise coverage has not been started.");
   }
-  return takeCoverage(m_isolate, true, out_result);
+  v8::HandleScope handle_scope(m_isolate);
+  v8::debug::Coverage coverage = v8::debug::Coverage::CollectPrecise(m_isolate);
+  return coverageToProtocol(m_isolate, coverage, out_result);
 }
 
 Response V8ProfilerAgentImpl::getBestEffortCoverage(
     std::unique_ptr<protocol::Array<protocol::Profiler::ScriptCoverage>>*
         out_result) {
-  return takeCoverage(m_isolate, false, out_result);
+  v8::HandleScope handle_scope(m_isolate);
+  v8::debug::Coverage coverage =
+      v8::debug::Coverage::CollectBestEffort(m_isolate);
+  return coverageToProtocol(m_isolate, coverage, out_result);
 }
 
 String16 V8ProfilerAgentImpl::nextProfileId() {
   return String16::fromInteger(
       v8::base::NoBarrier_AtomicIncrement(&s_lastProfileId, 1));
 }
 
 void V8ProfilerAgentImpl::startProfiling(const String16& title) {
   v8::HandleScope handleScope(m_isolate);
   if (!m_startedProfilesCount) {
@@ skipping 32 matching lines @@
   return m_profiler;
 }
 
 bool V8ProfilerAgentImpl::idleFinished() {
   m_idle = false;
   if (m_profiler) m_profiler->SetIdle(m_idle);
   return m_profiler;
 }
 
 }  // namespace v8_inspector