Changeset 220008 in webkit


Ignore:
Timestamp:
Jul 28, 2017 11:22:17 AM (7 years ago)
Author:
Devin Rousso
Message:

Web Inspector: Record actions performed on CanvasRenderingContext2D
​https://bugs.webkit.org/show_bug.cgi?id=174482

Reviewed by Joseph Pecoraro.

Source/WebCore:

Tests: inspector/canvas/recording-2d.html

inspector/canvas/recording.html

  • html/canvas/CanvasRenderingContext2D.idl:

Add CallTracingCallback to interface to record all API calls.

  • html/HTMLCanvasElement.cpp:

(WebCore::HTMLCanvasElement::paint):
If a recording is active, mark the current frame as completed.

  • bindings/scripts/CodeGeneratorJS.pm:

(GenerateAttributeGetterBodyDefinition):
(GenerateAttributeSetterBodyDefinition):
(GenerateImplementationFunctionCall):
(GenerateCallTracerParameter):
(GenerateCallTracer):

  • bindings/scripts/test/TestCallTracer.idl:
  • bindings/scripts/test/JS/JSTestCallTracer.cpp:

(WebCore::setJSTestCallTracerTestAttributeInterfaceSetter):
(WebCore::setJSTestCallTracerTestAttributeSpecifiedSetter):
(WebCore::jsTestCallTracerTestAttributeWithVariantGetter):
(WebCore::jsTestCallTracerTestAttributeWithVariant):
(WebCore::setJSTestCallTracerTestAttributeWithVariantSetter):
(WebCore::setJSTestCallTracerTestAttributeWithVariant):
(WebCore::jsTestCallTracerPrototypeFunctionTestOperationInterfaceBody):
(WebCore::jsTestCallTracerPrototypeFunctionTestOperationSpecifiedBody):
(WebCore::jsTestCallTracerPrototypeFunctionTestOperationWithArgumentsBody):
(WebCore::jsTestCallTracerPrototypeFunctionTestOperationWithNullableArgumentBody):
(WebCore::jsTestCallTracerPrototypeFunctionTestOperationWithVariantArgumentBody):
(WebCore::jsTestCallTracerPrototypeFunctionTestOperationWithVariantArgument):

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

(WebCore::InspectorCanvas::recordAction):
(WebCore::InspectorCanvas::buildAction):
Change CallTracer IDL generation to flatten any variants so that all types for the
parameters of an action are able to be listed in a single variant. This prevents possible
ambiguity when constructing the variant, as they require that exactly one type be
constructible and a sub-variant might not satisfy that condition. This was only an issue for
older mac SDKs.

  • bindings/js/CallTracer.h:
  • bindings/js/CallTracer.cpp:

(WebCore::CallTracer::recordCanvasAction):

  • bindings/js/CallTracerTypes.h:
  • inspector/InspectorCanvasAgent.h:
  • inspector/InspectorCanvasAgent.cpp:

(WebCore::InspectorCanvasAgent::recordCanvasAction):

  • inspector/InspectorInstrumentation.h:
  • inspector/InspectorInstrumentation.cpp:

(WebCore::InspectorInstrumentation::recordCanvasAction):
(WebCore::InspectorInstrumentation::recordCanvasActionImpl):
Rename CanvasActionParameterVariant to RecordCanvasActionVariant to match what is expected by
the IDL generator. Also remove unnecessary includes now that they are in CallTracerTypes.h.

  • CMakeLists.txt:
  • bindings/js/JSBindingsAllInOne.cpp:

Add CallTracer for CMake builds.

LayoutTests:

  • inspector/canvas/recording-2d-expected.txt: Added.
  • inspector/canvas/recording-2d.html: Added.
  • inspector/canvas/recording-expected.txt: Added.
  • inspector/canvas/recording.html: Added.

Take a recording of all CanvasRenderingContext2D actions and dump the recorded JSON data.

