Implement automatic load of composed/embedded automation trees

chrome/common/extensions/api/automation.idl

 // 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.
 
 // The <code>chrome.automation</code> API allows developers to access the
 // automation (accessibility) tree for the browser. The tree resembles the DOM
 // tree, but only exposes the <em>semantic</em> structure of a page. It can be
 // used to programmatically interact with a page by examining names, roles, and
 // states, listening for events, and performing actions on nodes.
 [nocompile] namespace automation {
@@ skipping 218 matching lines @@
     EventType type;
 
     // Stops this event from further processing except for any remaining
     // listeners on $(ref:AutomationEvent.target).
     static void stopPropagation();
   };
 
   // A listener for events on an <code>AutomationNode</code>.
   callback AutomationListener = void(AutomationEvent event);
 
+  // Called when the root <code>AutomationNode</code> for the page is available.
+  callback RootCallback = void(AutomationNode rootNode);
+
   // A single node in an Automation tree.
   [nocompile, noinline_doc] dictionary AutomationNode {
     // The root node of the tree containing this AutomationNode.
-    AutomationRootNode root;
+    AutomationNode root;

[aboxhall, 2014/10/29 19:29:11]

Why did this change? An AutomationRootNode _is_ an AutomationNode - why would a
root not be an AutomationRootNode?

[David Tseng, 2014/10/29 20:35:30]

I removed the AutomationRootNode interface; can put it back, but it doesn't seem
to serve any purpose now that load can be on a non-root node. Root node seems
pretty confusing to me as well because it's not a root node in the case of the
desktop tree. 

 
-    // Whether this AutomationNode is an AutomationRootNode.
+    // Whether this AutomationNode is a root node.
     boolean isRootNode;
 
     // Unique ID to identify this node.
     long id;
 
     // The role of this node.
     automation.RoleType role;
 
     // The $(ref:automation.StateType)s describing this node.
     object state;
 
     // The rendered location (as a bounding box) of this node within the frame.
     automation.Rect location;
 
     // A collection of this node's other attributes.
     object? attributes;
 
+    // Whether this AutomationNode is loaded or not. If false, call load()
+    // to get the contents. Only applicable on webArea nodes.
+    boolean? loaded;
+
     // The index of this node in its parent node's list of children. If this is
     // the root node, this will be undefined.
     long? indexInParent;
 
     static AutomationNode[] children();
     static AutomationNode parent();
     static AutomationNode firstChild();
     static AutomationNode lastChild();
     static AutomationNode previousSibling();
     static AutomationNode nextSibling();
 
     // Does the default action based on this node's role. This is generally
     // the same action that would result from clicking the node such as
     // expanding a treeitem, toggling a checkbox, selecting a radiobutton,
     // or activating a button.
     static void doDefault();
 
     // Places focus on this node.
     static void focus();
 
     // Scrolls this node to make it visible.
     static void makeVisible();
 
     // Sets selection within a text field.
     static void setSelection(long startIndex, long endIndex);
 
+    // Load the accessibility tree for this node hosting a frame. Only
+    // applicable on webArea nodes.
+    static void load(RootCallback callback);
+
     // Adds a listener for the given event type and event phase.
     static void addEventListener(
         EventType eventType, AutomationListener listener, boolean capture);
 
     // Removes a listener for the given event type and event phase.
     static void removeEventListener(
         EventType eventType, AutomationListener listener, boolean capture);
   };
 
-  // Called when the <code>AutomationRootNode</code> for the page is available.
-  callback RootCallback = void(AutomationRootNode rootNode);
-
-  // The root node of the automation tree for a single frame or desktop.
-  // This may be:
-  // <ul>
-  //   <li> The desktop
-  //   <li> The top frame of a page
-  //   <li> A frame or iframe within a page
-  // </ul>
-  // Thus, an <code>AutomationRootNode</code> may be a descendant of one or
-  // more <code>AutomationRootNode</code>s, and in turn have one or more
-  // <code>AutomationRootNode</code>s in its descendants. Thus, the
-  // <code>root</code> property of the <code>AutomationRootNode</code> will be
-  // the immediate parent <code>AutomationRootNode</code>, or <code>null</code>
-  // if this is the top-level <code>AutomationRootNode</code>.
-  //
-  // Extends $(ref:automation.AutomationNode).
-  [nocompile, noinline_doc] dictionary AutomationRootNode {
-    // TODO(aboxhall/dtseng): implement loading. Kept separate to not include
-    // in generated docs.
-
-    // Whether this AutomationRootNode is loaded or not. If false, call load()
-    // to get the contents.
-    boolean loaded;
-
-    // Load the accessibility tree for this AutomationRootNode.
-    static void load(RootCallback callback);
-  };
-
   interface Functions {
     // Get the automation tree for the tab with the given tabId, or the current
     // tab if no tabID is given, enabling automation if necessary. Returns a
     // tree with a placeholder root node; listen for the "loadComplete" event to
     // get a notification that the tree has fully loaded (the previous root node
     // reference will stop working at or before this point).
     [nocompile] static void getTree(optional long tabId, RootCallback callback);
 
     // Get the automation tree for the whole desktop which consists of all on
     // screen views. Note this API is currently only supported on Chrome OS.
     [nocompile] static void getDesktop(RootCallback callback);
   };
 };