Changeset 247278 in webkit


Ignore:
Timestamp:
Jul 9, 2019 2:07:53 PM (5 years ago)
Author:
Devin Rousso
Message:

Web Inspector: Canvas: replace WTF::Vector with std::initializer_list in CallTracer to avoid dynamic allocations
​https://bugs.webkit.org/show_bug.cgi?id=199611

Reviewed by Joseph Pecoraro.

Source/WebCore:

The number of arguments for each member function is known at build time, so there's no need
to dynamically allocate a WTF::Vector when capturing the arguments. One downside to using
a std::initializer_list is that we can no longer "flatten" WTF::Variant arguments into
a RecordCanvasActionVariant, but this is acceptable because WTF::Variant supports having
yet another WTF::Variant as one of it's types, which the InspectorCanvas can then figure
out when it finally gets the data. The same applies to nullptr/Optional checks as well.

  • bindings/scripts/CodeGeneratorJS.pm:

(GenerateAttributeSetterBodyDefinition):
(GenerateImplementationFunctionCall):
(GenerateCallTracer):
(GenerateCallTracerParameter): Deleted.

  • bindings/scripts/test/JS/JSTestCallTracer.cpp:
  • bindings/js/CallTracerTypes.h:
  • bindings/js/CallTracer.h:
  • bindings/js/CallTracer.cpp:

(WebCore::CallTracer::recordCanvasAction):

  • inspector/InspectorInstrumentation.h:

(WebCore::InspectorInstrumentation::recordCanvasAction):

  • inspector/InspectorInstrumentation.cpp:

(WebCore::InspectorInstrumentation::recordCanvasActionImpl):

  • inspector/agents/InspectorCanvasAgent.h:
  • inspector/agents/InspectorCanvasAgent.cpp:

(WebCore::InspectorCanvasAgent::recordCanvasAction):

  • inspector/InspectorCanvas.h:
  • inspector/InspectorCanvas.cpp:

(WebCore::InspectorCanvas::recordAction):
(WebCore::InspectorCanvas::buildAction):
Drive-by: handle the situation where a parameter is an array of deduplicated strings, which

would otherwise be treated as an array of numbers.

Source/WebInspectorUI:

  • UserInterface/Models/Recording.js:

(WI.Recording.prototype.async swizzle):
Drive-by: handle the situation where a parameter is an array of deduplicated strings, which

would otherwise be treated as an array of numbers.

