[inspector] added Debugger.getPossibleBreakpoints method

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 52 matching lines @@
     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();
 }
 
 V8DebuggerScript::V8DebuggerScript(v8::Isolate* isolate,
                                    v8::Local<v8::DebugInterface::Script> script,
                                    bool isLiveEdit) {
+  m_isolate = script->GetIsolate();
   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();
@@ skipping 23 matching lines @@
       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);
     }
   }
 
   m_isLiveEdit = isLiveEdit;
+
   if (script->Source().ToLocal(&tmp)) {
-    m_source.Reset(isolate, tmp);
+    m_source.Reset(m_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;
     }
   }
+
+  m_script.Reset(m_isolate, script);
 }
 
 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);
+void V8DebuggerScript::setSource(v8::Local<v8::String> source) {
+  m_source.Reset(m_isolate, source);
   m_hash = calculateHash(toProtocolString(source));
 }
 
+bool V8DebuggerScript::getPossibleBreakpoints(
+    const v8::DebugInterface::Script::Location& start,
+    const v8::DebugInterface::Script::Location& end,
+    std::vector<v8::DebugInterface::Script::Location>* locations) {
+  v8::HandleScope scope(m_isolate);
+  v8::Local<v8::DebugInterface::Script> script = m_script.Get(m_isolate);
+  return script->GetPossibleBreakpoints(start, end, locations);
+}
+
 }  // namespace v8_inspector