Pass current value of attributes to WebDOMActivityLogger Setter logs.

Source/bindings/templates/attributes.cpp

 {##############################################################################}
 {% macro attribute_getter(attribute, world_suffix) %}
 {% filter conditional(attribute.conditional_string) %}
 static void {{attribute.name}}AttributeGetter{{world_suffix}}(
 {%- if attribute.is_expose_js_accessors %}
 const v8::FunctionCallbackInfo<v8::Value>& info
 {%- else %}
 const v8::PropertyCallbackInfo<v8::Value>& info
 {%- endif %})
 {
@@ skipping 148 matching lines @@
     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
     {% if attribute.deprecate_as %}
     UseCounter::countDeprecation(callingExecutionContext(info.GetIsolate()), UseCounter::{{attribute.deprecate_as}});
     {% endif %}
     {% if attribute.measure_as %}
     UseCounter::count(callingExecutionContext(info.GetIsolate()), UseCounter::{{attribute.measure_as}});
     {% endif %}
     {% if world_suffix in attribute.activity_logging_world_list_for_getter %}
     V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->GetCurrentContext());
     if (contextData && contextData->activityLogger())
-        contextData->activityLogger()->log("{{interface_name}}.{{attribute.name}}", 0, 0, "Getter");
+        contextData->activityLogger()->logGetter("{{interface_name}}.{{attribute.name}}");
     {% endif %}
     {% if attribute.has_custom_getter %}
     {{v8_class}}::{{attribute.name}}AttributeGetterCustom(info);
     {% else %}
     {{cpp_class}}V8Internal::{{attribute.name}}AttributeGetter{{world_suffix}}(info);
     {% endif %}
     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 }
 {% endfilter %}
 {% endmacro %}
@@ skipping 113 matching lines @@
     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
     {% if attribute.deprecate_as %}
     UseCounter::countDeprecation(callingExecutionContext(info.GetIsolate()), UseCounter::{{attribute.deprecate_as}});
     {% endif %}
     {% if attribute.measure_as %}
     UseCounter::count(callingExecutionContext(info.GetIsolate()), UseCounter::{{attribute.measure_as}});
     {% endif %}
     {% if world_suffix in attribute.activity_logging_world_list_for_setter %}
     V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->GetCurrentContext());
     if (contextData && contextData->activityLogger()) {
-        v8::Handle<v8::Value> loggerArg[] = { jsValue };
-        contextData->activityLogger()->log("{{interface_name}}.{{attribute.name}}", 1, &loggerArg[0], "Setter");
+        v8::Handle<v8::Value> HACK;

[Devlin, 2014/03/26 22:58:42]

I'm a bit at a loss for how to best get the current value.  It boils down to
something like:
{{cpp_class}}* impl = {{v8_class}::toNative(info.Holder());
v8::Handle<v8::Value> currentValue = impl->get{{attribute.name}}

But I'm missing a few things in there (looking at the attribute_getter code at
the top, I know there's a lot of subtle things here)...

[Nils Barth (inactive), 2014/03/27 02:20:08]

?
Can't you just pass in jsValue (sans array),
as that's what's currently being done?

[Nils Barth (inactive), 2014/03/27 02:39:50]

OIC, sorry, the point of this CL is to add this value;
I'd been distracted by the refactoring.
Let me take a closer look.

[Nils Barth (inactive), 2014/03/27 02:51:25]

Simplest would be if you could just call the *AttributeGetter function, no?

Failing that, {{attribute.cpp_value}} will generally hold the value
(as a C++ expression), but if {{attribute.cpp_value_original}} exists
you'll need to use that instead (sometimes store value in a local
variable).
Could you see if this works?

[Devlin, 2014/03/27 20:35:30]

(I've never worked on the bindings before, so I might be missing something very
obvious.  If so, my apologies.)

We might be able to just call *AttributeGetter, but we'd need to pass in some
form of callback, right?  Can we do that from here safely?

For the other approach, doing something like:

{{cpp_class}}* impl = {{v8_class}}::toNative(info.Holder());
{% if attribute.cpp_value_original %}
{{attribute.cpp_type}} original = {{attribute.cpp_value_original}};
{% else %}
{{attribute.cpp_type}} original = {{attribute.cpp_value}};
{% endif %}
v8::Handle<v8::Value> originalValue = {{cpp_to_v8_conversion}};
contextData->activityLogger()->logSetter("{{interface_name}}.{{attribute.name}},
jsValue, originalValue);

almost works, with the problem that {{cpp_to_v8_conversion}} doesn't exist (at
least, not here).  Is there an easy way to solve that (or does it already exist,
under a name I couldn't find)?

[pmarch, 2014/04/17 16:10:58]

I am not an expert on this, but it looks to me that  {{cpp_to_v8_conversion}} 
which can convert arbitrary cpp values to JS values does not exist.

You need to check the type of oldValue and generate conversion code specific to
this type. The conversion code needs to use V8 API to produce JS values.

From my previous comment, if you chose to track only HTMLIFrameElement.src then
the oldValue type is sting and you need to create an external string. Note that
V8 binding code use cache for fast string conversions which would be nice to use
as well. See
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...

On 2014/03/27 20:35:30, D Cronin wrote:

+        contextData->activityLogger()->logSetter("{{interface_name}}.{{attribute.name}}", jsValue, HACK);
     }
     {% endif %}
     {% if attribute.is_custom_element_callbacks or attribute.is_reflect %}
     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
     {% endif %}
     {% if attribute.has_custom_setter %}
     {{v8_class}}::{{attribute.name}}AttributeSetterCustom(jsValue, info);
     {% else %}
     {{cpp_class}}V8Internal::{{attribute.name}}AttributeSetter{{world_suffix}}(jsValue, info);
     {% endif %}
     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 }
 {% endfilter %}
 {% endmacro %}