[inspector] Split off interface-types.h

src/inspector/wasm-translation.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 "src/inspector/wasm-translation.h"
 
 #include <algorithm>
 
 #include "src/debug/debug-interface.h"
 #include "src/inspector/protocol/Debugger.h"
@@ skipping 54 matching lines @@
 
 class WasmTranslation::TranslatorImpl::RawTranslator
     : public WasmTranslation::TranslatorImpl {
  public:
   void Translate(TransLocation *loc) {}
   void TranslateBack(TransLocation *loc) {}
 };
 
 class WasmTranslation::TranslatorImpl::DisassemblingTranslator
     : public WasmTranslation::TranslatorImpl {
-  using OffsetTable = std::vector<std::tuple<uint32_t, int, int>>;
+  using OffsetTable = debug::WasmDisassembly::OffsetTable;
 
  public:
   DisassemblingTranslator(Isolate *isolate, Local<Object> script)
       : script_(isolate, script) {}
 
   void Translate(TransLocation *loc) {
     const OffsetTable &offset_table = GetOffsetTable(loc);
     DCHECK(!offset_table.empty());
     uint32_t byte_offset = static_cast<uint32_t>(loc->column);
 
     // Binary search for the given offset.
     unsigned left = 0;                                            // inclusive
     unsigned right = static_cast<unsigned>(offset_table.size());  // exclusive
     while (right - left > 1) {
       unsigned mid = (left + right) / 2;
-      if (std::get<0>(offset_table[mid]) <= byte_offset) {
+      if (offset_table[mid].byte_offset <= byte_offset) {
         left = mid;
       } else {
         right = mid;
       }
     }
 
     loc->script_id = GetFakeScriptId(loc);
-    if (std::get<0>(offset_table[left]) == byte_offset) {
-      loc->line = std::get<1>(offset_table[left]);
-      loc->column = std::get<2>(offset_table[left]);
+    if (offset_table[left].byte_offset == byte_offset) {
+      loc->line = offset_table[left].line;
+      loc->column = offset_table[left].column;
     } else {
       loc->line = 0;
       loc->column = 0;
     }
   }
 
   void TranslateBack(TransLocation *loc) {
     int func_index = GetFunctionIndexFromFakeScriptId(loc->script_id);
     const OffsetTable *reverse_table = GetReverseTable(func_index);
     if (!reverse_table) return;
     DCHECK(!reverse_table->empty());
 
     // Binary search for the given line and column.
     unsigned left = 0;                                              // inclusive
     unsigned right = static_cast<unsigned>(reverse_table->size());  // exclusive
     while (right - left > 1) {
       unsigned mid = (left + right) / 2;
       auto &entry = (*reverse_table)[mid];
-      if (std::get<1>(entry) < loc->line ||
-          (std::get<1>(entry) == loc->line &&
-           std::get<2>(entry) <= loc->column)) {
+      if (entry.line < loc->line ||
+          (entry.line == loc->line && entry.column <= loc->column)) {
         left = mid;
       } else {
         right = mid;
       }
     }
 
     int found_byte_offset = 0;
     // If we found an exact match, use it. Otherwise check whether the next
     // bigger entry is still in the same line. Report that one then.
-    if (std::get<1>((*reverse_table)[left]) == loc->line &&
-        std::get<2>((*reverse_table)[left]) == loc->column) {
-      found_byte_offset = std::get<0>((*reverse_table)[left]);
+    if ((*reverse_table)[left].line == loc->line &&
+        (*reverse_table)[left].column == loc->column) {
+      found_byte_offset = (*reverse_table)[left].byte_offset;
     } else if (left + 1 < reverse_table->size() &&
-               std::get<1>((*reverse_table)[left + 1]) == loc->line) {
-      found_byte_offset = std::get<0>((*reverse_table)[left + 1]);
+               (*reverse_table)[left + 1].line == loc->line) {
+      found_byte_offset = (*reverse_table)[left + 1].byte_offset;
     }
 
     v8::Isolate *isolate = loc->translation->isolate_;
     loc->script_id =
         String16::fromInteger(GetScriptId(isolate, script_.Get(isolate)));
     loc->line = func_index;
     loc->column = found_byte_offset;
   }
 
  private:
@@ skipping 17 matching lines @@
     DCHECK(ok);
     return func_index;
   }
 
   const OffsetTable &GetOffsetTable(const TransLocation *loc) {
     int func_index = loc->line;
     auto it = offset_tables_.find(func_index);
     if (it != offset_tables_.end()) return it->second;
 
     v8::Isolate *isolate = loc->translation->isolate_;
-    std::pair<std::string, OffsetTable> disassembly =
+    debug::WasmDisassembly disassembly_result =
         DebugInterface::DisassembleWasmFunction(isolate, script_.Get(isolate),
                                                 func_index);
 
     it = offset_tables_
-             .insert(std::make_pair(func_index, std::move(disassembly.second)))
+             .insert(std::make_pair(func_index,
+                                    std::move(disassembly_result.offset_table)))
              .first;
 
     String16 fake_script_id = GetFakeScriptId(loc);
     String16 fake_script_url = GetFakeScriptUrl(loc);
-    String16 source(disassembly.first.data(), disassembly.first.length());
+    String16 source(disassembly_result.disassembly.data(),
+                    disassembly_result.disassembly.length());
     std::unique_ptr<V8DebuggerScript> fake_script(new V8DebuggerScript(
         fake_script_id, std::move(fake_script_url), source));
 
     loc->translation->AddFakeScript(std::move(fake_script), this,
                                     loc->context_group_id);
 
     return it->second;
   }
 
   const OffsetTable *GetReverseTable(int func_index) {
     auto it = reverse_tables_.find(func_index);
     if (it != reverse_tables_.end()) return &it->second;
 
     // Find offset table, copy and sort it to get reverse table.
     it = offset_tables_.find(func_index);
     if (it == offset_tables_.end()) return nullptr;
 
     OffsetTable reverse_table = it->second;
     // Order by line, column, then byte offset.
-    auto cmp = [](std::tuple<uint32_t, int, int> el1,
-                  std::tuple<uint32_t, int, int> el2) {
-      if (std::get<1>(el1) != std::get<1>(el2))
-        return std::get<1>(el1) < std::get<1>(el2);
-      if (std::get<2>(el1) != std::get<2>(el2))
-        return std::get<2>(el1) < std::get<2>(el2);
-      return std::get<0>(el1) < std::get<0>(el2);
+    auto cmp = [](OffsetTable::value_type el1, OffsetTable::value_type el2) {
+      if (el1.line != el2.line) return el1.line < el2.line;
+      if (el1.column != el2.column) return el1.column < el2.column;
+      return el1.byte_offset < el2.byte_offset;
     };
     std::sort(reverse_table.begin(), reverse_table.end(), cmp);
 
     auto inserted = reverse_tables_.insert(
         std::make_pair(func_index, std::move(reverse_table)));
     DCHECK(inserted.second);
     return &inserted.first->second;
   }
 
   Global<Object> script_;
@@ skipping 79 matching lines @@
     int context_group_id) {
   bool inserted =
       fake_scripts_.insert(std::make_pair(fake_script->scriptId(), translator))
           .second;
   DCHECK(inserted);
   USE(inserted);
   V8DebuggerAgentImpl *agent =
       debugger_->inspector()->enabledDebuggerAgentForGroup(context_group_id);
   agent->didParseSource(std::move(fake_script), true);
 }