[inspector] added type of break location into getPossibleBreakpoints output

src/api.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/api.h"
 
 #include <string.h>  // For memcpy, strlen.
 #ifdef V8_USE_ADDRESS_SANITIZER
 #include <sanitizer/asan_interface.h>
 #endif  // V8_USE_ADDRESS_SANITIZER
@@ skipping 9197 matching lines @@
 }
 
 namespace {
 int GetSmiValue(i::Handle<i::FixedArray> array, int index) {
   return i::Smi::cast(array->get(index))->value();
 }
 }  // namespace
 
 bool debug::Script::GetPossibleBreakpoints(
     const debug::Location& start, const debug::Location& end,
-    bool restrict_to_function, std::vector<debug::Location>* locations) const {
+    bool restrict_to_function,
+    std::vector<debug::BreakLocation>* locations) const {
   CHECK(!start.IsEmpty());
   i::Handle<i::Script> script = Utils::OpenHandle(this);
   if (script->type() == i::Script::TYPE_WASM) {
     i::Handle<i::WasmCompiledModule> compiled_module(
         i::WasmCompiledModule::cast(script->wasm_compiled_module()));
     return compiled_module->GetPossibleBreakpoints(start, end, locations);
   }
 
   i::Script::InitLineEnds(script);
   CHECK(script->line_ends()->IsFixedArray());
   i::Isolate* isolate = script->GetIsolate();
   i::Handle<i::FixedArray> line_ends =
       i::Handle<i::FixedArray>::cast(i::handle(script->line_ends(), isolate));
   CHECK(line_ends->length());
 
   int start_offset = GetSourceOffset(start);
   int end_offset = end.IsEmpty()
                        ? GetSmiValue(line_ends, line_ends->length() - 1) + 1
                        : GetSourceOffset(end);
   if (start_offset >= end_offset) return true;
 
-  std::set<int> offsets;
+  std::vector<i::BreakLocation> v8_locations;
   if (!isolate->debug()->GetPossibleBreakpoints(
-          script, start_offset, end_offset, restrict_to_function, &offsets)) {
+          script, start_offset, end_offset, restrict_to_function,
+          &v8_locations)) {
     return false;
   }
 
+  std::map<int, i::BreakLocation> unique_locations;
+  for (const auto& location : v8_locations) {

[dgozman, 2017/03/03 18:55:56]

I agree with Yang that we should move this to inspector code and let
debug-interface expose all break locations available.

[kozy, 2017/03/03 22:44:14]

Done.

+    auto it = unique_locations.find(location.position());
+    if (it == unique_locations.end()) {
+      unique_locations.insert(std::make_pair(location.position(), location));
+    } else if (it->second.type() == debug::kCommonBreakLocation &&
+               location.type() != debug::kCommonBreakLocation) {
+      // 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.
+      DCHECK(location.IsCall());
+      it->second = location;
+    }
+  }
   int current_line_end_index = 0;
-  for (const auto& it : offsets) {
-    int offset = it;
+  for (const auto& it : unique_locations) {
+    int offset = it.first;
     while (offset > GetSmiValue(line_ends, current_line_end_index)) {
       ++current_line_end_index;
       CHECK(current_line_end_index < line_ends->length());
     }
     int line_offset = 0;
 
     if (current_line_end_index > 0) {
       line_offset = GetSmiValue(line_ends, current_line_end_index - 1) + 1;
     }
-    locations->push_back(debug::Location(
+    locations->emplace_back(
         current_line_end_index + script->line_offset(),
         offset - line_offset +
-            (current_line_end_index == 0 ? script->column_offset() : 0)));
+            (current_line_end_index == 0 ? script->column_offset() : 0),
+        it.second.type());
   }
   return true;
 }
 
 int debug::Script::GetSourceOffset(const debug::Location& location) const {
   i::Handle<i::Script> script = Utils::OpenHandle(this);
   if (script->type() == i::Script::TYPE_WASM) {
     // TODO(clemensh): Return the proper thing for wasm.
     return 0;
   }
@@ skipping 975 matching lines @@
   Address callback_address =
       reinterpret_cast<Address>(reinterpret_cast<intptr_t>(callback));
   VMState<EXTERNAL> state(isolate);
   ExternalCallbackScope call_scope(isolate, callback_address);
   callback(info);
 }
 
 
 }  // namespace internal
 }  // namespace v8