[inspector] added type of break location into getPossibleBreakpoints output

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/string-util.h"
 #include "src/inspector/wasm-translation.h"
 
@@ skipping 137 matching lines @@
     return m_sourceMappingURL;
   }
 
   void setSourceMappingURL(const String16& sourceMappingURL) override {
     m_sourceMappingURL = sourceMappingURL;
   }
 
   bool getPossibleBreakpoints(
       const v8::debug::Location& start, const v8::debug::Location& end,
       bool restrictToFunction,
-      std::vector<v8::debug::Location>* locations) override {
+      std::vector<v8::debug::BreakLocation>* locations) override {
     v8::HandleScope scope(m_isolate);
     v8::Local<v8::debug::Script> script = m_script.Get(m_isolate);
-    return script->GetPossibleBreakpoints(start, end, restrictToFunction,
-                                          locations);
+    std::vector<v8::debug::BreakLocation> allLocations;
+    if (!script->GetPossibleBreakpoints(start, end, restrictToFunction,
+                                        &allLocations)) {
+      return false;
+    }
+    if (!allLocations.size()) return true;
+    v8::debug::BreakLocation current = allLocations[0];
+    for (size_t i = 1; i < allLocations.size(); ++i) {
+      if (allLocations[i].GetLineNumber() == current.GetLineNumber() &&
+          allLocations[i].GetColumnNumber() == current.GetColumnNumber()) {
+        if (allLocations[i].type() != v8::debug::kCommonBreakLocation) {
+          DCHECK(allLocations[i].type() == v8::debug::kCallBreakLocation ||
+                 allLocations[i].type() == v8::debug::kReturnBreakLocation);
+          // debugger can returns more then one break location at the same
+          // source location, e.g. foo() - in this case there are two break
+          // locations before foo: for statement and for function call, we can
+          // merge them for inspector and report only one with call type.
+          current = allLocations[i];
+        }
+      } else {
+        // we assume that returned break locations are sorted.
+        DCHECK(
+            allLocations[i].GetLineNumber() > current.GetLineNumber() ||
+            (allLocations[i].GetColumnNumber() >= current.GetColumnNumber() &&
+             allLocations[i].GetLineNumber() == current.GetLineNumber()));
+        locations->push_back(current);
+        current = allLocations[i];
+      }
+    }
+    locations->push_back(current);
+    return true;
   }
 
   void resetBlackboxedStateCache() override {
     v8::HandleScope scope(m_isolate);
     v8::debug::ResetBlackboxedStateCache(m_isolate, m_script.Get(m_isolate));
   }
 
   int offset(int lineNumber, int columnNumber) const override {
     v8::HandleScope scope(m_isolate);
     return m_script.Get(m_isolate)->GetSourceOffset(
@@ skipping 43 matching lines @@
   }
 
   const String16& sourceMappingURL() const override { return emptyString(); }
   bool isLiveEdit() const override { return false; }
   bool isModule() const override { return false; }
   void setSourceMappingURL(const String16&) override {}
 
   bool getPossibleBreakpoints(
       const v8::debug::Location& start, const v8::debug::Location& end,
       bool restrictToFunction,
-      std::vector<v8::debug::Location>* locations) override {
+      std::vector<v8::debug::BreakLocation>* locations) override {
     v8::HandleScope scope(m_isolate);
     v8::Local<v8::debug::Script> script = m_script.Get(m_isolate);
     String16 v8ScriptId = String16::fromInteger(script->Id());
 
     v8::debug::Location translatedStart = start;
     TranslateProtocolLocationToV8Location(m_wasmTranslation, &translatedStart,
                                           scriptId(), v8ScriptId);
 
     v8::debug::Location translatedEnd = end;
     if (translatedEnd.IsEmpty()) {
       // Stop before the start of the next function.
       translatedEnd =
           v8::debug::Location(translatedStart.GetLineNumber() + 1, 0);
     } else {
       TranslateProtocolLocationToV8Location(m_wasmTranslation, &translatedEnd,
                                             scriptId(), v8ScriptId);
     }
 
     bool success = script->GetPossibleBreakpoints(
         translatedStart, translatedEnd, restrictToFunction, locations);
-    for (v8::debug::Location& loc : *locations) {
+    for (v8::debug::BreakLocation& loc : *locations) {
       TranslateV8LocationToProtocolLocation(m_wasmTranslation, &loc, v8ScriptId,
                                             scriptId());
     }
     return success;
   }
 
   void resetBlackboxedStateCache() override {}
 
   int offset(int lineNumber, int columnNumber) const override {
     return kNoOffset;
@@ skipping 45 matching lines @@
   if (m_hash.isEmpty()) m_hash = calculateHash(source());
   DCHECK(!m_hash.isEmpty());
   return m_hash;
 }
 
 void V8DebuggerScript::setSourceURL(const String16& sourceURL) {
   m_sourceURL = sourceURL;
 }
 
 }  // namespace v8_inspector