Add logspam to help diagnose flaky tests

chrome/renderer/resources/extensions/automation/automation_node.js

 // Copyright 2014 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.
 
 var AutomationEvent = require('automationEvent').AutomationEvent;
 var automationInternal =
     require('binding').Binding.create('automationInternal').generate();
 var IsInteractPermitted =
     requireNative('automationInternal').IsInteractPermitted;
 
@@ skipping 96 matching lines @@
     if (this.listeners[eventType]) {
       var listeners = this.listeners[eventType];
       for (var i = 0; i < listeners.length; i++) {
         if (callback === listeners[i].callback)
           listeners.splice(i, 1);
       }
     }
   },
 
   dispatchEvent: function(eventType) {
+    logging.LOG('dispatching ' + eventType + ' on ' + this.id);
     var path = [];
     var parent = this.parent();
     while (parent) {
       path.push(parent);
       // TODO(aboxhall/dtseng): handle unloaded parent node
       parent = parent.parent();
     }
     var event = new AutomationEvent(eventType, this.wrapper);
 
     // Dispatch the event through the propagation path in three phases:
@@ skipping 148 matching lines @@
  * unique ids per node and we use these ids to build a hash to the actual
  * AutomationNode object.
  * Thus, tree traversals amount to a lookup in our hash.
  *
  * The tree itself is identified by the process id and routing id of the
  * renderer widget host.
  * @constructor
  */
 function AutomationRootNodeImpl(processID, routingID) {
   AutomationNodeImpl.call(this, this);
+  logging.LOG('AutomationRootNodeImpl constructor: processID=' + processID +
+              '; routingID=' + routingID + '; this.id=' + this.id);
   this.processID = processID;
   this.routingID = routingID;
   this.axNodeDataCache_ = {};
 }
 
 AutomationRootNodeImpl.prototype = {
   __proto__: AutomationNodeImpl.prototype,
 
   isRootNode: true,
 
   get: function(id) {
     if (id == undefined)
       return undefined;
 
     return this.axNodeDataCache_[id];
   },
 
   unserialize: function(update) {
     var updateState = { pendingNodes: {}, newNodes: {} };
-    var oldRootId = this.id;
 
     if (update.nodeIdToClear < 0) {
         logging.WARNING('Bad nodeIdToClear: ' + update.nodeIdToClear);
         lastError.set('automation',
                       'Bad update received on automation tree',
                       null,
                       chrome);
         return false;
     } else if (update.nodeIdToClear > 0) {
       var nodeToClear = this.axNodeDataCache_[update.nodeIdToClear];
@@ skipping 170 matching lines @@
       privates(childNode).impl.indexInParent = i;
       privates(childNode).impl.parentID = node.id;
     }
 
     return success;
   },
 
   setData_: function(node, nodeData) {
     var nodeImpl = privates(node).impl;
     for (var key in AutomationAttributeDefaults) {
-      if (key in nodeData)
+      if (key in nodeData) {
+        if (key == 'id' && nodeImpl[key] != nodeData[key]) {
+          logging.LOG('Changing ID of node from ' + nodeImpl[key] + ' to ' +
+                      nodeData[key]);
+        }
         nodeImpl[key] = nodeData[key];
-      else
+      } else {
         nodeImpl[key] = AutomationAttributeDefaults[key];
+      }
     }
     for (var i = 0; i < AutomationAttributeTypes.length; i++) {
       var attributeType = AutomationAttributeTypes[i];
       for (var attributeName in nodeData[attributeType]) {
         nodeImpl.attributesInternal[attributeName] =
             nodeData[attributeType][attributeName];
         if (ATTRIBUTE_BLACKLIST.hasOwnProperty(attributeName) ||
             nodeImpl.attributes.hasOwnProperty(attributeName)) {
           continue;
         } else if (
@@ skipping 98 matching lines @@
                                                'toString'] });
 
 var AutomationRootNode = utils.expose('AutomationRootNode',
                                       AutomationRootNodeImpl,
                                       { superclass: AutomationNode,
                                         functions: ['load'],
                                         readonly: ['loaded'] });
 
 exports.AutomationNode = AutomationNode;
 exports.AutomationRootNode = AutomationRootNode;