[inspector] Split off interface-types.h

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 8960 matching lines @@
   return Utils::OpenHandle(this)->type() == i::Script::TYPE_WASM;
 }
 
 namespace {
 int GetSmiValue(i::Handle<i::FixedArray> array, int index) {
   return i::Smi::cast(array->get(index))->value();
 }
 }  // namespace
 
 bool DebugInterface::Script::GetPossibleBreakpoints(
-    const Location& start, const Location& end,
-    std::vector<Location>* locations) const {
+    const debug::Location& start, const debug::Location& end,
+    std::vector<debug::Location>* locations) const {
   CHECK(!start.IsEmpty());
   i::Handle<i::Script> script = Utils::OpenHandle(this);
   if (script->type() == i::Script::TYPE_WASM) {
     // TODO(clemensh): Return the proper thing once we support wasm breakpoints.
     return false;
   }
 
   i::Script::InitLineEnds(script);
   CHECK(script->line_ends()->IsFixedArray());
   i::Isolate* isolate = script->GetIsolate();
@@ skipping 21 matching lines @@
     int offset = it;
     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(Location(
+    locations->push_back(debug::Location(
         current_line_end_index + script->line_offset(),
         offset - line_offset +
             (current_line_end_index == 0 ? script->column_offset() : 0)));
   }
   return true;
 }
 
-int DebugInterface::Script::GetSourcePosition(const Location& location) const {
+int DebugInterface::Script::GetSourcePosition(
+    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;
   }
 
   int line = std::max(location.GetLineNumber() - script->line_offset(), 0);
   int column = location.GetColumnNumber();
   if (line == 0) {
     column = std::max(0, column - script->column_offset());
@@ skipping 26 matching lines @@
   }
   i::Handle<i::Script> script_obj = i::Handle<i::Script>::cast(script_value);
   if (script_obj->type() != i::Script::TYPE_NORMAL &&
       script_obj->type() != i::Script::TYPE_WASM) {
     return MaybeLocal<Script>();
   }
   return ToApiHandle<DebugInterface::Script>(
       handle_scope.CloseAndEscape(script_obj));
 }
 
-DebugInterface::Location::Location(int lineNumber, int columnNumber)
-    : lineNumber_(lineNumber), columnNumber_(columnNumber) {
-  CHECK(lineNumber >= 0);
-  CHECK(columnNumber >= 0);
+debug::Location::Location(int line_number, int column_number)
+    : line_number_(line_number), column_number_(column_number) {
+  CHECK(line_number >= 0);
+  CHECK(column_number >= 0);
 }
 
-DebugInterface::Location::Location() : lineNumber_(-1), columnNumber_(-1) {}
+debug::Location::Location() : line_number_(-1), column_number_(-1) {}
 
-int DebugInterface::Location::GetLineNumber() const {
-  CHECK(lineNumber_ >= 0);
-  return lineNumber_;
+int debug::Location::GetLineNumber() const {
+  CHECK(line_number_ >= 0);
+  return line_number_;
 }
 
-int DebugInterface::Location::GetColumnNumber() const {
-  CHECK(columnNumber_ >= 0);
-  return columnNumber_;
+int debug::Location::GetColumnNumber() const {
+  CHECK(column_number_ >= 0);
+  return column_number_;
 }
 
-bool DebugInterface::Location::IsEmpty() const {
-  return lineNumber_ == -1 && columnNumber_ == -1;
+bool debug::Location::IsEmpty() const {
+  return line_number_ == -1 && column_number_ == -1;
 }
 
 void DebugInterface::GetLoadedScripts(
     v8::Isolate* v8_isolate,
     PersistentValueVector<DebugInterface::Script>& scripts) {
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
   ENTER_V8(isolate);
   // TODO(kozyatinskiy): remove this GC once tests are dealt with.
   isolate->heap()->CollectAllGarbage(i::Heap::kFinalizeIncrementalMarkingMask,
                                      i::GarbageCollectionReason::kDebugger);
   {
     i::DisallowHeapAllocation no_gc;
     i::Script::Iterator iterator(isolate);
     i::Script* script;
     while ((script = iterator.Next())) {
       if (script->type() != i::Script::TYPE_NORMAL) continue;
       if (script->HasValidSource()) {
         i::HandleScope handle_scope(isolate);
         i::Handle<i::Script> script_handle(script, isolate);
         scripts.Append(ToApiHandle<Script>(script_handle));
       }
     }
   }
 }
 
-std::pair<std::string, std::vector<std::tuple<uint32_t, int, int>>>
-DebugInterface::DisassembleWasmFunction(Isolate* v8_isolate,
-                                        Local<Object> v8_script,
-                                        int function_index) {
+debug::WasmDisassembly DebugInterface::DisassembleWasmFunction(
+    Isolate* v8_isolate, Local<Object> v8_script, int function_index) {
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
   if (v8_script.IsEmpty()) return {};
   i::Handle<i::Object> script_wrapper = Utils::OpenHandle(*v8_script);
   if (!script_wrapper->IsJSValue()) return {};
   i::Handle<i::Object> script_obj(
       i::Handle<i::JSValue>::cast(script_wrapper)->value(), isolate);
   if (!script_obj->IsScript()) return {};
   i::Handle<i::Script> script = i::Handle<i::Script>::cast(script_obj);
   if (script->type() != i::Script::TYPE_WASM) return {};
   i::Handle<i::WasmCompiledModule> compiled_module(
@@ skipping 701 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