[inspector] migrate scriptParsed and getCompiledScripts to native

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/protocol-platform.h"
 #include "src/inspector/string-util.h"
 
 namespace v8_inspector {
@@ skipping 49 matching lines @@
   }
 
   for (size_t i = 0; i < hashesSize; ++i)
     hashes[i] = (hashes[i] + zi[i] * (prime[i] - 1)) % prime[i];
 
   String16Builder hash;
   for (size_t i = 0; i < hashesSize; ++i) appendUnsignedAsHex(hashes[i], &hash);
   return hash.toString();
 }
 
-static v8::Local<v8::Value> GetChecked(v8::Local<v8::Context> context,
-                                       v8::Local<v8::Object> object,
-                                       const char* name) {
-  return object
-      ->Get(context, toV8StringInternalized(context->GetIsolate(), name))
-      .ToLocalChecked();
-}
+V8DebuggerScript::V8DebuggerScript(v8::Isolate* isolate,
+                                   v8::Local<v8::DebugInterface::Script> script,
+                                   bool isLiveEdit) {
+  m_id = String16::fromInteger(script->Id());
+  v8::Local<v8::String> tmp;
+  if (script->Name().ToLocal(&tmp)) m_url = toProtocolString(tmp);
+  if (script->SourceURL().ToLocal(&tmp)) {
+    m_sourceURL = toProtocolString(tmp);
+    if (m_url.isEmpty()) m_url = toProtocolString(tmp);
+  }
+  if (script->SourceMappingURL().ToLocal(&tmp))
+    m_sourceMappingURL = toProtocolString(tmp);
+  m_startLine = script->LineOffset();
+  m_startColumn = script->ColumnOffset();
+  std::vector<int> lineEnds = script->LineEnds();
+  CHECK(lineEnds.size());
+  int source_length = lineEnds[lineEnds.size() - 1];
+  if (lineEnds.size()) {
+    m_endLine = static_cast<int>(lineEnds.size()) + m_startLine - 1;
+    if (lineEnds.size() > 1) {
+      m_endColumn = source_length - lineEnds[lineEnds.size() - 2] - 1;
+    } else {
+      m_endColumn = source_length + m_startColumn;
+    }
+  } else {

[jgruber, 2016/11/02 08:39:07]

Sorry for the late comment; I've been reading a couple of older CLs on the
train, hope you don't mind. 

Isn't this dead code since you CHECK(lineEnds.size()) above? Also, we could pass
the vector around with move semantics instead of copying it.

[kozy, 2016/11/03 00:18:36]

Yes, it's dead code, thanks!
For vector - I think that copy elision optimization will help to avoid
additional copying.

+    m_endLine = m_startLine;
+    m_endColumn = m_startColumn;
+  }
 
-static int GetCheckedInt(v8::Local<v8::Context> context,
-                         v8::Local<v8::Object> object, const char* name) {
-  return static_cast<int>(GetChecked(context, object, name)
-                              ->ToInteger(context)
-                              .ToLocalChecked()
-                              ->Value());
-}
+  if (script->ContextData().ToLocal(&tmp)) {
+    String16 contextData = toProtocolString(tmp);
+    size_t firstComma = contextData.find(",", 0);
+    size_t secondComma = firstComma != String16::kNotFound
+                             ? contextData.find(",", firstComma + 1)
+                             : String16::kNotFound;
+    if (secondComma != String16::kNotFound) {
+      String16 executionContextId =
+          contextData.substring(firstComma + 1, secondComma - firstComma - 1);
+      bool isOk = false;
+      m_executionContextId = executionContextId.toInteger(&isOk);
+      if (!isOk) m_executionContextId = 0;
+      m_executionContextAuxData = contextData.substring(secondComma + 1);
+    }
+  }
 
-V8DebuggerScript::V8DebuggerScript(v8::Local<v8::Context> context,
-                                   v8::Local<v8::Object> object,
-                                   bool isLiveEdit) {
-  v8::Isolate* isolate = context->GetIsolate();
-  v8::Local<v8::Value> idValue = GetChecked(context, object, "id");
-  DCHECK(!idValue.IsEmpty() && idValue->IsInt32());
-  m_id = String16::fromInteger(idValue->Int32Value(context).FromJust());
-
-  m_url = toProtocolStringWithTypeCheck(GetChecked(context, object, "name"));
-  m_sourceURL =
-      toProtocolStringWithTypeCheck(GetChecked(context, object, "sourceURL"));
-  m_sourceMappingURL = toProtocolStringWithTypeCheck(
-      GetChecked(context, object, "sourceMappingURL"));
-  m_startLine = GetCheckedInt(context, object, "startLine");
-  m_startColumn = GetCheckedInt(context, object, "startColumn");
-  m_endLine = GetCheckedInt(context, object, "endLine");
-  m_endColumn = GetCheckedInt(context, object, "endColumn");
-  m_executionContextAuxData = toProtocolStringWithTypeCheck(
-      GetChecked(context, object, "executionContextAuxData"));
-  m_executionContextId = GetCheckedInt(context, object, "executionContextId");
   m_isLiveEdit = isLiveEdit;
-
-  v8::Local<v8::Value> sourceValue;
-  if (!object->Get(context, toV8StringInternalized(isolate, "source"))
-           .ToLocal(&sourceValue) ||
-      !sourceValue->IsString())
-    return;
-  setSource(isolate, sourceValue.As<v8::String>());
+  if (script->Source().ToLocal(&tmp)) {
+    m_source.Reset(isolate, tmp);
+    String16 source = toProtocolString(tmp);
+    m_hash = calculateHash(source);
+    // V8 will not count last line if script source ends with \n.
+    if (source.length() > 1 && source[source.length() - 1] == '\n') {
+      m_endLine++;
+      m_endColumn = 0;
+    }
+  }
 }
 
 V8DebuggerScript::~V8DebuggerScript() {}
 
 const String16& V8DebuggerScript::sourceURL() const {
   return m_sourceURL.isEmpty() ? m_url : m_sourceURL;
 }
 
 v8::Local<v8::String> V8DebuggerScript::source(v8::Isolate* isolate) const {
   return m_source.Get(isolate);
 }
 
 void V8DebuggerScript::setSourceURL(const String16& sourceURL) {
   m_sourceURL = sourceURL;
 }
 
 void V8DebuggerScript::setSourceMappingURL(const String16& sourceMappingURL) {
   m_sourceMappingURL = sourceMappingURL;
 }
 
 void V8DebuggerScript::setSource(v8::Isolate* isolate,
                                  v8::Local<v8::String> source) {
   m_source.Reset(isolate, source);
   m_hash = calculateHash(toProtocolString(source));
 }
 
 }  // namespace v8_inspector