[chromedriver] Added option to make element references W3C compliant.

chrome/test/chromedriver/js/call_function.js

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /**
  * Enum for WebDriver status codes.
  * @enum {number}
  */
 var StatusCode = {
   STALE_ELEMENT_REFERENCE: 10,
@@ skipping 10 matching lines @@
 };
 
 /**
  * Dictionary key to use for holding an element ID.
  * @const
  * @type {string}
  */
 var ELEMENT_KEY = 'ELEMENT';
 
 /**
+ * True if using W3C Element references.
+ * @const
+ * @type {boolean}
+ */
+var w3cEnabled = false;

[samuong, 2016/08/11 20:45:14]

if you're going to have this here, is there a need to add an argument to
getPageCache()?

although i think it might be slightly better to just pass it to wrap as an
argument...

+
+/**
  * True if shadow dom is enabled.
  * @const
  * @type {boolean}
  */
 var SHADOW_DOM_ENABLED = typeof ShadowRoot === 'function';
 
 /**
+ * Generates a unique ID to identify an element.
+ * @void
+ * @return {string} Randomly generated ID.
+ */
+function generateUUID() {
+  var UUID = "";
+  for (var i = 0; i < 16; i++) {
+    if (i == 6 || i == 12 || i == 14 || i == 15) {
+      UUID += "00";
+    } else if (i == 7 || i == 13) {
+      UUID += "01";

[samuong, 2016/08/11 20:45:14]

If I'm reading https://tools.ietf.org/html/rfc4122 correctly, version 1 UUIDs
are generated using the MAC address and a timer. Since you're generating these
from random numbers, you should be setting the version (the 13th hex digit) to
4.

For the 17th hex digit, the most significant two bits should be 10, which means
that the hex representation for this octet should be one of [89ab].

Other octets should be generated randomly, not set to 00 or 01.

+    } else {
+      var rand = Math.round(Math.random() * 225).toString(16);

[samuong, 2016/08/11 20:45:14]

Let's use window.crypto.getRandomValues() instead of Math.random():

https://developer.mozilla.org/en-US/docs/Web/API/RandomSource/getRandomValues

Also, a UUID should always have 32 hex digits, but I don't always get the same
length each time I run this function:

generateUUID().replace(/-/g, '').length
32
generateUUID().replace(/-/g, '').length
31
generateUUID().replace(/-/g, '').length
32
generateUUID().replace(/-/g, '').length
32
generateUUID().replace(/-/g, '').length
31
generateUUID().replace(/-/g, '').length
30

This is because the toString() function will not always left-pad with 0s.

Please add a test that generates many UUIDs and checks that they are all valid.
It should look at the length of the UUID (including the length of each
individual field) and check that all the characters are hex (0-9a-f) except for
the hyphens, which should be in the right place.

+      UUID += rand;
+    }
+    if (i == 3 || i == 5 || i == 7 || i == 9) {
+      UUID += "-";
+    }
+  }
+  return UUID;
+};
+
+/**
+ * A cache which maps IDs <-> cached objects for the purpose of identifying
+ * a script object remotely. Uses UUIDs for identification.
+ * @constructor
+ */
+function CacheWithUUID() {
+  this.cache_ = {};
+}
+
+CacheWithUUID.prototype = {
+  /**
+   * Stores a given item in the cache and returns a unique UUID.
+   *
+   * @param {!Object} item The item to store in the cache.
+   * @return {number} The UUID for the cached item.
+   */
+  storeItem: function(item) {
+    for (var i in this.cache_) {
+      if (item == this.cache_[i])
+        return i;
+    }
+    var id = generateUUID();
+    this.cache_[id] = item;
+    return id;
+  },
+
+  /**
+   * Retrieves the cached object for the given ID.
+   *
+   * @param {number} id The ID for the cached item to retrieve.
+   * @return {!Object} The retrieved item.
+   */
+  retrieveItem: function(id) {
+    var item = this.cache_[id];
+    if (item)
+      return item;
+    var error = new Error('not in cache');
+    error.code = StatusCode.STALE_ELEMENT_REFERENCE;
+    error.message = 'element is not attached to the page document';
+    throw error;
+  },
+
+  /**
+   * Clears stale items from the cache.
+   */
+  clearStale: function() {
+    for (var id in this.cache_) {
+      var node = this.cache_[id];
+      if (!this.isNodeReachable_(node))
+        delete this.cache_[id];
+    }
+  },
+
+  /**
+    * @private
+    * @param {!Node} node The node to check.
+    * @return {boolean} If the nodes is reachable.
+    */
+  isNodeReachable_: function(node) {
+    var nodeRoot = getNodeRootThroughAnyShadows(node);
+    return (nodeRoot == document);
+  }
+
+
+};
+
+/**
  * A cache which maps IDs <-> cached objects for the purpose of identifying
  * a script object remotely.
  * @constructor
  */
 function Cache() {
   this.cache_ = {};
   this.nextId_ = 1;
   this.idPrefix_ = Math.random().toString();
 }
 
