Added a new PyAuto method WaitForDomNode() which allows tests to block until a specified node exist…

chrome/test/pyautolib/dom_mutation_observer.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.
  *
  * Helper javascript injected whenever a DomMutationEventObserver is created.
  *
  * This script uses MutationObservers to watch for changes to the DOM, then
  * reports the event to the observer using the DomAutomationController. An
  * anonymous namespace is used to prevent conflict with other Javascript.
  *
  * Args:
  *  automation_id: Automation id used to route DomAutomationController messages.
  *  observer_id: Id of the observer who will be receiving the messages.
- *  observer_type: One of 'add', 'remove', or 'change'.
+ *  observer_type: One of 'add', 'remove', 'change', or 'exists'.
  *  pattern: Pattern used to select the DOM node of interest.
  *  ptype: Type of |pattern|, either 'xpath' or 'css'.
  *  expected_value: If not null, regular expression matching text contents
  *      expected after the mutation.
  */
 
 function(automation_id, observer_id, observer_type, pattern, ptype,
          expected_value) {
 
   /* Raise an event for the DomMutationEventObserver.
@@ skipping 70 matching lines @@
     for (var j=0; j<mutations.length; j++) {
       if (nodeValueTextEquals(mutations[j].target, expected_value)) {
         raiseEvent();
         observer.disconnect();
         delete observer;
         return;
       }
     }
   }
 
+  /* Calls raiseEvent if the expected node exists in the DOM.
+   *
+   * Args:
+   *  mutations: A list of mutation objects.
+   *  observer: The mutation observer object associated with this callback.
+   */
+  function existsNodeCallback(mutations, observer) {
+    var node = firstMatchingNode(pattern, ptype);
+    if (node && nodeValueTextEquals(node, expected_value)) {
+      raiseEvent();
+      observer.disconnect();
+      delete observer;
+      return;
+    }
+  }
+
   /* Return true if the xpath matches the given node.
    *
    * Args:
    *  node: A node object from the DOM.
    *  xpath: A string in the format of an xpath.
    */
   function XPathMatchesNode(node, xpath) {
     var con = document.evaluate(xpath, document, null,
         XPathResult.UNORDERED_NODE_ITERATOR_TYPE, null);
     var thisNode = con.iterateNext();
@@ skipping 62 matching lines @@
   }
 
   /* Watch for a node matching pattern to be added to the DOM.
    *
    * Args:
    *  pattern: A string in the format of either an XPath or CSS Selector.
    *  ptype: Either 'xpath' or 'css'.
    */
   function observeAdd(pattern, ptype) {
     window.domAutomationController.send("success");
-    if (firstMatchingNode(pattern, ptype)) {
+    var node = firstMatchingNode(pattern, ptype);
+    if (node && nodeValueTextEquals(node, expected_value)) {
       raiseEvent();
       console.log("Matching node in DOM, assuming it was previously added.");
       return;
     }
 
     var obs = new WebKitMutationObserver(addNodeCallback);
     obs.observe(document,
         { childList: true,
           attributes: true,
           subtree: true});
@@ skipping 38 matching lines @@
     window.domAutomationController.send("success");
 
     var obs = new WebKitMutationObserver(changeNodeCallback);
     obs.observe(node,
         { childList: true,
           attributes: true,
           characterData: true,
           subtree: true});
   }
 
+  /* Watch for a node matching pattern to exist in the DOM.
+   *
+   * Args:
+   *  pattern: A string in the format of either an XPath or CSS Selector.
+   *  ptype: Either 'xpath' or 'css'.
+   */
+  function observeExists(pattern, ptype) {
+    window.domAutomationController.send("success");
+    var node = firstMatchingNode(pattern, ptype);
+    if (node && nodeValueTextEquals(node, expected_value)) {
+      raiseEvent();
+      console.log("Node already exists in DOM.");
+      return;
+    }
+
+    var obs = new WebKitMutationObserver(existsNodeCallback);
+    obs.observe(document,
+        { childList: true,
+          attributes: true,
+          subtree: true});
+  }
 
   /* Interpret arguments and launch the requested observer function. */
   var observer;
   switch (observer_type) {
     case "add":
       observeAdd(pattern, ptype);
       break;
     case "remove":
       observeRemove(pattern, ptype);
       break;
     case "change":
       observeChange(pattern, ptype);
       break;
+    case "exists":
+      observeExists(pattern, ptype);
+      break;
   }
 
   console.log("MutationObserver javscript injection completed.")
 
 }