Location:
trunk/Source
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r247273 r247278  
     12019-07-09  Devin Rousso  <drousso@apple.com>
     2
     3        Web Inspector: Canvas: replace WTF::Vector with std::initializer_list in CallTracer to avoid dynamic allocations
     4        https://bugs.webkit.org/show_bug.cgi?id=199611
     5
     6        Reviewed by Joseph Pecoraro.
     7
     8        The number of arguments for each member function is known at build time, so there's no need
     9        to dynamically allocate a `WTF::Vector` when capturing the arguments. One downside to using
     10        a `std::initializer_list` is that we can no longer "flatten" `WTF::Variant` arguments into
     11        a `RecordCanvasActionVariant`, but this is acceptable because `WTF::Variant` supports having
     12        yet another `WTF::Variant` as one of it's types, which the `InspectorCanvas` can then figure
     13        out when it finally gets the data. The same applies to `nullptr`/`Optional` checks as well.
     14
     15        * bindings/scripts/CodeGeneratorJS.pm:
     16        (GenerateAttributeSetterBodyDefinition):
     17        (GenerateImplementationFunctionCall):
     18        (GenerateCallTracer):
     19        (GenerateCallTracerParameter): Deleted.
     20        * bindings/scripts/test/JS/JSTestCallTracer.cpp:
     21
     22        * bindings/js/CallTracerTypes.h:
     23        * bindings/js/CallTracer.h:
     24        * bindings/js/CallTracer.cpp:
     25        (WebCore::CallTracer::recordCanvasAction):
     26
     27        * inspector/InspectorInstrumentation.h:
     28        (WebCore::InspectorInstrumentation::recordCanvasAction):
     29        * inspector/InspectorInstrumentation.cpp:
     30        (WebCore::InspectorInstrumentation::recordCanvasActionImpl):
     31
     32        * inspector/agents/InspectorCanvasAgent.h:
     33        * inspector/agents/InspectorCanvasAgent.cpp:
     34        (WebCore::InspectorCanvasAgent::recordCanvasAction):
     35
     36        * inspector/InspectorCanvas.h:
     37        * inspector/InspectorCanvas.cpp:
     38        (WebCore::InspectorCanvas::recordAction):
     39        (WebCore::InspectorCanvas::buildAction):
     40        Drive-by: handle the situation where a parameter is an array of deduplicated strings, which
     41                  would otherwise be treated as an array of numbers.
     42
    1432019-07-09  Chris Dumez  <cdumez@apple.com>
    244

  • trunk/Source/WebCore/bindings/js/CallTracer.cpp

    r237777 r247278  
    3333namespace WebCore {
    3434
    35 void CallTracer::recordCanvasAction(const HTMLCanvasElement& canvasElement, const String& name, Vector<RecordCanvasActionVariant>&& parameters)
     35void CallTracer::recordCanvasAction(const HTMLCanvasElement& canvasElement, const String& name, std::initializer_list<RecordCanvasActionVariant>&& parameters)
    3636{
    3737    if (auto* canvasRenderingContext = canvasElement.renderingContext())
    … …  
    3939}
    4040
    41 void CallTracer::recordCanvasAction(CanvasRenderingContext& canvasRenderingContext, const String& name, Vector<RecordCanvasActionVariant>&& parameters)
     41void CallTracer::recordCanvasAction(CanvasRenderingContext& canvasRenderingContext, const String& name, std::initializer_list<RecordCanvasActionVariant>&& parameters)
    4242{
    4343    InspectorInstrumentation::recordCanvasAction(canvasRenderingContext, name, WTFMove(parameters));

  • trunk/Source/WebCore/bindings/js/CallTracer.h

    r237777 r247278  
    2727
    2828#include "CallTracerTypes.h"
    29 #include <wtf/Vector.h>
     29#include <initializer_list>
    3030#include <wtf/text/WTFString.h>
    3131
    … …  
    3737class CallTracer {
    3838public:
    39     static void recordCanvasAction(const HTMLCanvasElement&, const String&, Vector<RecordCanvasActionVariant>&& = { });
    40     static void recordCanvasAction(CanvasRenderingContext&, const String&, Vector<RecordCanvasActionVariant>&& = { });
     39    static void recordCanvasAction(const HTMLCanvasElement&, const String&, std::initializer_list<RecordCanvasActionVariant>&& = { });
     40    static void recordCanvasAction(CanvasRenderingContext&, const String&, std::initializer_list<RecordCanvasActionVariant>&& = { });
    4141};
    4242

  • trunk/Source/WebCore/bindings/js/CallTracerTypes.h

    r244908 r247278  
    4343#include <JavaScriptCore/Int32Array.h>
    4444#include <JavaScriptCore/Uint32Array.h>
     45#include <wtf/Optional.h>
    4546#include <wtf/RefPtr.h>
    4647#include <wtf/Variant.h>
    … …  
    5455#include "WebGLQuery.h"
    5556#include "WebGLRenderbuffer.h"
     57#include "WebGLRenderingContextBase.h"
    5658#include "WebGLSampler.h"
    5759#include "WebGLShader.h"
    … …  
    6365#endif
    6466
     67#if ENABLE(WEBGL2)
     68#include "WebGL2RenderingContext.h"
     69#endif
     70
    6571namespace WebCore {
    6672
    6773using RecordCanvasActionVariant = Variant<
     74    // enum
    6875    CanvasDirection,
    6976    CanvasFillRule,
    … …  
    7279    CanvasTextAlign,
    7380    CanvasTextBaseline,
     81    ImageSmoothingQuality,
     82
     83    // struct
    7484    DOMMatrix2DInit,
     85
     86    // pointer
    7587    Element*,
    7688    HTMLImageElement*,
    7789    ImageBitmap*,
    7890    ImageData*,
    79     ImageSmoothingQuality,
    8091    Path2D*,
    8192#if ENABLE(WEBGL)
    … …  
    110121    RefPtr<Int32Array>,
    111122    RefPtr<Uint32Array>,
     123
     124    // variant
     125    CanvasImageSource,
     126    CanvasRenderingContext2DBase::Style,
     127#if ENABLE(WEBGL)
     128    WebGLRenderingContextBase::BufferDataSource,
     129    Optional<WebGLRenderingContextBase::BufferDataSource>,
     130    WebGLRenderingContextBase::TexImageSource,
     131    Optional<WebGLRenderingContextBase::TexImageSource>,
     132#endif
     133
     134    // array
    112135    Vector<String>,
    113136    Vector<float>,
    114137    Vector<uint32_t>,
    115138    Vector<int32_t>,
     139#if ENABLE(WEBGL)
     140    WebGLRenderingContextBase::Float32List::VariantType,
     141    WebGLRenderingContextBase::Int32List::VariantType,
     142#endif
     143#if ENABLE(WEBGL2)
     144    WebGL2RenderingContext::Uint32List::VariantType,
     145#endif
     146
     147    // basic
    116148    String,
    117149    double,
    118150    float,
     151    Optional<float>,
    119152    uint64_t,
    120153    int64_t,

  • trunk/Source/WebCore/bindings/scripts/CodeGeneratorJS.pm

    r246780 r247278  
    50645064        if ($callTracingCallback) {
    50655065            my $indent = "    ";
    5066             my @callTracerArguments = ();
    5067             push(@callTracerArguments, GenerateCallTracerParameter("nativeValue", $attribute->type, 0, $indent));
     5066            my @callTracerArguments = ("nativeValue");
    50685067            GenerateCallTracer($outputArray, $callTracingCallback, $attribute->name, \@callTracerArguments, $indent);
    50695068        }
    … …  
    62636262    my $callTracingCallback = $operation->extendedAttributes->{CallTracingCallback} || $interface->extendedAttributes->{CallTracingCallback};
    62646263    if ($callTracingCallback) {
    6265         my @callTracerArguments = ();
    6266         foreach my $argument (@{$operation->arguments}) {
    6267             push(@callTracerArguments, GenerateCallTracerParameter($argument->name, $argument->type, $argument->isOptional && !defined($argument->default), $indent));
    6268         }
     6264        my @callTracerArguments = map { $_->name } @{$operation->arguments};
    62696265        GenerateCallTracer($outputArray, $callTracingCallback, $operation->name, \@callTracerArguments, $indent);
    62706266    }
    … …  
    75067502}
    75077503
    7508 sub GenerateCallTracerParameter()
    7509 {
    7510     my ($name, $type, $optional, $indent) = @_;
    7511 
    7512     my $result = "";
    7513 
    7514     if ($optional || $type->isNullable) {
    7515         $result .= $indent . "    if (" . $name . ")\n";
    7516         $result .= "    ";
    7517     }
    7518 
    7519     $result .= $indent . "    ";
    7520 
    7521     if ($type->isUnion) {
    7522         $result .= "WTF::visit([&] (auto& value) { callTracerParameters.append(value); }, ";
    7523     } else {
    7524         $result .= "callTracerParameters.append(";
    7525     }
    7526 
    7527     if ($optional || ($type->isUnion && $type->isNullable)) {
    7528         $result .= "*";
    7529     }
    7530 
    7531     $result .= $name . ");";
    7532 
    7533     return $result;
    7534 }
    7535 
    75367504sub GenerateCallTracer()
    75377505{
    … …  
    75407508    AddToImplIncludes("CallTracer.h");
    75417509
    7542     my $count = scalar(@$arguments);
    7543 
    7544     push(@$outputArray, $indent . "if (UNLIKELY(impl.callTracingActive()))");
    7545     if ($count) {
    7546         push(@$outputArray, " {\n");
    7547         push(@$outputArray, $indent . "    Vector<" . $codeGenerator->WK_ucfirst($callTracingCallback) . "Variant> callTracerParameters;\n");
    7548         push(@$outputArray, join("\n", @$arguments));
    7549     }
    7550     push(@$outputArray, "\n");
     7510    push(@$outputArray, $indent . "if (UNLIKELY(impl.callTracingActive()))\n");
    75517511    push(@$outputArray, $indent . "    CallTracer::" . $callTracingCallback . "(impl, \"" . $name . "\"_s");
    7552     if ($count) {
    7553         push(@$outputArray, ", WTFMove(callTracerParameters)");
     7512    if (scalar(@$arguments)) {
     7513        push(@$outputArray, ", { " . join(", ", @$arguments) . " }");
    75547514    }
    75557515    push(@$outputArray, ");\n");
    7556     if ($count) {
    7557         push(@$outputArray, $indent . "}\n")
    7558     }
    75597516}
    75607517

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestCallTracer.cpp

    r246780 r247278  
    243243    auto nativeValue = convert<IDLBoolean>(state, value);
    244244    RETURN_IF_EXCEPTION(throwScope, false);
    245     if (UNLIKELY(impl.callTracingActive())) {
    246         Vector<TestCallTracerInterfaceVariant> callTracerParameters;
    247         callTracerParameters.append(nativeValue);
    248         CallTracer::testCallTracerInterface(impl, "testAttributeInterface"_s, WTFMove(callTracerParameters));
    249     }
     245    if (UNLIKELY(impl.callTracingActive()))
     246        CallTracer::testCallTracerInterface(impl, "testAttributeInterface"_s, { nativeValue });
    250247    AttributeSetter::call(state, throwScope, [&] {
    251248        return impl.setTestAttributeInterface(WTFMove(nativeValue));
    … …  
    281278    auto nativeValue = convert<IDLBoolean>(state, value);
    282279    RETURN_IF_EXCEPTION(throwScope, false);
    283     if (UNLIKELY(impl.callTracingActive())) {
    284         Vector<TestCallTracerAttributeVariant> callTracerParameters;
    285         callTracerParameters.append(nativeValue);
    286         CallTracer::testCallTracerAttribute(impl, "testAttributeSpecified"_s, WTFMove(callTracerParameters));
    287     }
     280    if (UNLIKELY(impl.callTracingActive()))
     281        CallTracer::testCallTracerAttribute(impl, "testAttributeSpecified"_s, { nativeValue });
    288282    AttributeSetter::call(state, throwScope, [&] {
    289283        return impl.setTestAttributeSpecified(WTFMove(nativeValue));
    … …  
    319313    auto nativeValue = convert<IDLUnion<IDLBoolean, IDLFloat, IDLDOMString>>(state, value);
    320314    RETURN_IF_EXCEPTION(throwScope, false);
    321     if (UNLIKELY(impl.callTracingActive())) {
    322         Vector<TestCallTracerInterfaceVariant> callTracerParameters;
    323         WTF::visit([&] (auto& value) { callTracerParameters.append(value); }, nativeValue);
    324         CallTracer::testCallTracerInterface(impl, "testAttributeWithVariant"_s, WTFMove(callTracerParameters));
    325     }
     315    if (UNLIKELY(impl.callTracingActive()))
     316        CallTracer::testCallTracerInterface(impl, "testAttributeWithVariant"_s, { nativeValue });
    326317    AttributeSetter::call(state, throwScope, [&] {
    327318        return impl.setTestAttributeWithVariant(WTFMove(nativeValue));
    … …  
    394385    auto c = convert<IDLDOMString>(*state, state->uncheckedArgument(2));
    395386    RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
    396     if (UNLIKELY(impl.callTracingActive())) {
    397         Vector<TestCallTracerInterfaceVariant> callTracerParameters;
    398         callTracerParameters.append(a);
    399         callTracerParameters.append(b);
    400         callTracerParameters.append(c);
    401         CallTracer::testCallTracerInterface(impl, "testOperationWithArguments"_s, WTFMove(callTracerParameters));
    402     }
     387    if (UNLIKELY(impl.callTracingActive()))
     388        CallTracer::testCallTracerInterface(impl, "testOperationWithArguments"_s, { a, b, c });
    403389    impl.testOperationWithArguments(WTFMove(a), WTFMove(b), WTFMove(c));
    404390    return JSValue::encode(jsUndefined());
    … …  
    419405    auto nodeNullableArg = convert<IDLNullable<IDLInterface<Node>>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "nodeNullableArg", "TestCallTracer", "testOperationWithNullableArgument", "Node"); });
    420406    RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
    421     if (UNLIKELY(impl.callTracingActive())) {
    422         Vector<TestCallTracerInterfaceVariant> callTracerParameters;
    423         if (nodeNullableArg)
    424             callTracerParameters.append(nodeNullableArg);
    425         CallTracer::testCallTracerInterface(impl, "testOperationWithNullableArgument"_s, WTFMove(callTracerParameters));
    426     }
     407    if (UNLIKELY(impl.callTracingActive()))
     408        CallTracer::testCallTracerInterface(impl, "testOperationWithNullableArgument"_s, { nodeNullableArg });
    427409    impl.testOperationWithNullableArgument(WTFMove(nodeNullableArg));
    428410    return JSValue::encode(jsUndefined());
    … …  
    443425    auto variantArg = convert<IDLUnion<IDLBoolean, IDLFloat, IDLDOMString>>(*state, state->uncheckedArgument(0));
    444426    RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
    445     if (UNLIKELY(impl.callTracingActive())) {
    446         Vector<TestCallTracerInterfaceVariant> callTracerParameters;
    447         WTF::visit([&] (auto& value) { callTracerParameters.append(value); }, variantArg);
    448         CallTracer::testCallTracerInterface(impl, "testOperationWithVariantArgument"_s, WTFMove(callTracerParameters));
    449     }
     427    if (UNLIKELY(impl.callTracingActive()))
     428        CallTracer::testCallTracerInterface(impl, "testOperationWithVariantArgument"_s, { variantArg });
    450429    impl.testOperationWithVariantArgument(WTFMove(variantArg));
    451430    return JSValue::encode(jsUndefined());
    … …  
    466445    auto variantNullableArg = convert<IDLNullable<IDLUnion<IDLBoolean, IDLFloat, IDLDOMString>>>(*state, state->uncheckedArgument(0));
    467446    RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
    468     if (UNLIKELY(impl.callTracingActive())) {
    469         Vector<TestCallTracerInterfaceVariant> callTracerParameters;
    470         if (variantNullableArg)
    471             WTF::visit([&] (auto& value) { callTracerParameters.append(value); }, *variantNullableArg);
    472         CallTracer::testCallTracerInterface(impl, "testOperationWithNullableVariantArgument"_s, WTFMove(callTracerParameters));
    473     }
     447    if (UNLIKELY(impl.callTracingActive()))
     448        CallTracer::testCallTracerInterface(impl, "testOperationWithNullableVariantArgument"_s, { variantNullableArg });
    474449    impl.testOperationWithNullableVariantArgument(WTFMove(variantNullableArg));
    475450    return JSValue::encode(jsUndefined());
    … …  
    488463    auto variantOptionalArg = state->argument(0).isUndefined() ? Optional<Converter<IDLUnion<IDLBoolean, IDLFloat, IDLDOMString>>::ReturnType>() : Optional<Converter<IDLUnion<IDLBoolean, IDLFloat, IDLDOMString>>::ReturnType>(convert<IDLUnion<IDLBoolean, IDLFloat, IDLDOMString>>(*state, state->uncheckedArgument(0)));
    489464    RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
    490     if (UNLIKELY(impl.callTracingActive())) {
    491         Vector<TestCallTracerInterfaceVariant> callTracerParameters;
    492         if (variantOptionalArg)
    493             WTF::visit([&] (auto& value) { callTracerParameters.append(value); }, *variantOptionalArg);
    494         CallTracer::testCallTracerInterface(impl, "testOperationWithOptionalVariantArgument"_s, WTFMove(callTracerParameters));
    495     }
     465    if (UNLIKELY(impl.callTracingActive()))
     466        CallTracer::testCallTracerInterface(impl, "testOperationWithOptionalVariantArgument"_s, { variantOptionalArg });
    496467    impl.testOperationWithOptionalVariantArgument(WTFMove(variantOptionalArg));
    497468    return JSValue::encode(jsUndefined());
    … …  
    510481    auto variantDefaultArg = state->argument(0).isUndefined() ? "" : convert<IDLUnion<IDLBoolean, IDLFloat, IDLDOMString>>(*state, state->uncheckedArgument(0));
    511482    RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
    512     if (UNLIKELY(impl.callTracingActive())) {
    513         Vector<TestCallTracerInterfaceVariant> callTracerParameters;
    514         WTF::visit([&] (auto& value) { callTracerParameters.append(value); }, variantDefaultArg);
    515         CallTracer::testCallTracerInterface(impl, "testOperationWithDefaultVariantArgument"_s, WTFMove(callTracerParameters));
    516     }
     483    if (UNLIKELY(impl.callTracingActive()))
     484        CallTracer::testCallTracerInterface(impl, "testOperationWithDefaultVariantArgument"_s, { variantDefaultArg });
    517485    impl.testOperationWithDefaultVariantArgument(WTFMove(variantDefaultArg));
    518486    return JSValue::encode(jsUndefined());

  • trunk/Source/WebCore/inspector/InspectorCanvas.cpp

    r246095 r247278  
    7272#include <JavaScriptCore/IdentifiersFactory.h>
    7373#include <JavaScriptCore/ScriptCallStackFactory.h>
     74#include <wtf/Function.h>
    7475
    7576namespace WebCore {
    … …  
    159160#endif
    160161
    161 void InspectorCanvas::recordAction(const String& name, Vector<RecordCanvasActionVariant>&& parameters)
     162void InspectorCanvas::recordAction(const String& name, std::initializer_list<RecordCanvasActionVariant>&& parameters)
    162163{
    163164    if (!m_initialState) {
    … …  
    656657}
    657658
    658 Ref<JSON::ArrayOf<JSON::Value>> InspectorCanvas::buildAction(const String& name, Vector<RecordCanvasActionVariant>&& parameters)
     659Ref<JSON::ArrayOf<JSON::Value>> InspectorCanvas::buildAction(const String& name, std::initializer_list<RecordCanvasActionVariant>&& parameters)
    659660{
    660661    auto action = JSON::ArrayOf<JSON::Value>::create();
    … …  
    669670    };
    670671
    671     for (auto& item : parameters) {
    672         WTF::switchOn(item,
     672    // Declared before it's initialized so it can be used recursively.
     673    Function<void(const RecordCanvasActionVariant&)> parseParameter;
     674    parseParameter = [&] (const auto& parameter) {
     675        WTF::switchOn(parameter,
    673676            [&] (CanvasDirection value) { addParameter(indexForData(convertEnumerationToString(value)), RecordingSwizzleTypes::String); },
    674677            [&] (CanvasFillRule value) { addParameter(indexForData(convertEnumerationToString(value)), RecordingSwizzleTypes::String); },
    … …  
    677680            [&] (CanvasTextAlign value) { addParameter(indexForData(convertEnumerationToString(value)), RecordingSwizzleTypes::String); },
    678681            [&] (CanvasTextBaseline value) { addParameter(indexForData(convertEnumerationToString(value)), RecordingSwizzleTypes::String); },
     682            [&] (ImageSmoothingQuality value) { addParameter(indexForData(convertEnumerationToString(value)), RecordingSwizzleTypes::String); },
    679683            [&] (const DOMMatrix2DInit& value) {
    680684                auto array = JSON::ArrayOf<double>::create();
    … …  
    687691                addParameter(array.ptr(), RecordingSwizzleTypes::DOMMatrix);
    688692            },
    689             [&] (const Element*) {
    690                 // Elements are not serializable, so add a string as a placeholder since the actual
    691                 // element cannot be reconstructed in the frontend.
    692                 addParameter(indexForData("Element"), RecordingSwizzleTypes::None);
    693             },
    694             [&] (HTMLImageElement* value) { addParameter(indexForData(value), RecordingSwizzleTypes::Image); },
    695             [&] (ImageBitmap* value) { addParameter(indexForData(value), RecordingSwizzleTypes::ImageBitmap); },
    696             [&] (ImageData* value) { addParameter(indexForData(value), RecordingSwizzleTypes::ImageData); },
    697             [&] (ImageSmoothingQuality value) { addParameter(indexForData(convertEnumerationToString(value)), RecordingSwizzleTypes::String); },
    698             [&] (const Path2D* value) { addParameter(indexForData(buildStringFromPath(value->path())), RecordingSwizzleTypes::Path2D); },
     693            [&] (const Element* value) {
     694                if (value) {
     695                    // Elements are not serializable, so add a string as a placeholder since the actual
     696                    // element cannot be reconstructed in the frontend.
     697                    addParameter(indexForData("Element"), RecordingSwizzleTypes::None);
     698                }
     699            },
     700            [&] (HTMLImageElement* value) {
     701                if (value)
     702                    addParameter(indexForData(value), RecordingSwizzleTypes::Image); },
     703            [&] (ImageBitmap* value) {
     704                if (value)
     705                    addParameter(indexForData(value), RecordingSwizzleTypes::ImageBitmap); },
     706            [&] (ImageData* value) {
     707                if (value)
     708                    addParameter(indexForData(value), RecordingSwizzleTypes::ImageData); },
     709            [&] (const Path2D* value) {
     710                if (value)
     711                    addParameter(indexForData(buildStringFromPath(value->path())), RecordingSwizzleTypes::Path2D); },
    699712#if ENABLE(WEBGL)
    700713            // FIXME: <https://webkit.org/b/176009> Web Inspector: send data for WebGL objects during a recording instead of a placeholder string
    701             [&] (const WebGLBuffer*) { addParameter(0, RecordingSwizzleTypes::WebGLBuffer); },
    702             [&] (const WebGLFramebuffer*) { addParameter(0, RecordingSwizzleTypes::WebGLFramebuffer); },
    703             [&] (const WebGLProgram*) { addParameter(0, RecordingSwizzleTypes::WebGLProgram); },
    704             [&] (const WebGLQuery*) { addParameter(0, RecordingSwizzleTypes::WebGLQuery); },
    705             [&] (const WebGLRenderbuffer*) { addParameter(0, RecordingSwizzleTypes::WebGLRenderbuffer); },
    706             [&] (const WebGLSampler*) { addParameter(0, RecordingSwizzleTypes::WebGLSampler); },
    707             [&] (const WebGLShader*) { addParameter(0, RecordingSwizzleTypes::WebGLShader); },
    708             [&] (const WebGLSync*) { addParameter(0, RecordingSwizzleTypes::WebGLSync); },
    709             [&] (const WebGLTexture*) { addParameter(0, RecordingSwizzleTypes::WebGLTexture); },
    710             [&] (const WebGLTransformFeedback*) { addParameter(0, RecordingSwizzleTypes::WebGLTransformFeedback); },
    711             [&] (const WebGLUniformLocation*) { addParameter(0, RecordingSwizzleTypes::WebGLUniformLocation); },
    712             [&] (const WebGLVertexArrayObject*) { addParameter(0, RecordingSwizzleTypes::WebGLVertexArrayObject); },
    713 #endif
    714             [&] (const RefPtr<ArrayBuffer>&) { addParameter(0, RecordingSwizzleTypes::TypedArray); },
    715             [&] (const RefPtr<ArrayBufferView>&) { addParameter(0, RecordingSwizzleTypes::TypedArray); },
    716             [&] (const RefPtr<CanvasGradient>& value) { addParameter(indexForData(value), RecordingSwizzleTypes::CanvasGradient); },
    717             [&] (const RefPtr<CanvasPattern>& value) { addParameter(indexForData(value), RecordingSwizzleTypes::CanvasPattern); },
    718             [&] (const RefPtr<Float32Array>&) { addParameter(0, RecordingSwizzleTypes::TypedArray); },
    719             [&] (const RefPtr<HTMLCanvasElement>& value) { addParameter(indexForData(value), RecordingSwizzleTypes::Image); },
    720             [&] (const RefPtr<HTMLImageElement>& value) { addParameter(indexForData(value), RecordingSwizzleTypes::Image); },
     714            [&] (const WebGLBuffer* value) {
     715                if (value)
     716                    addParameter(0, RecordingSwizzleTypes::WebGLBuffer);
     717            },
     718            [&] (const WebGLFramebuffer* value) {
     719                if (value)
     720                    addParameter(0, RecordingSwizzleTypes::WebGLFramebuffer);
     721            },
     722            [&] (const WebGLProgram* value) {
     723                if (value)
     724                    addParameter(0, RecordingSwizzleTypes::WebGLProgram);
     725            },
     726            [&] (const WebGLQuery* value) {
     727                if (value)
     728                    addParameter(0, RecordingSwizzleTypes::WebGLQuery);
     729            },
     730            [&] (const WebGLRenderbuffer* value) {
     731                if (value)
     732                    addParameter(0, RecordingSwizzleTypes::WebGLRenderbuffer);
     733            },
     734            [&] (const WebGLSampler* value) {
     735                if (value)
     736                    addParameter(0, RecordingSwizzleTypes::WebGLSampler);
     737            },
     738            [&] (const WebGLShader* value) {
     739                if (value)
     740                    addParameter(0, RecordingSwizzleTypes::WebGLShader);
     741            },
     742            [&] (const WebGLSync* value) {
     743                if (value)
     744                    addParameter(0, RecordingSwizzleTypes::WebGLSync);
     745            },
     746            [&] (const WebGLTexture* value) {
     747                if (value)
     748                    addParameter(0, RecordingSwizzleTypes::WebGLTexture);
     749            },
     750            [&] (const WebGLTransformFeedback* value) {
     751                if (value)
     752                    addParameter(0, RecordingSwizzleTypes::WebGLTransformFeedback);
     753            },
     754            [&] (const WebGLUniformLocation* value) {
     755                if (value)
     756                    addParameter(0, RecordingSwizzleTypes::WebGLUniformLocation);
     757            },
     758            [&] (const WebGLVertexArrayObject* value) {
     759                if (value)
     760                    addParameter(0, RecordingSwizzleTypes::WebGLVertexArrayObject);
     761            },
     762#endif
     763            [&] (const RefPtr<ArrayBuffer>& value) {
     764                if (value)
     765                    addParameter(0, RecordingSwizzleTypes::TypedArray);
     766            },
     767            [&] (const RefPtr<ArrayBufferView>& value) {
     768                if (value)
     769                    addParameter(0, RecordingSwizzleTypes::TypedArray);
     770            },
     771            [&] (const RefPtr<CanvasGradient>& value) {
     772                if (value)
     773                    addParameter(indexForData(value), RecordingSwizzleTypes::CanvasGradient);
     774            },
     775            [&] (const RefPtr<CanvasPattern>& value) {
     776                if (value)
     777                    addParameter(indexForData(value), RecordingSwizzleTypes::CanvasPattern);
     778            },
     779            [&] (const RefPtr<Float32Array>& value) {
     780                if (value)
     781                    addParameter(0, RecordingSwizzleTypes::TypedArray);
     782            },
     783            [&] (const RefPtr<HTMLCanvasElement>& value) {
     784                if (value)
     785                    addParameter(indexForData(value), RecordingSwizzleTypes::Image);
     786            },
     787            [&] (const RefPtr<HTMLImageElement>& value) {
     788                if (value)
     789                    addParameter(indexForData(value), RecordingSwizzleTypes::Image);
     790            },
    721791#if ENABLE(VIDEO)
    722             [&] (const RefPtr<HTMLVideoElement>& value) { addParameter(indexForData(value), RecordingSwizzleTypes::Image); },
     792            [&] (const RefPtr<HTMLVideoElement>& value) {
     793                if (value)
     794                    addParameter(indexForData(value), RecordingSwizzleTypes::Image);
     795            },
    723796#endif
    724797#if ENABLE(CSS_TYPED_OM)
    725             [&] (const RefPtr<TypedOMCSSImageValue>& value) { addParameter(indexForData(value), RecordingSwizzleTypes::Image); },
    726 #endif
    727             [&] (const RefPtr<ImageBitmap>& value) { addParameter(indexForData(value), RecordingSwizzleTypes::ImageBitmap); },
    728             [&] (const RefPtr<ImageData>& value) { addParameter(indexForData(value), RecordingSwizzleTypes::ImageData); },
    729             [&] (const RefPtr<Int32Array>&) { addParameter(0, RecordingSwizzleTypes::TypedArray); },
    730             [&] (const RefPtr<Uint32Array>&) { addParameter(0, RecordingSwizzleTypes::TypedArray); },
     798            [&] (const RefPtr<TypedOMCSSImageValue>& value) {
     799                if (value)
     800                    addParameter(indexForData(value), RecordingSwizzleTypes::Image);
     801            },
     802#endif
     803            [&] (const RefPtr<ImageBitmap>& value) {
     804                if (value)
     805                    addParameter(indexForData(value), RecordingSwizzleTypes::ImageBitmap);
     806            },
     807            [&] (const RefPtr<ImageData>& value) {
     808                if (value)
     809                    addParameter(indexForData(value), RecordingSwizzleTypes::ImageData);
     810            },
     811            [&] (const RefPtr<Int32Array>& value) {
     812                if (value)
     813                    addParameter(0, RecordingSwizzleTypes::TypedArray);
     814            },
     815            [&] (const RefPtr<Uint32Array>& value) {
     816                if (value)
     817                    addParameter(0, RecordingSwizzleTypes::TypedArray);
     818            },
     819            [&] (const CanvasImageSource& value) {
     820                WTF::visit(parseParameter, value);
     821            },
     822            [&] (const CanvasRenderingContext2DBase::Style& value) {
     823                WTF::visit(parseParameter, value);
     824            },
     825#if ENABLE(WEBGL)
     826            [&] (const WebGLRenderingContextBase::BufferDataSource& value) {
     827                WTF::visit(parseParameter, value);
     828            },
     829            [&] (const Optional<WebGLRenderingContextBase::BufferDataSource>& value) {
     830                if (value)
     831                    parseParameter(value.value());
     832            },
     833            [&] (const WebGLRenderingContextBase::TexImageSource& value) {
     834                WTF::visit(parseParameter, value);
     835            },
     836            [&] (const Optional<WebGLRenderingContextBase::TexImageSource>& value) {
     837                if (value)
     838                    parseParameter(value.value());
     839            },
     840#endif
    731841            [&] (const Vector<String>& value) {
    732842                auto deduplicated = value.map([&] (const String& item) {
    733843                    return indexForData(item);
    734844                });
    735                 addParameter(buildArrayForVector(deduplicated).ptr(), RecordingSwizzleTypes::Array);
     845                addParameter(buildArrayForVector(deduplicated).ptr(), RecordingSwizzleTypes::String);
    736846            },
    737847            [&] (const Vector<float>& value) { addParameter(buildArrayForVector(value).ptr(), RecordingSwizzleTypes::Array); },
    … …  
    743853            },
    744854            [&] (const Vector<int32_t>& value) { addParameter(buildArrayForVector(value).ptr(), RecordingSwizzleTypes::Array); },
     855#if ENABLE(WEBGL)
     856            [&] (const WebGLRenderingContextBase::Float32List::VariantType& value) {
     857                WTF::visit(parseParameter, value);
     858            },
     859            [&] (const WebGLRenderingContextBase::Int32List::VariantType& value) {
     860                WTF::visit(parseParameter, value);
     861            },
     862#endif
     863#if ENABLE(WEBGL2)
     864            [&] (const WebGL2RenderingContext::Uint32List::VariantType& value) {
     865                WTF::visit(parseParameter, value);
     866            },
     867#endif
    745868            [&] (const String& value) { addParameter(indexForData(value), RecordingSwizzleTypes::String); },
    746869            [&] (double value) { addParameter(value, RecordingSwizzleTypes::Number); },
    747870            [&] (float value) { addParameter(value, RecordingSwizzleTypes::Number); },
     871            [&] (const Optional<float>& value) {
     872                if (value)
     873                    parseParameter(value.value());
     874            },
    748875            [&] (uint64_t value) { addParameter(static_cast<double>(value), RecordingSwizzleTypes::Number); },
    749876            [&] (int64_t value) { addParameter(static_cast<double>(value), RecordingSwizzleTypes::Number); },
    … …  
    753880            [&] (bool value) { addParameter(value, RecordingSwizzleTypes::Boolean); }
    754881        );
    755     }
     882    };
     883    for (auto& parameter : parameters)
     884        parseParameter(parameter);
    756885
    757886    action->addItem(WTFMove(parametersData));

  • trunk/Source/WebCore/inspector/InspectorCanvas.h

    r244908 r247278  
    3030#include <JavaScriptCore/ScriptCallFrame.h>
    3131#include <JavaScriptCore/ScriptCallStack.h>
     32#include <initializer_list>
    3233#include <wtf/Variant.h>
    3334#include <wtf/Vector.h>
    … …  
    6465    bool hasRecordingData() const;
    6566    bool currentFrameHasData() const;
    66     void recordAction(const String&, Vector<RecordCanvasActionVariant>&& = { });
     67    void recordAction(const String&, std::initializer_list<RecordCanvasActionVariant>&& = { });
    6768
    6869    Ref<JSON::ArrayOf<Inspector::Protocol::Recording::Frame>> releaseFrames() { return m_frames.releaseNonNull(); }
    … …  
    110111    String stringIndexForKey(const String&);
    111112    Ref<Inspector::Protocol::Recording::InitialState> buildInitialState();
    112     Ref<JSON::ArrayOf<JSON::Value>> buildAction(const String&, Vector<RecordCanvasActionVariant>&& = { });
     113    Ref<JSON::ArrayOf<JSON::Value>> buildAction(const String&, std::initializer_list<RecordCanvasActionVariant>&& = { });
    113114    Ref<JSON::ArrayOf<JSON::Value>> buildArrayForCanvasGradient(const CanvasGradient&);
    114115    Ref<JSON::ArrayOf<JSON::Value>> buildArrayForCanvasPattern(const CanvasPattern&);

  • trunk/Source/WebCore/inspector/InspectorInstrumentation.cpp

    r246876 r247278  
    10371037}
    10381038
    1039 void InspectorInstrumentation::recordCanvasActionImpl(InstrumentingAgents& instrumentingAgents, CanvasRenderingContext& canvasRenderingContext, const String& name, Vector<RecordCanvasActionVariant>&& parameters)
     1039void InspectorInstrumentation::recordCanvasActionImpl(InstrumentingAgents& instrumentingAgents, CanvasRenderingContext& canvasRenderingContext, const String& name, std::initializer_list<RecordCanvasActionVariant>&& parameters)
    10401040{
    10411041    if (InspectorCanvasAgent* canvasAgent = instrumentingAgents.inspectorCanvasAgent())

  • trunk/Source/WebCore/inspector/InspectorInstrumentation.h

    r247219 r247278  
    5151#include "WorkerInspectorController.h"
    5252#include <JavaScriptCore/JSCInlines.h>
     53#include <initializer_list>
    5354#include <wtf/MemoryPressureHandler.h>
    5455#include <wtf/RefPtr.h>
    … …  
    270271    static void didCreateCanvasRenderingContext(CanvasRenderingContext&);
    271272    static void didChangeCanvasMemory(CanvasRenderingContext&);
    272     static void recordCanvasAction(CanvasRenderingContext&, const String&, Vector<RecordCanvasActionVariant>&& = { });
     273    static void recordCanvasAction(CanvasRenderingContext&, const String&, std::initializer_list<RecordCanvasActionVariant>&& = { });
    273274    static void didFinishRecordingCanvasFrame(CanvasRenderingContext&, bool forceDispatch = false);
    274275#if ENABLE(WEBGL)
    … …  
    453454    static void didCreateCanvasRenderingContextImpl(InstrumentingAgents&, CanvasRenderingContext&);
    454455    static void didChangeCanvasMemoryImpl(InstrumentingAgents&, CanvasRenderingContext&);
    455     static void recordCanvasActionImpl(InstrumentingAgents&, CanvasRenderingContext&, const String&, Vector<RecordCanvasActionVariant>&& = { });
     456    static void recordCanvasActionImpl(InstrumentingAgents&, CanvasRenderingContext&, const String&, std::initializer_list<RecordCanvasActionVariant>&& = { });
    456457    static void didFinishRecordingCanvasFrameImpl(InstrumentingAgents&, CanvasRenderingContext&, bool forceDispatch = false);
    457458#if ENABLE(WEBGL)
    … …  
    13121313}
    13131314
    1314 inline void InspectorInstrumentation::recordCanvasAction(CanvasRenderingContext& context, const String& name, Vector<RecordCanvasActionVariant>&& parameters)
     1315inline void InspectorInstrumentation::recordCanvasAction(CanvasRenderingContext& context, const String& name, std::initializer_list<RecordCanvasActionVariant>&& parameters)
    13151316{
    13161317    FAST_RETURN_IF_NO_FRONTENDS(void());

  • trunk/Source/WebCore/inspector/agents/InspectorCanvasAgent.cpp

    r244908 r247278  
    421421}
    422422
    423 void InspectorCanvasAgent::recordCanvasAction(CanvasRenderingContext& canvasRenderingContext, const String& name, Vector<RecordCanvasActionVariant>&& parameters)
     423void InspectorCanvasAgent::recordCanvasAction(CanvasRenderingContext& canvasRenderingContext, const String& name, std::initializer_list<RecordCanvasActionVariant>&& parameters)
    424424{
    425425    auto inspectorCanvas = findInspectorCanvas(canvasRenderingContext);

  • trunk/Source/WebCore/inspector/agents/InspectorCanvasAgent.h

    r244908 r247278  
    3333#include <JavaScriptCore/InspectorBackendDispatchers.h>
    3434#include <JavaScriptCore/InspectorFrontendDispatchers.h>
     35#include <initializer_list>
    3536#include <wtf/HashMap.h>
    3637#include <wtf/RefPtr.h>
    … …  
    8889    void willDestroyCanvasRenderingContext(CanvasRenderingContext&);
    8990    void didChangeCanvasMemory(CanvasRenderingContext&);
    90     void recordCanvasAction(CanvasRenderingContext&, const String&, Vector<RecordCanvasActionVariant>&& = { });
     91    void recordCanvasAction(CanvasRenderingContext&, const String&, std::initializer_list<RecordCanvasActionVariant>&& = { });
    9192    void didFinishRecordingCanvasFrame(CanvasRenderingContext&, bool forceDispatch = false);
    9293    void consoleStartRecordingCanvas(CanvasRenderingContext&, JSC::ExecState&, JSC::JSObject* options);

  • trunk/Source/WebInspectorUI/ChangeLog

    r247275 r247278  
     12019-07-09  Devin Rousso  <drousso@apple.com>
     2
     3        Web Inspector: Canvas: replace WTF::Vector with std::initializer_list in CallTracer to avoid dynamic allocations
     4        https://bugs.webkit.org/show_bug.cgi?id=199611
     5
     6        Reviewed by Joseph Pecoraro.
     7
     8        * UserInterface/Models/Recording.js:
     9        (WI.Recording.prototype.async swizzle):
     10        Drive-by: handle the situation where a parameter is an array of deduplicated strings, which
     11                  would otherwise be treated as an array of numbers.
     12
    1132019-07-09  Joseph Pecoraro  <pecoraro@apple.com>
    214

  • trunk/Source/WebInspectorUI/UserInterface/Models/Recording.js

    r244908 r247278  
    353353
    354354                case WI.Recording.Swizzle.String:
    355                     this._swizzle[index][type] = String(data);
     355                    if (Array.isArray(data))
     356                        this._swizzle[index][type] = await Promise.all(data.map((item) => this.swizzle(item, WI.Recording.Swizzle.String)));
     357                    else
     358                        this._swizzle[index][type] = String(data);
    356359                    break;
    357360
Note: See TracChangeset for help on using the changeset viewer.