[inspector] added type of break location into getPossibleBreakpoints output

src/debug/debug.cc

 // Copyright 2012 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/debug/debug.h"
 
 #include <memory>
 
 #include "src/api.h"
 #include "src/arguments.h"
@@ skipping 107 matching lines @@
     it.SkipToPosition(position_, BREAK_POSITION_ALIGNED);
     return it.code_offset() == code_offset_;
   } else {
     DCHECK(abstract_code_->IsBytecodeArray());
     BytecodeArrayBreakIterator it(debug_info);
     it.SkipToPosition(position_, BREAK_POSITION_ALIGNED);
     return it.code_offset() == code_offset_;
   }
 }
 
+debug::BreakLocationType BreakLocation::type() const {
+  switch (type_) {
+    case DEBUGGER_STATEMENT:
+      return debug::kDebuggerStatementBreakLocation;
+    case DEBUG_BREAK_SLOT_AT_CALL:
+      return debug::kCallBreakLocation;
+    case DEBUG_BREAK_SLOT_AT_RETURN:
+      return debug::kReturnBreakLocation;
+    default:
+      return debug::kCommonBreakLocation;
+  }
+  return debug::kCommonBreakLocation;
+}
+
 std::unique_ptr<BreakIterator> BreakIterator::GetIterator(
     Handle<DebugInfo> debug_info, Handle<AbstractCode> abstract_code) {
   if (abstract_code->IsBytecodeArray()) {
     DCHECK(debug_info->HasDebugBytecodeArray());
     return std::unique_ptr<BreakIterator>(
         new BytecodeArrayBreakIterator(debug_info));
   } else {
     DCHECK(abstract_code->IsCode());
     DCHECK(debug_info->HasDebugCode());
     return std::unique_ptr<BreakIterator>(new CodeBreakIterator(debug_info));
@@ skipping 1170 matching lines @@
   RedirectActiveFunctions redirect_visitor(*shared);
   redirect_visitor.VisitThread(isolate_, isolate_->thread_local_top());
   isolate_->thread_manager()->IterateArchivedThreads(&redirect_visitor);
 
   return true;
 }
 
 namespace {
 template <typename Iterator>
 void GetBreakablePositions(Iterator* it, int start_position, int end_position,
-                           BreakPositionAlignment alignment,
-                           std::set<int>* positions) {
-  it->SkipToPosition(start_position, alignment);
+                           std::vector<BreakLocation>* locations) {
+  it->SkipToPosition(start_position, BREAK_POSITION_ALIGNED);
   while (!it->Done() && it->position() < end_position &&
          it->position() >= start_position) {
-    positions->insert(alignment == STATEMENT_ALIGNED ? it->statement_position()
-                                                     : it->position());
+    locations->push_back(it->GetBreakLocation());
     it->Next();
   }
 }
 
 void FindBreakablePositions(Handle<DebugInfo> debug_info, int start_position,
-                            int end_position, BreakPositionAlignment alignment,
-                            std::set<int>* positions) {
+                            int end_position,
+                            std::vector<BreakLocation>* locations) {
   if (debug_info->HasDebugCode()) {
     CodeBreakIterator it(debug_info);
-    GetBreakablePositions(&it, start_position, end_position, alignment,
-                          positions);
+    GetBreakablePositions(&it, start_position, end_position, locations);
   } else {
     DCHECK(debug_info->HasDebugBytecodeArray());
     BytecodeArrayBreakIterator it(debug_info);
-    GetBreakablePositions(&it, start_position, end_position, alignment,
-                          positions);
+    GetBreakablePositions(&it, start_position, end_position, locations);
   }
 }
 }  // namespace
 
 bool Debug::GetPossibleBreakpoints(Handle<Script> script, int start_position,
                                    int end_position, bool restrict_to_function,
-                                   std::set<int>* positions) {
+                                   std::vector<BreakLocation>* locations) {
   if (restrict_to_function) {
     Handle<Object> result =
         FindSharedFunctionInfoInScript(script, start_position);
     if (result->IsUndefined(isolate_)) return false;
 
     // Make sure the function has set up the debug info.
     Handle<SharedFunctionInfo> shared =
         Handle<SharedFunctionInfo>::cast(result);
     if (!EnsureDebugInfo(shared)) return false;
 
     Handle<DebugInfo> debug_info(shared->GetDebugInfo());
-    FindBreakablePositions(debug_info, start_position, end_position,
-                           BREAK_POSITION_ALIGNED, positions);
+    FindBreakablePositions(debug_info, start_position, end_position, locations);
     return true;
   }
 
   while (true) {
     HandleScope scope(isolate_);
     List<Handle<SharedFunctionInfo>> candidates;
     SharedFunctionInfo::ScriptIterator iterator(script);
     for (SharedFunctionInfo* info = iterator.Next(); info != nullptr;
          info = iterator.Next()) {
       if (info->end_position() < start_position ||
@@ skipping 17 matching lines @@
         }
       }
       if (!EnsureDebugInfo(candidates[i])) return false;
     }
     if (was_compiled) continue;
 
     for (int i = 0; i < candidates.length(); ++i) {
       CHECK(candidates[i]->HasDebugInfo());
       Handle<DebugInfo> debug_info(candidates[i]->GetDebugInfo());
       FindBreakablePositions(debug_info, start_position, end_position,
-                             BREAK_POSITION_ALIGNED, positions);
+                             locations);
     }
     return true;
   }
   UNREACHABLE();
   return false;
 }
 
 void Debug::RecordGenerator(Handle<JSGeneratorObject> generator_object) {
   if (last_step_action() <= StepOut) return;
 
@@ skipping 1017 matching lines @@
     isolate_->Throw(*isolate_->factory()->NewEvalError(
         MessageTemplate::kNoSideEffectDebugEvaluate));
   }
   isolate_->set_needs_side_effect_check(old_needs_side_effect_check_);
   isolate_->debug()->UpdateHookOnFunctionCall();
   isolate_->debug()->side_effect_check_failed_ = false;
 }
 
 }  // namespace internal
 }  // namespace v8