[inspector] added Debugger.getPossibleBreakpoints method

test/inspector/task-runner.cc

 // Copyright 2016 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 "test/inspector/task-runner.h"
 
 #if !defined(_WIN32) && !defined(_WIN64)
 #include <unistd.h>  // NOLINT
 #endif               // !defined(_WIN32) && !defined(_WIN64)
 
@@ skipping 105 matching lines @@
     process_queue_semaphore_.Wait();
   }
   return nullptr;
 }
 
 TaskRunner* TaskRunner::FromContext(v8::Local<v8::Context> context) {
   return static_cast<TaskRunner*>(
       context->GetAlignedPointerFromEmbedderData(kTaskRunnerIndex));
 }
 
+namespace {
+
+v8::internal::Vector<uint16_t> ToVector(v8::Local<v8::String> str) {
+  v8::internal::Vector<uint16_t> buffer =
+      v8::internal::Vector<uint16_t>::New(str->Length());
+  str->Write(buffer.start(), 0, str->Length());
+  return buffer;
+}
+
+}  // namespace
+
 ExecuteStringTask::ExecuteStringTask(
-    const v8::internal::Vector<uint16_t>& expression)
-    : expression_(expression) {}
+    const v8::internal::Vector<uint16_t>& expression,
+    v8::Local<v8::String> name, v8::Local<v8::Integer> line_offset,
+    v8::Local<v8::Integer> column_offset)
+    : expression_(expression),
+      name_(ToVector(name)),
+      line_offset_(line_offset.As<v8::Int32>()->Value()),
+      column_offset_(column_offset.As<v8::Int32>()->Value()) {}
 
 ExecuteStringTask::ExecuteStringTask(
     const v8::internal::Vector<const char>& expression)
-    : expression_utf8_(expression) {}
+    : expression_utf8_(expression), line_offset_(0), column_offset_(0) {}
 
 void ExecuteStringTask::Run(v8::Isolate* isolate,
                             const v8::Global<v8::Context>& context) {
   v8::MicrotasksScope microtasks_scope(isolate,
                                        v8::MicrotasksScope::kRunMicrotasks);
   v8::HandleScope handle_scope(isolate);
   v8::Local<v8::Context> local_context = context.Get(isolate);
   v8::Context::Scope context_scope(local_context);
 
-  v8::ScriptOrigin origin(v8::String::Empty(isolate));
+  v8::Local<v8::String> name =
+      v8::String::NewFromTwoByte(isolate, name_.start(),
+                                 v8::NewStringType::kNormal, name_.length())
+          .ToLocalChecked();
+  v8::Local<v8::Integer> line_offset = v8::Integer::New(isolate, line_offset_);
+  v8::Local<v8::Integer> column_offset =
+      v8::Integer::New(isolate, column_offset_);
+
+  v8::ScriptOrigin origin(name, line_offset, column_offset);
   v8::Local<v8::String> source;
   if (expression_.length()) {
     source = v8::String::NewFromTwoByte(isolate, expression_.start(),
                                         v8::NewStringType::kNormal,
                                         expression_.length())
                  .ToLocalChecked();
   } else {
     source = v8::String::NewFromUtf8(isolate, expression_utf8_.start(),
                                      v8::NewStringType::kNormal,
                                      expression_utf8_.length())
                  .ToLocalChecked();
   }
 
   v8::ScriptCompiler::Source scriptSource(source, origin);
   v8::Local<v8::Script> script;
   if (!v8::ScriptCompiler::Compile(local_context, &scriptSource)
            .ToLocal(&script))
     return;
   v8::MaybeLocal<v8::Value> result;
   result = script->Run(local_context);
 }