bindings,devtools: Shows DOM attributes' values in DevTools.

Source/core/inspector/InjectedScriptSource.js

 /*
  * Copyright (C) 2007 Apple Inc.  All rights reserved.
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 202 matching lines @@
 
     while (k < len) {
         if (str[k] === searchElement)
             return k;
         ++k;
     }
     return -1;
 }
 
 /**
+ * DOM Attributes which have observable side effect on getter, in the form of
+ *   {interfaceName1: {attributeName1: true,
+ *                     attributeName2: true,
+ *                     ...},
+ *    interfaceName2: {...},
+ *    ...}
+ * @type {!Object<string, !Object<string, boolean>>}
+ * @const
+ */
+var domAttributesWithObservableSideEffectOnGet = InjectedScriptHost.getDOMAttributesWithObservableSideEffectOnGet();

[pfeldman, 2015/03/09 11:41:41]

var domAttributesWithObservableSideEffectOnGet = nullifyObjectProto({});
domAttributesWithObservableSideEffectOnGet["Request"] = nullifyObjectProto({});
domAttributesWithObservableSideEffectOnGet["Request"]["body"] = true;

[Yuki, 2015/03/09 12:48:13]

Done.

+
+/**
+ * @param {!Object} object
+ * @param {!string} attribute
+ * @return {boolean}
+ */
+function doesAttributeHaveObservableSideEffectOnGet(object, attribute)
+{
+    for (var interfaceName in domAttributesWithObservableSideEffectOnGet) {
+        var isInstance = InjectedScriptHost.suppressWarningsAndCallFunction(function(object, interfaceName) {
+            return typeof window[interfaceName] === "function" && object instanceof window[interfaceName];

[pfeldman, 2015/03/09 11:41:41]

This is no better than what it used to be as long as we are fetching the
window[interfaceName]. Page can easily override it. Our options are:

1) not care about it at all, which might lead to a new devtools detection
technique
2) fix it as I was suggesting via returning the canonical types from the
bindings:

var types = InjectedScriptHost.canonicalTypes(object); // returns ["Request",
"Object"]
for (var i = 0; i < types.length; ++i) {
    if (domAttrsWithSideEffects[types[i]] &&
domAttrsWithSideEffects[types[i]][attribute])
        return true;
}
return false;

[Yuki, 2015/03/09 12:48:13]

I prefer option 1.  I don't think it's worth creating a new mechanism to
retrieve class inheritance info as string, which we don't have for now.

We already check that the given object is a DOM wrapper.  I think it's enough.

+        }, null, [object, interfaceName]);
+        if (isInstance) {
+            return attribute in domAttributesWithObservableSideEffectOnGet[interfaceName];
+        }
+    }
+    return false;
+}
+
+/**
  * @constructor
  */
 var InjectedScript = function()
 {
     /** @type {!Object.<string, !Object>} */
     this._modules = { __proto__: null };
 }
 
 /**
  * @type {!Object.<string, boolean>}
@@ skipping 315 matching lines @@
                 var name = property;
                 if (isSymbol(property))
                     name = injectedScript._describe(property);
 
                 try {
                     propertyProcessed[property] = true;
                     var descriptor = nullifyObjectProto(InjectedScriptHost.suppressWarningsAndCallFunction(Object.getOwnPropertyDescriptor, Object, [o, property]));
                     if (descriptor) {
                         if (accessorPropertiesOnly && !("get" in descriptor || "set" in descriptor))
                             continue;
-                        if ("get" in descriptor && "set" in descriptor && InjectedScriptHost.isPopularDOMObject(object) && name != "__proto__") {
+                        if ("get" in descriptor && "set" in descriptor && name != "__proto__" && InjectedScriptHost.isDOMWrapper(object) && !doesAttributeHaveObservableSideEffectOnGet(object, name)) {
                             descriptor.value = InjectedScriptHost.suppressWarningsAndCallFunction(function(attribute) { return this[attribute]; }, object, [name]);
                             delete descriptor.get;
                             delete descriptor.set;
                         }
                     } else {
                         // Not all bindings provide proper descriptors. Fall back to the writable, configurable property.
                         if (accessorPropertiesOnly)
                             continue;
                         try {
                             descriptor = { name: name, value: o[property], writable: false, configurable: false, enumerable: false, __proto__: null };
@@ skipping 940 matching lines @@
         if (middle) {
             var leftHalf = maxLength >> 1;
             var rightHalf = maxLength - leftHalf - 1;
             return string.substr(0, leftHalf) + "\u2026" + string.substr(string.length - rightHalf, rightHalf);
         }
         return string.substr(0, maxLength) + "\u2026";
     },
 
     __proto__: null
 }
+
 /**
  * @constructor
  * @param {number} ordinal
  * @param {!JavaScriptCallFrame} callFrame
  * @param {number} asyncOrdinal
  */
 InjectedScript.CallFrameProxy = function(ordinal, callFrame, asyncOrdinal)
 {
     this.callFrameId = "{\"ordinal\":" + ordinal + ",\"injectedScriptId\":" + injectedScriptId + (asyncOrdinal ? ",\"asyncOrdinal\":" + asyncOrdinal : "") + "}";
     this.functionName = (callFrame.type === "function" ? callFrame.functionName : "");
@@ skipping 400 matching lines @@
      */
     _logEvent: function(event)
     {
         inspectedWindow.console.log(event.type, event);
     }
 }
 
 injectedScript._commandLineAPIImpl = new CommandLineAPIImpl();
 return injectedScript;
 })