[inspector] [wasm] Add folder structure to wasm urls

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 118 matching lines @@
       found_byte_offset = std::get<0>((*reverse_table)[left + 1]);
     }
 
     v8::Isolate *isolate = loc->translation->isolate_;
     loc->script_id = String16::fromInteger(script_.Get(isolate)->Id());
     loc->line = func_index;
     loc->column = found_byte_offset;
   }
 
  private:
-  String16 GetScriptName(v8::Isolate *isolate) {
-    return toProtocolString(script_.Get(isolate)->Name().ToLocalChecked());
+  int getNumDigits(int number) {
+    DCHECK_LE(0, number);
+    static const int limits[] = {0,         10,        100,     1000,
+                                 10000,     100000,    1000000, 10000000,
+                                 100000000, 1000000000};
+    for (int i = 0; i < static_cast<int>(arraysize(limits)); ++i)
+      if (number < limits[i]) return i;
+    UNREACHABLE();
+    return 0;

[Yang, 2016/12/05 15:16:42]

This seems just to left-pad the folder name to the same width as the max value.
Is this that important? Or can we just always pad to 8 digits to save on
complexity?

[Clemens Hammacher, 2016/12/05 18:15:29]

Yes, this is just for aesthetics. We can either just replace it by 8, or by
String16::fromInteger(number).length().
As the complexity of the code below is not reduced by switching to "always 8", I
would actually prefer the String16::fromInteger solution, which is much closer
to the complexity of a constant than the current code, but still produces nice
results :)

I changed it accordingly.

   }
 
   String16 GetFakeScriptUrl(v8::Isolate *isolate, int func_index) {
-    String16 script_name = GetScriptName(isolate);
-    return String16::concat("wasm://wasm/", script_name, '/', script_name, '-',
-                            String16::fromInteger(func_index));
-  }
-  String16 GetFakeScriptUrl(const TransLocation *loc) {
-    return GetFakeScriptUrl(loc->translation->isolate_, loc->line);
+    Local<DebugInterface::WasmScript> script = script_.Get(isolate);
+    String16 script_name = toProtocolString(script->Name().ToLocalChecked());
+    int numFunctions = script->NumFunctions();
+    int numImported = script->NumImportedFunctions();
+    String16Builder builder;
+    builder.appendAll("wasm://wasm/", script_name, '/');
+    if (numFunctions - numImported > 300) {
+      int digits = getNumDigits(numFunctions - 1);
+      String16 thisCategory = String16::fromInteger((func_index / 100) * 100);
+      DCHECK_LE(thisCategory.length(), digits);
+      for (int i = static_cast<int>(thisCategory.length()); i < digits; ++i)
+        builder.append('0');
+      builder.appendAll(thisCategory, '/');
+    }
+    builder.appendAll(script_name, '-');
+    builder.appendNumber(func_index);
+    return builder.toString();
   }
 
   String16 GetFakeScriptId(const String16 script_id, int func_index) {
     return String16::concat(script_id, '-', String16::fromInteger(func_index));
   }
   String16 GetFakeScriptId(const TransLocation *loc) {
     return GetFakeScriptId(loc->script_id, loc->line);
   }
 
   void AddFakeScript(v8::Isolate *isolate, const String16 &underlyingScriptId,
@@ skipping 137 matching lines @@
   *column_number = trans_loc.column;
 
   return true;
 }
 
 void WasmTranslation::AddFakeScript(const String16 &scriptId,
                                     TranslatorImpl *translator) {
   DCHECK_EQ(0, fake_scripts_.count(scriptId));
   fake_scripts_.insert(std::make_pair(scriptId, translator));
 }