Location:
trunk
Files:
4 added
18 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r220005 r220008  
     12017-07-28  Devin Rousso  <drousso@apple.com>
     2
     3        Web Inspector: Record actions performed on CanvasRenderingContext2D
     4        https://bugs.webkit.org/show_bug.cgi?id=174482
     5
     6        Reviewed by Joseph Pecoraro.
     7
     8        * inspector/canvas/recording-2d-expected.txt: Added.
     9        * inspector/canvas/recording-2d.html: Added.
     10        * inspector/canvas/recording-expected.txt: Added.
     11        * inspector/canvas/recording.html: Added.
     12        Take a recording of all CanvasRenderingContext2D actions and dump the recorded JSON data.
     13
    1142017-07-28  Per Arne Vollan  <pvollan@apple.com>
    215

  • trunk/Source/WebCore/CMakeLists.txt

    r220006 r220008  
    11371137    bindings/js/CachedModuleScriptLoader.cpp
    11381138    bindings/js/CachedScriptFetcher.cpp
     1139    bindings/js/CallTracer.cpp
    11391140    bindings/js/CommonVM.cpp
    11401141    bindings/js/DOMWrapperWorld.cpp

  • trunk/Source/WebCore/ChangeLog

    r220006 r220008  
     12017-07-28  Devin Rousso  <drousso@apple.com>
     2
     3        Web Inspector: Record actions performed on CanvasRenderingContext2D
     4        https://bugs.webkit.org/show_bug.cgi?id=174482
     5
     6        Reviewed by Joseph Pecoraro.
     7
     8        Tests: inspector/canvas/recording-2d.html
     9               inspector/canvas/recording.html
     10
     11        * html/canvas/CanvasRenderingContext2D.idl:
     12        Add CallTracingCallback to interface to record all API calls.
     13
     14        * html/HTMLCanvasElement.cpp:
     15        (WebCore::HTMLCanvasElement::paint):
     16        If a recording is active, mark the current frame as completed.
     17
     18        * bindings/scripts/CodeGeneratorJS.pm:
     19        (GenerateAttributeGetterBodyDefinition):
     20        (GenerateAttributeSetterBodyDefinition):
     21        (GenerateImplementationFunctionCall):
     22        (GenerateCallTracerParameter):
     23        (GenerateCallTracer):
     24        * bindings/scripts/test/TestCallTracer.idl:
     25        * bindings/scripts/test/JS/JSTestCallTracer.cpp:
     26        (WebCore::setJSTestCallTracerTestAttributeInterfaceSetter):
     27        (WebCore::setJSTestCallTracerTestAttributeSpecifiedSetter):
     28        (WebCore::jsTestCallTracerTestAttributeWithVariantGetter):
     29        (WebCore::jsTestCallTracerTestAttributeWithVariant):
     30        (WebCore::setJSTestCallTracerTestAttributeWithVariantSetter):
     31        (WebCore::setJSTestCallTracerTestAttributeWithVariant):
     32        (WebCore::jsTestCallTracerPrototypeFunctionTestOperationInterfaceBody):
     33        (WebCore::jsTestCallTracerPrototypeFunctionTestOperationSpecifiedBody):
     34        (WebCore::jsTestCallTracerPrototypeFunctionTestOperationWithArgumentsBody):
     35        (WebCore::jsTestCallTracerPrototypeFunctionTestOperationWithNullableArgumentBody):
     36        (WebCore::jsTestCallTracerPrototypeFunctionTestOperationWithVariantArgumentBody):
     37        (WebCore::jsTestCallTracerPrototypeFunctionTestOperationWithVariantArgument):
     38        * inspector/InspectorCanvas.h:
     39        * inspector/InspectorCanvas.cpp:
     40        (WebCore::InspectorCanvas::recordAction):
     41        (WebCore::InspectorCanvas::buildAction):
     42        Change CallTracer IDL generation to flatten any variants so that all types for the
     43        parameters of an action are able to be listed in a single variant. This prevents possible
     44        ambiguity when constructing the variant, as they require that exactly one type be
     45        constructible and a sub-variant might not satisfy that condition. This was only an issue for
     46        older mac SDKs.
     47
     48        * bindings/js/CallTracer.h:
     49        * bindings/js/CallTracer.cpp:
     50        (WebCore::CallTracer::recordCanvasAction):
     51        * bindings/js/CallTracerTypes.h:
     52        * inspector/InspectorCanvasAgent.h:
     53        * inspector/InspectorCanvasAgent.cpp:
     54        (WebCore::InspectorCanvasAgent::recordCanvasAction):
     55        * inspector/InspectorInstrumentation.h:
     56        * inspector/InspectorInstrumentation.cpp:
     57        (WebCore::InspectorInstrumentation::recordCanvasAction):
     58        (WebCore::InspectorInstrumentation::recordCanvasActionImpl):
     59        Rename CanvasActionParameterVariant to RecordCanvasActionVariant to match what is expected by
     60        the IDL generator. Also remove unnecessary includes now that they are in CallTracerTypes.h.
     61
     62        * CMakeLists.txt:
     63        * bindings/js/JSBindingsAllInOne.cpp:
     64        Add CallTracer for CMake builds.
     65
    1662017-07-28  Sam Weinig  <sam@webkit.org>
    267

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

    r219964 r220008  
    2727#include "CallTracer.h"
    2828
    29 #include "CanvasGradient.h"
    30 #include "CanvasPattern.h"
    3129#include "CanvasRenderingContext.h"
    32 #include "DOMPath.h"
    33 #include "Element.h"
    34 #include "HTMLCanvasElement.h"
    35 #include "HTMLImageElement.h"
    36 #include "HTMLVideoElement.h"
    37 #include "ImageData.h"
    3830#include "InspectorInstrumentation.h"
    3931
    4032namespace WebCore {
    4133
    42 void CallTracer::recordCanvasAction(CanvasRenderingContext& canvasRenderingContext, const String& name, Vector<CanvasActionParameterVariant>&& parameters)
     34void CallTracer::recordCanvasAction(CanvasRenderingContext& canvasRenderingContext, const String& name, Vector<RecordCanvasActionVariant>&& parameters)
    4335{
    4436    InspectorInstrumentation::recordCanvasAction(canvasRenderingContext, name, WTFMove(parameters));

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

    r219964 r220008  
    3636class CallTracer {
    3737public:
    38     static void recordCanvasAction(CanvasRenderingContext&, const String&, Vector<CanvasActionParameterVariant>&& = { });
     38    static void recordCanvasAction(CanvasRenderingContext&, const String&, Vector<RecordCanvasActionVariant>&& = { });
    3939};
    4040

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

    r219964 r220008  
    2626#pragma once
    2727
     28#include "CanvasGradient.h"
     29#include "CanvasPattern.h"
    2830#include "CanvasRenderingContext2D.h"
    2931#include "DOMMatrixInit.h"
     32#include "DOMPath.h"
     33#include "Element.h"
     34#include "HTMLCanvasElement.h"
     35#include "HTMLImageElement.h"
     36#include "HTMLVideoElement.h"
     37#include "ImageData.h"
     38#include <wtf/RefPtr.h>
    3039#include <wtf/Variant.h>
    3140#include <wtf/Vector.h>
    … …  
    3443namespace WebCore {
    3544
    36 class DOMPath;
    37 class Element;
    38 class HTMLImageElement;
    39 class ImageData;
    40 
    4145typedef Variant<
     46    CanvasRenderingContext2D::ImageSmoothingQuality,
     47    CanvasRenderingContext2D::WindingRule,
     48    DOMMatrixInit,
     49    DOMPath*,
    4250    Element*,
    4351    HTMLImageElement*,
    4452    ImageData*,
    45     DOMMatrixInit,
    46     DOMPath*,
     53    RefPtr<CanvasGradient>,
     54    RefPtr<CanvasPattern>,
     55    RefPtr<HTMLCanvasElement>,
     56    RefPtr<HTMLImageElement>,
     57#if ENABLE(VIDEO)
     58    RefPtr<HTMLVideoElement>,
     59#endif
    4760    Vector<float>,
    4861    String,
    … …  
    5164    int,
    5265    bool,
    53     std::optional<float>,
    54     CanvasImageSource,
    55     CanvasRenderingContext2D::Style,
    56     CanvasRenderingContext2D::WindingRule,
    57     CanvasRenderingContext2D::ImageSmoothingQuality
    58 > CanvasActionParameterVariant;
     66    std::optional<float>
     67> RecordCanvasActionVariant;
    5968
    6069} // namespace WebCore

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

    r219902 r220008  
    2727
    2828#include "CachedModuleScriptLoader.cpp"
     29#include "CallTracer.cpp"
    2930#include "DOMWrapperWorld.cpp"
    3031#include "GCController.cpp"

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

    r219981 r220008  
    47254725        my $callTracingCallback = $attribute->extendedAttributes->{CallTracingCallback} || $interface->extendedAttributes->{CallTracingCallback};
    47264726        if ($callTracingCallback) {
    4727             AddToImplIncludes("CallTracer.h");
    4728 
    4729             push(@$outputArray, "    if (UNLIKELY(impl.callTracingActive()))\n");
    4730             push(@$outputArray, "        CallTracer::$callTracingCallback(impl, ASCIILiteral(\"" . $attribute->name . "\"));\n");
     4727            my @callTracerArguments = ();
     4728            GenerateCallTracer($outputArray, $callTracingCallback, $attribute->name, \@callTracerArguments, "    ");
    47314729        }
    47324730
    … …  
    49154913        my $callTracingCallback = $attribute->extendedAttributes->{CallTracingCallback} || $interface->extendedAttributes->{CallTracingCallback};
    49164914        if ($callTracingCallback) {
    4917             AddToImplIncludes("CallTracer.h");
    4918 
    4919             push(@$outputArray, "    if (UNLIKELY(impl.callTracingActive()))\n");
    4920             push(@$outputArray, "        CallTracer::$callTracingCallback(impl, ASCIILiteral(\"" . $attribute->name . "\"), { nativeValue });\n");
     4915            my $indent = "    ";
     4916            my @callTracerArguments = ();
     4917            push(@callTracerArguments, GenerateCallTracerParameter("nativeValue", $attribute->type, $indent));
     4918            GenerateCallTracer($outputArray, $callTracingCallback, $attribute->name, \@callTracerArguments, $indent);
    49214919        }
    49224920
    … …  
    60586056    my $callTracingCallback = $operation->extendedAttributes->{CallTracingCallback} || $interface->extendedAttributes->{CallTracingCallback};
    60596057    if ($callTracingCallback) {
    6060         AddToImplIncludes("CallTracer.h");
    6061 
    6062         my @inspectorRecordingArguments = ();
     6058        my @callTracerArguments = ();
    60636059        foreach my $argument (@{$operation->arguments}) {
    6064             push(@inspectorRecordingArguments, $argument->name);
    6065         }
    6066 
    6067         push(@$outputArray, $indent . "if (UNLIKELY(impl.callTracingActive()))\n");
    6068         push(@$outputArray, $indent . "    CallTracer::$callTracingCallback(impl, ASCIILiteral(\"" . $operation->name . "\"), { " . join(", ", @inspectorRecordingArguments) . " });\n");
     6060            push(@callTracerArguments, GenerateCallTracerParameter($argument->name, $argument->type, $indent));
     6061        }
     6062        GenerateCallTracer($outputArray, $callTracingCallback, $operation->name, \@callTracerArguments, $indent);
    60696063    }
    60706064
    … …  
    72657259}
    72667260
     7261sub GenerateCallTracerParameter()
     7262{
     7263    my ($name, $type, $indent) = @_;
     7264
     7265    if ($type->isUnion) {
     7266        return $indent . "    WTF::visit([&] (auto& value) { callTracerParameters.append(value); }, " . $name . ");";
     7267    }
     7268
     7269    return $indent . "    callTracerParameters.append(" . $name . ");";
     7270}
     7271
     7272sub GenerateCallTracer()
     7273{
     7274    my ($outputArray, $callTracingCallback, $name, $arguments, $indent) = @_;
     7275
     7276    AddToImplIncludes("CallTracer.h");
     7277
     7278    my $count = scalar(@$arguments);
     7279
     7280    push(@$outputArray, $indent . "if (UNLIKELY(impl.callTracingActive()))");
     7281    if ($count) {
     7282        push(@$outputArray, " {\n");
     7283        push(@$outputArray, $indent . "    Vector<" . $codeGenerator->WK_ucfirst($callTracingCallback) . "Variant> callTracerParameters;\n");
     7284        push(@$outputArray, join("\n", @$arguments));
     7285    }
     7286    push(@$outputArray, "\n");
     7287    push(@$outputArray, $indent . "    CallTracer::" . $callTracingCallback . "(impl, ASCIILiteral(\"" . $name . "\")");
     7288    if ($count) {
     7289        push(@$outputArray, ", WTFMove(callTracerParameters)");
     7290    }
     7291    push(@$outputArray, ");\n");
     7292    if ($count) {
     7293        push(@$outputArray, $indent . "}\n")
     7294    }
     7295}
     7296
    726772971;

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

    r219981 r220008  
    3131#include "JSDOMConvertNumbers.h"
    3232#include "JSDOMConvertStrings.h"
     33#include "JSDOMConvertUnion.h"
    3334#include "JSDOMExceptionHandling.h"
     35#include "JSDOMGlobalObject.h"
    3436#include "JSDOMOperation.h"
    3537#include "JSDOMWrapperCache.h"
    … …  
    3840#include <runtime/JSCInlines.h>
    3941#include <wtf/GetPtr.h>
     42#include <wtf/Variant.h>
    4043
    4144using namespace JSC;
    … …  
    4952JSC::EncodedJSValue JSC_HOST_CALL jsTestCallTracerPrototypeFunctionTestOperationWithArguments(JSC::ExecState*);
    5053JSC::EncodedJSValue JSC_HOST_CALL jsTestCallTracerPrototypeFunctionTestOperationWithNullableArgument(JSC::ExecState*);
     54JSC::EncodedJSValue JSC_HOST_CALL jsTestCallTracerPrototypeFunctionTestOperationWithVariantArgument(JSC::ExecState*);
    5155
    5256// Attributes
    … …  
    5862JSC::EncodedJSValue jsTestCallTracerTestAttributeSpecified(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
    5963bool setJSTestCallTracerTestAttributeSpecified(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     64JSC::EncodedJSValue jsTestCallTracerTestAttributeWithVariant(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     65bool setJSTestCallTracerTestAttributeWithVariant(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
    6066
    6167class JSTestCallTracerPrototype : public JSC::JSNonFinalObject {
    … …  
    108114    { "testAttributeInterface", CustomAccessor | DOMAttribute, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestCallTracerTestAttributeInterface), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestCallTracerTestAttributeInterface) } },
    109115    { "testAttributeSpecified", CustomAccessor | DOMAttribute, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestCallTracerTestAttributeSpecified), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestCallTracerTestAttributeSpecified) } },
     116    { "testAttributeWithVariant", CustomAccessor | DOMAttribute, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestCallTracerTestAttributeWithVariant), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestCallTracerTestAttributeWithVariant) } },
    110117    { "testOperationInterface", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestCallTracerPrototypeFunctionTestOperationInterface), (intptr_t) (0) } },
    111118    { "testOperationSpecified", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestCallTracerPrototypeFunctionTestOperationSpecified), (intptr_t) (0) } },
    112119    { "testOperationWithArguments", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestCallTracerPrototypeFunctionTestOperationWithArguments), (intptr_t) (3) } },
    113120    { "testOperationWithNullableArgument", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestCallTracerPrototypeFunctionTestOperationWithNullableArgument), (intptr_t) (1) } },
     121    { "testOperationWithVariantArgument", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestCallTracerPrototypeFunctionTestOperationWithVariantArgument), (intptr_t) (1) } },
    114122};
    115123
    … …  
    213221    auto nativeValue = convert<IDLBoolean>(state, value);
    214222    RETURN_IF_EXCEPTION(throwScope, false);
    215     if (UNLIKELY(impl.callTracingActive()))
    216         CallTracer::testCallTracerInterface(impl, ASCIILiteral("testAttributeInterface"), { nativeValue });
     223    if (UNLIKELY(impl.callTracingActive())) {
     224        Vector<TestCallTracerInterfaceVariant> callTracerParameters;
     225        callTracerParameters.append(nativeValue);
     226        CallTracer::testCallTracerInterface(impl, ASCIILiteral("testAttributeInterface"), WTFMove(callTracerParameters));
     227    }
    217228    impl.setTestAttributeInterface(WTFMove(nativeValue));
    218229    return true;
    … …  
    247258    auto nativeValue = convert<IDLBoolean>(state, value);
    248259    RETURN_IF_EXCEPTION(throwScope, false);
    249     if (UNLIKELY(impl.callTracingActive()))
    250         CallTracer::testCallTracerAttribute(impl, ASCIILiteral("testAttributeSpecified"), { nativeValue });
     260    if (UNLIKELY(impl.callTracingActive())) {
     261        Vector<TestCallTracerAttributeVariant> callTracerParameters;
     262        callTracerParameters.append(nativeValue);
     263        CallTracer::testCallTracerAttribute(impl, ASCIILiteral("testAttributeSpecified"), WTFMove(callTracerParameters));
     264    }
    251265    impl.setTestAttributeSpecified(WTFMove(nativeValue));
    252266    return true;
    … …  
    258272}
    259273
     274static inline JSValue jsTestCallTracerTestAttributeWithVariantGetter(ExecState& state, JSTestCallTracer& thisObject, ThrowScope& throwScope)
     275{
     276    UNUSED_PARAM(throwScope);
     277    UNUSED_PARAM(state);
     278    auto& impl = thisObject.wrapped();
     279    if (UNLIKELY(impl.callTracingActive()))
     280        CallTracer::testCallTracerInterface(impl, ASCIILiteral("testAttributeWithVariant"));
     281    JSValue result = toJS<IDLUnion<IDLBoolean, IDLFloat, IDLDOMString>>(state, *thisObject.globalObject(), impl.testAttributeWithVariant());
     282    return result;
     283}
     284
     285EncodedJSValue jsTestCallTracerTestAttributeWithVariant(ExecState* state, EncodedJSValue thisValue, PropertyName)
     286{
     287    return IDLAttribute<JSTestCallTracer>::get<jsTestCallTracerTestAttributeWithVariantGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "testAttributeWithVariant");
     288}
     289
     290static inline bool setJSTestCallTracerTestAttributeWithVariantSetter(ExecState& state, JSTestCallTracer& thisObject, JSValue value, ThrowScope& throwScope)
     291{
     292    UNUSED_PARAM(state);
     293    UNUSED_PARAM(throwScope);
     294    auto& impl = thisObject.wrapped();
     295    auto nativeValue = convert<IDLUnion<IDLBoolean, IDLFloat, IDLDOMString>>(state, value);
     296    RETURN_IF_EXCEPTION(throwScope, false);
     297    if (UNLIKELY(impl.callTracingActive())) {
     298        Vector<TestCallTracerInterfaceVariant> callTracerParameters;
     299        WTF::visit([&] (auto& value) { callTracerParameters.append(value); }, nativeValue);
     300        CallTracer::testCallTracerInterface(impl, ASCIILiteral("testAttributeWithVariant"), WTFMove(callTracerParameters));
     301    }
     302    impl.setTestAttributeWithVariant(WTFMove(nativeValue));
     303    return true;
     304}
     305
     306bool setJSTestCallTracerTestAttributeWithVariant(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     307{
     308    return IDLAttribute<JSTestCallTracer>::set<setJSTestCallTracerTestAttributeWithVariantSetter>(*state, thisValue, encodedValue, "testAttributeWithVariant");
     309}
     310
    260311static inline JSC::EncodedJSValue jsTestCallTracerPrototypeFunctionTestOperationInterfaceBody(JSC::ExecState* state, typename IDLOperation<JSTestCallTracer>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
    261312{
    … …  
    264315    auto& impl = castedThis->wrapped();
    265316    if (UNLIKELY(impl.callTracingActive()))
    266         CallTracer::testCallTracerInterface(impl, ASCIILiteral("testOperationInterface"), {  });
     317        CallTracer::testCallTracerInterface(impl, ASCIILiteral("testOperationInterface"));
    267318    impl.testOperationInterface();
    268319    return JSValue::encode(jsUndefined());
    … …  
    280331    auto& impl = castedThis->wrapped();
    281332    if (UNLIKELY(impl.callTracingActive()))
    282         CallTracer::testCallTracerOperation(impl, ASCIILiteral("testOperationSpecified"), {  });
     333        CallTracer::testCallTracerOperation(impl, ASCIILiteral("testOperationSpecified"));
    283334    impl.testOperationSpecified();
    284335    return JSValue::encode(jsUndefined());
    … …  
    303354    auto c = convert<IDLDOMString>(*state, state->uncheckedArgument(2));
    304355    RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
    305     if (UNLIKELY(impl.callTracingActive()))
    306         CallTracer::testCallTracerInterface(impl, ASCIILiteral("testOperationWithArguments"), { a, b, c });
     356    if (UNLIKELY(impl.callTracingActive())) {
     357        Vector<TestCallTracerInterfaceVariant> callTracerParameters;
     358        callTracerParameters.append(a);
     359        callTracerParameters.append(b);
     360        callTracerParameters.append(c);
     361        CallTracer::testCallTracerInterface(impl, ASCIILiteral("testOperationWithArguments"), WTFMove(callTracerParameters));
     362    }
    307363    impl.testOperationWithArguments(WTFMove(a), WTFMove(b), WTFMove(c));
    308364    return JSValue::encode(jsUndefined());
    … …  
    323379    auto nodeNullableArg = convert<IDLNullable<IDLInterface<Node>>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "nodeNullableArg", "TestCallTracer", "testOperationWithNullableArgument", "Node"); });
    324380    RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
    325     if (UNLIKELY(impl.callTracingActive()))
    326         CallTracer::testCallTracerInterface(impl, ASCIILiteral("testOperationWithNullableArgument"), { nodeNullableArg });
     381    if (UNLIKELY(impl.callTracingActive())) {
     382        Vector<TestCallTracerInterfaceVariant> callTracerParameters;
     383        callTracerParameters.append(nodeNullableArg);
     384        CallTracer::testCallTracerInterface(impl, ASCIILiteral("testOperationWithNullableArgument"), WTFMove(callTracerParameters));
     385    }
    327386    impl.testOperationWithNullableArgument(WTFMove(nodeNullableArg));
    328387    return JSValue::encode(jsUndefined());
    … …  
    332391{
    333392    return IDLOperation<JSTestCallTracer>::call<jsTestCallTracerPrototypeFunctionTestOperationWithNullableArgumentBody>(*state, "testOperationWithNullableArgument");
     393}
     394
     395static inline JSC::EncodedJSValue jsTestCallTracerPrototypeFunctionTestOperationWithVariantArgumentBody(JSC::ExecState* state, typename IDLOperation<JSTestCallTracer>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
     396{
     397    UNUSED_PARAM(state);
     398    UNUSED_PARAM(throwScope);
     399    auto& impl = castedThis->wrapped();
     400    if (UNLIKELY(state->argumentCount() < 1))
     401        return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
     402    auto variantArg = convert<IDLUnion<IDLBoolean, IDLFloat, IDLDOMString>>(*state, state->uncheckedArgument(0));
     403    RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
     404    if (UNLIKELY(impl.callTracingActive())) {
     405        Vector<TestCallTracerInterfaceVariant> callTracerParameters;
     406        WTF::visit([&] (auto& value) { callTracerParameters.append(value); }, variantArg);
     407        CallTracer::testCallTracerInterface(impl, ASCIILiteral("testOperationWithVariantArgument"), WTFMove(callTracerParameters));
     408    }
     409    impl.testOperationWithVariantArgument(WTFMove(variantArg));
     410    return JSValue::encode(jsUndefined());
     411}
     412
     413EncodedJSValue JSC_HOST_CALL jsTestCallTracerPrototypeFunctionTestOperationWithVariantArgument(ExecState* state)
     414{
     415    return IDLOperation<JSTestCallTracer>::call<jsTestCallTracerPrototypeFunctionTestOperationWithVariantArgumentBody>(*state, "testOperationWithVariantArgument");
    334416}
    335417

  • trunk/Source/WebCore/bindings/scripts/test/TestCallTracer.idl

    r219964 r220008  
    2424 */
    2525
     26typedef (boolean or float or DOMString) VariantType;
     27
    2628[
    2729    CallTracingCallback=testCallTracerInterface,
    … …  
    3032    [CallTracingCallback=testCallTracerAttribute] attribute boolean testAttributeSpecified;
    3133
     34    attribute VariantType testAttributeWithVariant;
     35
    3236    void testOperationInterface();
    3337    [CallTracingCallback=testCallTracerOperation] void testOperationSpecified();
    … …  
    3539    void testOperationWithArguments(boolean a, float b, DOMString c);
    3640    void testOperationWithNullableArgument(Node? nodeNullableArg);
     41    void testOperationWithVariantArgument(VariantType variantArg);
    3742};
    3843

  • trunk/Source/WebCore/html/HTMLCanvasElement.cpp

    r219902 r220008  
    506506void HTMLCanvasElement::paint(GraphicsContext& context, const LayoutRect& r)
    507507{
     508    if (UNLIKELY(m_context && m_context->callTracingActive()))
     509        InspectorInstrumentation::didFinishRecordingCanvasFrame(*this);
     510
    508511    // Clear the dirty rect
    509512    m_dirtyRect = FloatRect();

  • trunk/Source/WebCore/html/canvas/CanvasRenderingContext2D.idl

    r219619 r220008  
    3838    JSGenerateToJSObject,
    3939    JSCustomMarkFunction,
     40    CallTracingCallback=recordCanvasAction,
    4041] interface CanvasRenderingContext2D {
    4142

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

    r219964 r220008  
    100100}
    101101
    102 void InspectorCanvas::recordAction(const String& name, Vector<CanvasActionParameterVariant>&& parameters)
     102void InspectorCanvas::recordAction(const String& name, Vector<RecordCanvasActionVariant>&& parameters)
    103103{
    104104    if (!hasRecordingData()) {
    … …  
    386386}
    387387
    388 RefPtr<Inspector::Protocol::Array<Inspector::InspectorValue>> InspectorCanvas::buildAction(const String& name, Vector<CanvasActionParameterVariant>&& parameters)
     388RefPtr<Inspector::Protocol::Array<Inspector::InspectorValue>> InspectorCanvas::buildAction(const String& name, Vector<RecordCanvasActionVariant>&& parameters)
    389389{
    390390    RefPtr<Inspector::Protocol::Array<InspectorValue>> action = Inspector::Protocol::Array<InspectorValue>::create();
    391     action->addItem(static_cast<double>(indexForData(name)));
     391    action->addItem(indexForData(name));
    392392
    393393    RefPtr<Inspector::Protocol::Array<InspectorValue>> parametersData = Inspector::Protocol::Array<Inspector::InspectorValue>::create();
    394     for (CanvasActionParameterVariant& item : parameters) {
     394    for (RecordCanvasActionVariant& item : parameters) {
    395395        WTF::switchOn(item,
    396             [&] (const Element*) {
    397                 // Elements are not serializable, so add a string as a placeholder since the actual
    398                 // element cannot be reconstructed in the frontend.
    399                 parametersData->addItem(indexForData(String("element")));
     396            [&] (const CanvasRenderingContext2D::WindingRule& value) {
     397                String windingRule = CanvasRenderingContext2D::stringForWindingRule(value);
     398                parametersData->addItem(indexForData(windingRule));
    400399            },
    401             [&] (const HTMLImageElement* value) { parametersData->addItem(indexForData(value)); },
    402             [&] (const ImageData* value) {
    403                 if (value)
    404                     parametersData->addItem(indexForData(value));
     400            [&] (const CanvasRenderingContext2D::ImageSmoothingQuality& value) {
     401                String imageSmoothingQuality = CanvasRenderingContext2D::stringForImageSmoothingQuality(value);
     402                parametersData->addItem(indexForData(imageSmoothingQuality));
    405403            },
    406404            [&] (const DOMMatrixInit& value) {
    … …  
    415413            },
    416414            [&] (const DOMPath* value) { parametersData->addItem(indexForData(buildStringFromPath(value->path()))); },
     415            [&] (const Element*) {
     416                // Elements are not serializable, so add a string as a placeholder since the actual
     417                // element cannot be reconstructed in the frontend.
     418                parametersData->addItem(indexForData(String("element")));
     419            },
     420            [&] (HTMLImageElement* value) { parametersData->addItem(indexForData(value)); },
     421            [&] (ImageData* value) {
     422                if (value)
     423                    parametersData->addItem(indexForData(value));
     424            },
     425            [&] (const RefPtr<CanvasGradient>& value) { parametersData->addItem(indexForData(value.get())); },
     426            [&] (const RefPtr<CanvasPattern>& value) { parametersData->addItem(indexForData(value.get())); },
     427            [&] (RefPtr<HTMLCanvasElement>& value) { parametersData->addItem(indexForData(value.get())); },
     428            [&] (const RefPtr<HTMLImageElement>& value) { parametersData->addItem(indexForData(value.get())); },
     429#if ENABLE(VIDEO)
     430            [&] (RefPtr<HTMLVideoElement>& value) { parametersData->addItem(indexForData(value.get())); },
     431#endif
    417432            [&] (const Vector<float>& value) { parametersData->addItem(buildArrayForVector(value)); },
    418433            [&] (const String& value) { parametersData->addItem(indexForData(value)); },
    … …  
    424439                if (value)
    425440                    parametersData->addItem(value.value());
    426             },
    427             [&] (CanvasImageSource& canvasImageSource) {
    428                 WTF::switchOn(canvasImageSource,
    429                     [&] (const RefPtr<HTMLImageElement>& value) { parametersData->addItem(indexForData(value.get())); },
    430 #if ENABLE(VIDEO)
    431                     [&] (RefPtr<HTMLVideoElement>& value) { parametersData->addItem(indexForData(value.get())); },
    432 #endif
    433                     [&] (RefPtr<HTMLCanvasElement>& value) { parametersData->addItem(indexForData(value.get())); }
    434                 );
    435             },
    436             [&] (const CanvasRenderingContext2D::Style& style) {
    437                 WTF::switchOn(style,
    438                     [&] (const String& value) { parametersData->addItem(indexForData(value)); },
    439                     [&] (const RefPtr<CanvasGradient>& value) { parametersData->addItem(indexForData(value.get())); },
    440                     [&] (const RefPtr<CanvasPattern>& value) { parametersData->addItem(indexForData(value.get())); }
    441                 );
    442             },
    443             [&] (CanvasRenderingContext2D::WindingRule value) {
    444                 String windingRule = CanvasRenderingContext2D::stringForWindingRule(value);
    445                 parametersData->addItem(indexForData(windingRule));
    446             },
    447             [&] (CanvasRenderingContext2D::ImageSmoothingQuality value) {
    448                 String imageSmoothingQuality = CanvasRenderingContext2D::stringForImageSmoothingQuality(value);
    449                 parametersData->addItem(indexForData(imageSmoothingQuality));
    450441            }
    451442        );

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

    r219964 r220008  
    4848typedef String ErrorString;
    4949
    50 typedef Variant<
    51     const HTMLImageElement*,
    52 #if ENABLE(VIDEO)
    53     HTMLVideoElement*,
    54 #endif
    55     HTMLCanvasElement*,
    56     const CanvasGradient*,
    57     const CanvasPattern*,
    58     const ImageData*,
    59     String
    60 > DuplicateDataVariant;
    61 
    6250class InspectorCanvas final : public RefCounted<InspectorCanvas> {
    6351public:
    … …  
    7058    void resetRecordingData();
    7159    bool hasRecordingData() const;
    72     void recordAction(const String&, Vector<CanvasActionParameterVariant>&& = { });
     60    void recordAction(const String&, Vector<RecordCanvasActionVariant>&& = { });
    7361
    7462    RefPtr<Inspector::Protocol::Recording::InitialState>&& releaseInitialState() { return WTFMove(m_initialState); }
    … …  
    9280    InspectorCanvas(HTMLCanvasElement&, const String& cssCanvasName);
    9381
     82    typedef Variant<
     83        CanvasGradient*,
     84        CanvasPattern*,
     85        HTMLCanvasElement*,
     86        HTMLImageElement*,
     87#if ENABLE(VIDEO)
     88        HTMLVideoElement*,
     89#endif
     90        ImageData*,
     91        String
     92    > DuplicateDataVariant;
     93
    9494    int indexForData(DuplicateDataVariant);
    9595    RefPtr<Inspector::Protocol::Recording::InitialState> buildInitialState();
    96     RefPtr<Inspector::Protocol::Array<Inspector::InspectorValue>> buildAction(const String&, Vector<CanvasActionParameterVariant>&& = { });
     96    RefPtr<Inspector::Protocol::Array<Inspector::InspectorValue>> buildAction(const String&, Vector<RecordCanvasActionVariant>&& = { });
    9797    RefPtr<Inspector::Protocol::Array<Inspector::InspectorValue>> buildArrayForCanvasGradient(const CanvasGradient&);
    9898    RefPtr<Inspector::Protocol::Array<Inspector::InspectorValue>> buildArrayForCanvasPattern(const CanvasPattern&);

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

    r219964 r220008  
    2727#include "InspectorCanvasAgent.h"
    2828
    29 #include "CanvasGradient.h"
    30 #include "CanvasPattern.h"
    3129#include "CanvasRenderingContext.h"
    3230#include "CanvasRenderingContext2D.h"
    33 #include "DOMMatrixInit.h"
    34 #include "DOMPath.h"
    3531#include "Document.h"
    3632#include "Element.h"
    3733#include "Frame.h"
    38 #include "HTMLCanvasElement.h"
    39 #include "HTMLImageElement.h"
    40 #include "HTMLVideoElement.h"
    41 #include "ImageData.h"
    4234#include "InspectorDOMAgent.h"
    4335#include "InstrumentingAgents.h"
    … …  
    338330}
    339331
    340 void InspectorCanvasAgent::recordCanvasAction(CanvasRenderingContext& canvasRenderingContext, const String& name, Vector<CanvasActionParameterVariant>&& parameters)
     332void InspectorCanvasAgent::recordCanvasAction(CanvasRenderingContext& canvasRenderingContext, const String& name, Vector<RecordCanvasActionVariant>&& parameters)
    341333{
    342334    HTMLCanvasElement& canvasElement = canvasRenderingContext.canvas();

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

    r219964 r220008  
    7676    void didCreateCanvasRenderingContext(HTMLCanvasElement&);
    7777    void didChangeCanvasMemory(HTMLCanvasElement&);
    78     void recordCanvasAction(CanvasRenderingContext&, const String&, Vector<CanvasActionParameterVariant>&& = { });
     78    void recordCanvasAction(CanvasRenderingContext&, const String&, Vector<RecordCanvasActionVariant>&& = { });
    7979    void didFinishRecordingCanvasFrame(HTMLCanvasElement&, bool forceDispatch = false);
    8080

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

    r219964 r220008  
    981981}
    982982
    983 void InspectorInstrumentation::recordCanvasActionImpl(InstrumentingAgents* instrumentingAgents, CanvasRenderingContext& canvasRenderingContext, const String& name, Vector<CanvasActionParameterVariant>&& parameters)
     983void InspectorInstrumentation::recordCanvasActionImpl(InstrumentingAgents* instrumentingAgents, CanvasRenderingContext& canvasRenderingContext, const String& name, Vector<RecordCanvasActionVariant>&& parameters)
    984984{
    985985    if (InspectorCanvasAgent* canvasAgent = instrumentingAgents->inspectorCanvasAgent())

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

    r219964 r220008  
    3434#include "CSSSelector.h"
    3535#include "CallTracerTypes.h"
    36 #include "CanvasGradient.h"
    37 #include "CanvasPattern.h"
    3836#include "CanvasRenderingContext.h"
    39 #include "DOMPath.h"
    4037#include "DocumentThreadableLoader.h"
    4138#include "Element.h"
    … …  
    4340#include "Frame.h"
    4441#include "HTMLCanvasElement.h"
    45 #include "HTMLImageElement.h"
    46 #include "HTMLVideoElement.h"
    4742#include "HitTestResult.h"
    48 #include "ImageData.h"
    4943#include "InspectorController.h"
    5044#include "InspectorInstrumentationCookie.h"
    … …  
    233227    static void didCreateCanvasRenderingContext(HTMLCanvasElement&);
    234228    static void didChangeCanvasMemory(HTMLCanvasElement&);
    235     static void recordCanvasAction(CanvasRenderingContext&, const String&, Vector<CanvasActionParameterVariant>&& = { });
     229    static void recordCanvasAction(CanvasRenderingContext&, const String&, Vector<RecordCanvasActionVariant>&& = { });
    236230    static void didFinishRecordingCanvasFrame(HTMLCanvasElement&, bool forceDispatch = false);
    237231
    … …  
    392386    static void didCreateCanvasRenderingContextImpl(InstrumentingAgents*, HTMLCanvasElement&);
    393387    static void didChangeCanvasMemoryImpl(InstrumentingAgents*, HTMLCanvasElement&);
    394     static void recordCanvasActionImpl(InstrumentingAgents*, CanvasRenderingContext&, const String&, Vector<CanvasActionParameterVariant>&& = { });
     388    static void recordCanvasActionImpl(InstrumentingAgents*, CanvasRenderingContext&, const String&, Vector<RecordCanvasActionVariant>&& = { });
    395389    static void didFinishRecordingCanvasFrameImpl(InstrumentingAgents*, HTMLCanvasElement&, bool forceDispatch = false);
    396390
    … …  
    10991093}
    11001094
    1101 inline void InspectorInstrumentation::recordCanvasAction(CanvasRenderingContext& canvasRenderingContext, const String& name, Vector<CanvasActionParameterVariant>&& parameters)
     1095inline void InspectorInstrumentation::recordCanvasAction(CanvasRenderingContext& canvasRenderingContext, const String& name, Vector<RecordCanvasActionVariant>&& parameters)
    11021096{
    11031097    FAST_RETURN_IF_NO_FRONTENDS(void());
Note: See TracChangeset for help on using the changeset viewer.