@@ skipping 73 matching lines @@
  */
 function getNodeRootThroughAnyShadows(node) {
   var root = getNodeRoot(node);
   while (SHADOW_DOM_ENABLED && root instanceof ShadowRoot) {
     root = getNodeRoot(root.host);
   }
   return root;
 }
 
 /**
  * Returns the global object cache for the page.

[samuong, 2016/08/11 20:45:14]

don't forget to add a comment here for the w3c arg

  * @param {Document=} opt_doc The document whose cache to retrieve. Defaults to
  *     the current document.
  * @return {!Cache} The page's object cache.
  */
-function getPageCache(opt_doc) {
+function getPageCache(opt_doc, opt_w3c) {
   var doc = opt_doc || document;
+  var w3c = opt_w3c || false;

[samuong, 2016/08/11 20:45:14]

is there ever a case where we don't pass a value for opt_w3c?
maybe we should make it non-optional? (and move it to the first arg)

[roisinmcl, 2016/08/13 01:47:26]

Done.

   var key = '$cdc_asdjflasutopfhvcZLmcfl_';
-  if (!(key in doc))
-    doc[key] = new Cache();
-  return doc[key];
+  if (w3c) {
+    if (!(key in doc))
+      doc[key] = new CacheWithUUID();
+    return doc[key];
+  } else {
+    if (!(key in doc))
+      doc[key] = new Cache();
+    return doc[key];
+  }

[samuong, 2016/08/11 20:45:14]

if you make the "if (w3c)" check the inner condition, then you won't need to
duplicate "if (!(key in doc))" and "return doc[key];"

[roisinmcl, 2016/08/13 01:47:26]

Done.

 }
 
 /**
  * Wraps the given value to be transmitted remotely by converting
  * appropriate objects to cached object IDs.
  *
  * @param {*} value The value to wrap.
  * @return {*} The wrapped value.
  */
 function wrap(value) {
   // As of crrev.com/1316933002, typeof() for some elements will return
   // 'function', not 'object'. So we need to check for both non-null objects, as
   // well Elements that also happen to be callable functions (e.g. <embed> and
   // <object> elements). Note that we can not use |value instanceof Object| here
   // since this does not work with frames/iframes, for example
   // frames[0].document.body instanceof Object == false even though
   // typeof(frames[0].document.body) == 'object'.
   if ((typeof(value) == 'object' && value != null) ||
       (typeof(value) == 'function' && value instanceof Element)) {
     var nodeType = value['nodeType'];
     if (nodeType == NodeType.ELEMENT || nodeType == NodeType.DOCUMENT
         || (SHADOW_DOM_ENABLED && value instanceof ShadowRoot)) {
       var wrapped = {};
       var root = getNodeRootThroughAnyShadows(value);
-      wrapped[ELEMENT_KEY] = getPageCache(root).storeItem(value);
+      wrapped[ELEMENT_KEY] = getPageCache(root, w3cEnabled).storeItem(value);
       return wrapped;
     }
 
     var obj = (typeof(value.length) == 'number') ? [] : {};
     for (var prop in value)
       obj[prop] = wrap(value[prop]);
     return obj;
   }
   return value;
 }
@@ skipping 32 matching lines @@
  * @param {function(...[*]) : *} func The function to invoke.
  * @param {!Array<*>} args The array of arguments to supply to the function,
  *     which will be unwrapped before invoking the function.
  * @param {boolean=} opt_unwrappedReturn Whether the function's return value
  *     should be left unwrapped.
  * @return {*} An object containing a status and value property, where status
  *     is a WebDriver status code and value is the wrapped value. If an
  *     unwrapped return was specified, this will be the function's pure return
  *     value.
  */
-function callFunction(shadowHostIds, func, args, opt_unwrappedReturn) {
-  var cache = getPageCache();
+function callFunction(shadowHostIds, func, args, w3c, opt_unwrappedReturn) {
+  if (w3c) {
+    w3cEnabled = true;
+    ELEMENT_KEY = 'element-6066-11e4-a52e-4f735466cecf';
+
+  }
+  var cache = getPageCache(null, w3cEnabled);
   cache.clearStale();
   if (shadowHostIds && SHADOW_DOM_ENABLED) {
     for (var i = 0; i < shadowHostIds.length; i++) {
       var host = cache.retrieveItem(shadowHostIds[i]);
       // TODO(zachconrad): Use the olderShadowRoot API when available to check
       // all of the shadow roots.
-      cache = getPageCache(host.webkitShadowRoot);
+      cache = getPageCache(host.webkitShadowRoot, w3cEnabled);
       cache.clearStale();
     }
   }
 
   if (opt_unwrappedReturn)
     return func.apply(null, unwrap(args, cache));
 
   var status = 0;
   try {
     var returnValue = wrap(func.apply(null, unwrap(args, cache)));
   } catch (error) {
     status = error.code || StatusCode.UNKNOWN_ERROR;
     var returnValue = error.message;
   }
   return {
       status: status,
       value: returnValue
   }
 }