[inspector] move coverage related methods to profiler

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

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 34 matching lines @@
 #include "src/tracing/trace-event.h"
 
 #include "include/v8-inspector.h"
 
 namespace v8_inspector {
 
 namespace V8RuntimeAgentImplState {
 static const char customObjectFormatterEnabled[] =
     "customObjectFormatterEnabled";
 static const char runtimeEnabled[] = "runtimeEnabled";
-static const char preciseCoverageStarted[] = "preciseCoverageStarted";
 };
 
 using protocol::Runtime::RemoteObject;
 
 namespace {
 
 template <typename Callback>
 class ProtocolPromiseHandler {
  public:
   static void add(V8InspectorImpl* inspector, v8::Local<v8::Context> context,
@@ skipping 574 matching lines @@
   }
   ProtocolPromiseHandler<RunScriptCallback>::add(
       m_inspector, scope.context(), maybeResultValue.ToLocalChecked(),
       "Result of the script execution is not a promise",
       m_session->contextGroupId(),
       scope.injectedScript()->context()->contextId(), objectGroup.fromMaybe(""),
       returnByValue.fromMaybe(false), generatePreview.fromMaybe(false),
       std::move(callback));
 }
 
-Response V8RuntimeAgentImpl::startPreciseCoverage() {
-  m_state->setBoolean(V8RuntimeAgentImplState::preciseCoverageStarted, true);
-  v8::debug::Coverage::TogglePrecise(m_inspector->isolate(), true);
-  return Response::OK();
-}
-
-Response V8RuntimeAgentImpl::stopPreciseCoverage() {
-  m_state->setBoolean(V8RuntimeAgentImplState::preciseCoverageStarted, false);
-  v8::debug::Coverage::TogglePrecise(m_inspector->isolate(), false);
-  return Response::OK();
-}
-
-namespace {
-Response takeCoverage(
-    v8::Isolate* isolate, bool reset_count,
-    std::unique_ptr<protocol::Array<protocol::Runtime::ScriptCoverage>>*
-        out_result) {
-  std::unique_ptr<protocol::Array<protocol::Runtime::ScriptCoverage>> result =
-      protocol::Array<protocol::Runtime::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::Runtime::FunctionCoverage>>
-        functions =
-            protocol::Array<protocol::Runtime::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::Runtime::CoverageRange>>
-          ranges = protocol::Array<protocol::Runtime::CoverageRange>::create();
-      // At this point we only have per-function coverage data, so there is
-      // only one range per function.
-      ranges->addItem(
-          protocol::Runtime::CoverageRange::create()
-              .setStartLineNumber(function_data.Start().GetLineNumber())
-              .setStartColumnNumber(function_data.Start().GetColumnNumber())
-              .setEndLineNumber(function_data.End().GetLineNumber())
-              .setEndColumnNumber(function_data.End().GetColumnNumber())
-              .setCount(function_data.Count())
-              .build());
-      functions->addItem(
-          protocol::Runtime::FunctionCoverage::create()
-              .setFunctionName(toProtocolString(
-                  function_data.Name().FromMaybe(v8::Local<v8::String>())))
-              .setRanges(std::move(ranges))
-              .build());
-    }
-    String16 url;
-    v8::Local<v8::String> name;
-    if (script->Name().ToLocal(&name) || script->SourceURL().ToLocal(&name)) {
-      url = toProtocolString(name);
-    }
-    result->addItem(protocol::Runtime::ScriptCoverage::create()
-                        .setScriptId(String16::fromInteger(script->Id()))
-                        .setUrl(url)
-                        .setFunctions(std::move(functions))
-                        .build());
-  }
-  *out_result = std::move(result);
-  return Response::OK();
-}
-}  // anonymous namespace
-
-Response V8RuntimeAgentImpl::takePreciseCoverage(
-    std::unique_ptr<protocol::Array<protocol::Runtime::ScriptCoverage>>*
-        out_result) {
-  if (!m_state->booleanProperty(V8RuntimeAgentImplState::preciseCoverageStarted,
-                                false)) {
-    return Response::Error("Precise coverage has not been started.");
-  }
-  return takeCoverage(m_inspector->isolate(), true, out_result);
-}
-
-Response V8RuntimeAgentImpl::getBestEffortCoverage(
-    std::unique_ptr<protocol::Array<protocol::Runtime::ScriptCoverage>>*
-        out_result) {
-  return takeCoverage(m_inspector->isolate(), false, out_result);
-}
-
 void V8RuntimeAgentImpl::restore() {
   if (!m_state->booleanProperty(V8RuntimeAgentImplState::runtimeEnabled, false))
     return;
   m_frontend.executionContextsCleared();
   enable();
   if (m_state->booleanProperty(
           V8RuntimeAgentImplState::customObjectFormatterEnabled, false))
     m_session->setCustomObjectFormatterEnabled(true);
-  if (m_state->booleanProperty(V8RuntimeAgentImplState::preciseCoverageStarted,
-                               false))
-    startPreciseCoverage();
 }
 
 Response V8RuntimeAgentImpl::enable() {
   if (m_enabled) return Response::OK();
   m_inspector->client()->beginEnsureAllContextsInGroup(
       m_session->contextGroupId());
   m_enabled = true;
   m_state->setBoolean(V8RuntimeAgentImplState::runtimeEnabled, true);
   m_inspector->enableStackCapturingIfNeeded();
   m_session->reportAllContexts(this);
   V8ConsoleMessageStorage* storage =
       m_inspector->ensureConsoleMessageStorage(m_session->contextGroupId());
   for (const auto& message : storage->messages()) {
     if (!reportMessage(message.get(), false)) break;
   }
   return Response::OK();
 }
 
 Response V8RuntimeAgentImpl::disable() {
   if (!m_enabled) return Response::OK();
   m_enabled = false;
   m_state->setBoolean(V8RuntimeAgentImplState::runtimeEnabled, false);
   m_inspector->disableStackCapturingIfNeeded();
   m_session->discardInjectedScripts();
   reset();
   m_inspector->client()->endEnsureAllContextsInGroup(
       m_session->contextGroupId());
-  stopPreciseCoverage();
   return Response::OK();
 }
 
 void V8RuntimeAgentImpl::reset() {
   m_compiledScripts.clear();
   if (m_enabled) {
     if (const V8InspectorImpl::ContextByIdMap* contexts =
             m_inspector->contextGroup(m_session->contextGroupId())) {
       for (auto& idContext : *contexts) idContext.second->setReported(false);
     }
@@ skipping 37 matching lines @@
 }
 
 bool V8RuntimeAgentImpl::reportMessage(V8ConsoleMessage* message,
                                        bool generatePreview) {
   message->reportToFrontend(&m_frontend, m_session, generatePreview);
   m_frontend.flush();
   return m_inspector->hasConsoleMessageStorage(m_session->contextGroupId());
 }
 
 }  // namespace v8_inspector