[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 142 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);
   }
 
   void resetBlackboxedStateCache() override {
     v8::HandleScope scope(m_isolate);
     v8::debug::ResetBlackboxedStateCache(m_isolate, m_script.Get(m_isolate));
   }
@@ skipping 47 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