[inspector] better isArrayLike for injected-script-source.js

src/inspector/injected-script-source.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 96 matching lines @@
 
 /**
  * FireBug's array detection.
  * @param {*} obj
  * @return {boolean}
  */
 function isArrayLike(obj)
 {
     if (typeof obj !== "object")
         return false;
-    try {
-        if (typeof obj.splice === "function") {
-            if (!InjectedScriptHost.objectHasOwnProperty(/** @type {!Object} */ (obj), "length"))
-                return false;
-            var len = obj.length;
-            return typeof len === "number" && isUInt32(len);
-        }
-    } catch (e) {
+    var splice = InjectedScriptHost.getProperty(obj, "splice");
+    if (typeof splice === "function") {
+        if (!InjectedScriptHost.objectHasOwnProperty(/** @type {!Object} */ (obj), "length"))
+            return false;
+        var len = InjectedScriptHost.getProperty(obj, "length");
+        return typeof len === "number" && isUInt32(len);
     }
     return false;
 }
 
 /**
  * @param {number} a
  * @param {number} b
  * @return {number}
  */
 function max(a, b)
@@ skipping 250 matching lines @@
      * @param {!Object} object
      * @param {!function(!Array<!Object>, !Object)} addPropertyIfNeeded
      * @param {boolean=} ownProperties
      * @param {boolean=} accessorPropertiesOnly
      * @param {?Array<string>=} propertyNamesOnly
      * @return {!Array<!Object>}
      */
     _propertyDescriptors: function(object, addPropertyIfNeeded, ownProperties, accessorPropertiesOnly, propertyNamesOnly)
     {
         var descriptors = [];
-        descriptors.__proto__ = null;
+        InjectedScriptHost.nullifyPrototype(descriptors);
         var propertyProcessed = { __proto__: null };
         var subtype = InjectedScriptHost.subtype(object);
 
         /**
          * @param {!Object} o
          * @param {!Array<string|number|symbol>=} properties
          * @param {number=} objectLength
          * @return {boolean}
          */
         function process(o, properties, objectLength)
@@ skipping 10 matching lines @@
                     name = /** @type {string} */ (injectedScript._describe(property));
                 else
                     name = typeof property === "number" ? ("" + property) : /** @type {string} */(property);
 
                 if (subtype === "internal#scopeList" && name === "length")
                     continue;
 
                 var descriptor;
                 try {
                     descriptor = Object.getOwnPropertyDescriptor(o, property);
+                    InjectedScriptHost.nullifyPrototype(descriptor);
                     var isAccessorProperty = descriptor && ("get" in descriptor || "set" in descriptor);
                     if (accessorPropertiesOnly && !isAccessorProperty)
                         continue;
                     if (descriptor && "get" in descriptor && "set" in descriptor && name !== "__proto__" &&
                             InjectedScriptHost.formatAccessorsAsProperties(object, descriptor.get) &&
                             !doesAttributeHaveObservableSideEffectOnGet(object, name)) {
                         descriptor.value = object[property];
                         descriptor.isOwn = true;
                         delete descriptor.get;
                         delete descriptor.set;
                     }
                 } catch (e) {
                     if (accessorPropertiesOnly)
                         continue;
-                    descriptor = { value: e, wasThrown: true };
+                    descriptor = { value: e, wasThrown: true, __proto__: null };
                 }
 
                 // Not all bindings provide proper descriptors. Fall back to the non-configurable, non-enumerable,
                 // non-writable property.
                 if (!descriptor) {
                     try {
-                        descriptor = { value: o[property], writable: false };
+                        descriptor = { value: o[property], writable: false, __proto__: null };
                     } catch (e) {
                         // Silent catch.
                         continue;
                     }
                 }
 
                 descriptor.name = name;
                 if (o === object)
                     descriptor.isOwn = true;
                 if (isSymbol(property))
@@ skipping 628 matching lines @@
             return string.substr(0, leftHalf) + "\u2026" + string.substr(string.length - rightHalf, rightHalf);
         }
         return string.substr(0, maxLength) + "\u2026";
     },
 
     __proto__: null
 }
 
 return injectedScript;
 })