[inspector] restore provisional breakpoints smarter

src/inspector/v8-debugger-script.cc

 // Copyright 2014 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-debugger-script.h"
 
 #include "src/inspector/inspected-context.h"
+#include "src/inspector/search-util.h"
 #include "src/inspector/string-util.h"
 #include "src/inspector/wasm-translation.h"
 
 namespace v8_inspector {
 
 namespace {
 
 const char hexDigits[17] = "0123456789ABCDEF";
 
 void appendUnsignedAsHex(uint64_t number, String16Builder* destination) {
@@ skipping 129 matching lines @@
     m_script.Reset(m_isolate, script);
   }
 
   bool isLiveEdit() const override { return m_isLiveEdit; }
   bool isModule() const override { return m_isModule; }
 
   const String16& sourceMappingURL() const override {
     return m_sourceMappingURL;
   }
 
-  String16 source(v8::Isolate* isolate) const override {
+  String16 source() const override {
+    v8::HandleScope scope(m_isolate);
     if (!m_sourceObj.IsEmpty())
-      return toProtocolString(m_sourceObj.Get(isolate));
-    return V8DebuggerScript::source(isolate);
+      return toProtocolString(m_sourceObj.Get(m_isolate));
+    return V8DebuggerScript::source();
   }
 
   void setSourceMappingURL(const String16& sourceMappingURL) override {
     m_sourceMappingURL = sourceMappingURL;
   }
 
   void setSource(v8::Local<v8::String> source) override {
-    m_source = String16();
+    m_lineEndings.reset();
     m_sourceObj.Reset(m_isolate, source);
     m_hash = String16();
   }
 
   bool getPossibleBreakpoints(
       const v8::debug::Location& start, const v8::debug::Location& end,
       std::vector<v8::debug::Location>* locations) override {
     v8::HandleScope scope(m_isolate);
     v8::Local<v8::debug::Script> script = m_script.Get(m_isolate);
     return script->GetPossibleBreakpoints(start, end, locations);
@@ skipping 82 matching lines @@
  private:
   static const String16& emptyString() {
     static const String16 singleEmptyString;
     return singleEmptyString;
   }
 
   v8::Global<v8::debug::WasmScript> m_script;
   WasmTranslation* m_wasmTranslation;
 };
 
+std::unique_ptr<std::vector<size_t>> lineEndings(const String16& text) {
+  std::unique_ptr<std::vector<size_t>> result(new std::vector<size_t>());
+
+  const String16 lineEndString = "\n";
+  size_t start = 0;
+  while (start < text.length()) {
+    size_t lineEnd = text.find(lineEndString, start);
+    if (lineEnd == String16::kNotFound) break;
+
+    result->push_back(lineEnd);
+    start = lineEnd + 1;
+  }
+  result->push_back(text.length());
+
+  return result;
+}
+
 }  // namespace
 
 std::unique_ptr<V8DebuggerScript> V8DebuggerScript::Create(
     v8::Isolate* isolate, v8::Local<v8::debug::Script> scriptObj,
     bool isLiveEdit) {
   return std::unique_ptr<ActualScript>(
       new ActualScript(isolate, scriptObj, isLiveEdit));
 }
 
 std::unique_ptr<V8DebuggerScript> V8DebuggerScript::CreateWasm(
     v8::Isolate* isolate, WasmTranslation* wasmTranslation,
     v8::Local<v8::debug::WasmScript> underlyingScript, String16 id,
     String16 url, String16 source) {
   return std::unique_ptr<WasmVirtualScript>(
       new WasmVirtualScript(isolate, wasmTranslation, underlyingScript,
                             std::move(id), std::move(url), std::move(source)));
 }
 
 V8DebuggerScript::V8DebuggerScript(v8::Isolate* isolate, String16 id,
                                    String16 url)
     : m_id(std::move(id)), m_url(std::move(url)), m_isolate(isolate) {}
 
 V8DebuggerScript::~V8DebuggerScript() {}
 
 const String16& V8DebuggerScript::sourceURL() const {
   return m_sourceURL.isEmpty() ? m_url : m_sourceURL;
 }
 
-const String16& V8DebuggerScript::hash(v8::Isolate* isolate) const {
-  if (m_hash.isEmpty()) m_hash = calculateHash(source(isolate));
+const String16& V8DebuggerScript::hash() const {
+  if (m_hash.isEmpty()) m_hash = calculateHash(source());
   DCHECK(!m_hash.isEmpty());
   return m_hash;
 }
 
 void V8DebuggerScript::setSourceURL(const String16& sourceURL) {
   m_sourceURL = sourceURL;
 }
 
+String16 V8DebuggerScript::lineAt(int lineNumberWithOffset, int maxLength) {
+  String16 sourceStr = source();
+  if (!m_lineEndings) m_lineEndings = lineEndings(sourceStr);

[pfeldman, 2017/02/07 19:13:05]

That's O(N) which hurts us on the 20Mb scripts.

[kozy, 2017/02/08 01:32:56]

V8 couldn't avoid this calculation since it uses lineNumber and columnNumber as
breakpoint location. We can reuse LineEnds from internal script object - done.
Maybe in general we'd like to operate with offsets as long as possible and
convert them right after receiving protocol request or before sending protocol
notification. Currently this conversion happens on boundary between V8 and
inspector.

+  int lineNumber = lineNumberWithOffset - m_startLine;
+  if (lineNumber >= static_cast<int>(m_lineEndings->size()) || lineNumber < 0)
+    return String16();
+  size_t lineEnd = m_lineEndings->at(lineNumber);
+  size_t lineStart = lineNumber > 0 ? m_lineEndings->at(lineNumber - 1) + 1 : 0;
+  String16 line = sourceStr.substring(lineStart, lineEnd - lineStart);
+  if (line.length() && line[line.length() - 1] == '\r')
+    line = line.substring(0, line.length() - 1);
+  if (maxLength) line = line.substring(0, maxLength);
+  return line;
+}
+
 }  // namespace v8_inspector