Refactor content/ to use ui::AXNodeData instead of blink.

content/renderer/accessibility/renderer_accessibility_complete.cc

 // 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.
 
 #include "content/renderer/accessibility/renderer_accessibility_complete.h"
 
 #include <queue>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "content/renderer/accessibility/accessibility_node_serializer.h"
+#include "content/renderer/accessibility/blink_ax_enum_conversion.h"
 #include "content/renderer/render_view_impl.h"
 #include "third_party/WebKit/public/web/WebAXObject.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebInputElement.h"
 #include "third_party/WebKit/public/web/WebNode.h"
 #include "third_party/WebKit/public/web/WebView.h"
+#include "ui/accessibility/ax_tree.h"
 
 using blink::WebAXObject;
 using blink::WebDocument;
 using blink::WebFrame;
 using blink::WebNode;
 using blink::WebPoint;
 using blink::WebRect;
 using blink::WebSize;
 using blink::WebView;
 
@@ skipping 13 matching lines @@
   // APIs that compute the bounds of a range of text, it's a waste to
   // include these in the AX tree.
   WebAXObject::enableInlineTextBoxAccessibility();
 #endif
 
   const WebDocument& document = GetMainDocument();
   if (!document.isNull()) {
     // It's possible that the webview has already loaded a webpage without
     // accessibility being enabled. Initialize the browser's cached
     // accessibility tree by sending it a notification.
-    HandleWebAccessibilityEvent(document.accessibilityObject(),
-                                blink::WebAXEventLayoutComplete);
+    HandleAXEvent(document.accessibilityObject(),
+                  ui::AX_EVENT_LAYOUT_COMPLETE);
   }
 }
 
 RendererAccessibilityComplete::~RendererAccessibilityComplete() {
   if (browser_root_) {
     ClearBrowserTreeNode(browser_root_);
     browser_id_map_.erase(browser_root_->id);
     delete browser_root_;
   }
   DCHECK(browser_id_map_.empty());
@@ skipping 21 matching lines @@
 }
 
 void RendererAccessibilityComplete::FocusedNodeChanged(const WebNode& node) {
   const WebDocument& document = GetMainDocument();
   if (document.isNull())
     return;
 
   if (node.isNull()) {
     // When focus is cleared, implicitly focus the document.
     // TODO(dmazzoni): Make WebKit send this notification instead.
-    HandleWebAccessibilityEvent(document.accessibilityObject(),
-                                blink::WebAXEventBlur);
+    HandleAXEvent(document.accessibilityObject(), ui::AX_EVENT_BLUR);
   }
 }
 
 void RendererAccessibilityComplete::DidFinishLoad(blink::WebFrame* frame) {
   const WebDocument& document = GetMainDocument();
   if (document.isNull())
     return;
 
   // Check to see if the root accessibility object has changed, to work
   // around WebKit bugs that cause AXObjectCache to be cleared
   // unnecessarily.
   // TODO(dmazzoni): remove this once rdar://5794454 is fixed.
   WebAXObject new_root = document.accessibilityObject();
   if (!browser_root_ || new_root.axID() != browser_root_->id)
-    HandleWebAccessibilityEvent(new_root, blink::WebAXEventLayoutComplete);
+    HandleAXEvent(new_root, ui::AX_EVENT_LAYOUT_COMPLETE);
 }
 
+
 void RendererAccessibilityComplete::HandleWebAccessibilityEvent(
-    const blink::WebAXObject& obj,
-    blink::WebAXEvent event) {
+    const blink::WebAXObject& obj, blink::WebAXEvent event) {
+  HandleAXEvent(obj, AXEventFromBlink(event));
+}
+
+void RendererAccessibilityComplete::HandleAXEvent(
+    const blink::WebAXObject& obj, ui::AXEvent event) {
   const WebDocument& document = GetMainDocument();
   if (document.isNull())
     return;
 
   gfx::Size scroll_offset = document.frame()->scrollOffset();
   if (scroll_offset != last_scroll_offset_) {
     // Make sure the browser is always aware of the scroll position of
     // the root document element by posting a generic notification that
     // will update it.
     // TODO(dmazzoni): remove this as soon as
     // https://bugs.webkit.org/show_bug.cgi?id=73460 is fixed.
     last_scroll_offset_ = scroll_offset;
     if (!obj.equals(document.accessibilityObject())) {
-      HandleWebAccessibilityEvent(
-          document.accessibilityObject(),
-          blink::WebAXEventLayoutComplete);
+      HandleAXEvent(document.accessibilityObject(),
+                    ui::AX_EVENT_LAYOUT_COMPLETE);
     }
   }
 
   // Add the accessibility object to our cache and ensure it's valid.
   AccessibilityHostMsg_EventParams acc_event;
   acc_event.id = obj.axID();
   acc_event.event_type = event;
 
   // Discard duplicate accessibility events.
   for (uint32 i = 0; i < pending_events_.size(); ++i) {
@@ skipping 51 matching lines @@
 
     WebAXObject obj = document.accessibilityObjectFromID(
         event.id);
     if (!obj.updateBackingStoreAndCheckValidity())
       continue;
 
     // When we get a "selected children changed" event, WebKit
     // doesn't also send us events for each child that changed
     // selection state, so make sure we re-send that whole subtree.
     if (event.event_type ==
-        blink::WebAXEventSelectedChildrenChanged) {
+        ui::AX_EVENT_SELECTED_CHILDREN_CHANGED) {
       base::hash_map<int32, BrowserTreeNode*>::iterator iter =
           browser_id_map_.find(obj.axID());
       if (iter != browser_id_map_.end())
         ClearBrowserTreeNode(iter->second);
     }
 
     // The browser may not have this object yet, for example if we get a
     // event on an object that was recently added, or if we get a
     // event on a node before the page has loaded. Work our way
     // up the parent chain until we find a node the browser has, or until
     // we reach the root.
     WebAXObject root_object = document.accessibilityObject();
     int root_id = root_object.axID();
     while (browser_id_map_.find(obj.axID()) == browser_id_map_.end() &&
            !obj.isDetached() &&
            obj.axID() != root_id) {
       obj = obj.parentObject();
       if (event.event_type ==
-          blink::WebAXEventChildrenChanged) {
+          ui::AX_EVENT_CHILDREN_CHANGED) {
         event.id = obj.axID();
       }
     }
 
     if (obj.isDetached()) {
 #ifndef NDEBUG
-      if (logging_)
-        LOG(WARNING) << "Got event on object that is invalid or has"
-                     << " invalid ancestor. Id: " << obj.axID();
+      LOG(WARNING) << "Got event on object that is invalid or has"
+                   << " invalid ancestor. Id: " << obj.axID();
 #endif
       continue;
     }
 
     // Another potential problem is that this event may be on an
     // object that is detached from the tree. Determine if this node is not a
     // child of its parent, and if so move the event to the parent.
     // TODO(dmazzoni): see if this can be removed after
     // https://bugs.webkit.org/show_bug.cgi?id=68466 is fixed.
     if (obj.axID() != root_id) {
@@ skipping 26 matching lines @@
     root_object.startCachingComputedObjectAttributesUntilTreeMutates();
 
     AccessibilityHostMsg_EventParams event_msg;
     event_msg.event_type = event.event_type;
     event_msg.id = event.id;
     std::set<int> ids_serialized;
     SerializeChangedNodes(obj, &event_msg.nodes, &ids_serialized);
     event_msgs.push_back(event_msg);
 
 #ifndef NDEBUG
-    if (logging_) {
-      AccessibilityNodeDataTreeNode tree;
-      MakeAccessibilityNodeDataTree(event_msg.nodes, &tree);
-      VLOG(0) << "Accessibility update: \n"
-          << "routing id=" << routing_id()
-          << " event="
-          << AccessibilityEventToString(event.event_type)
-          << "\n" << tree.DebugString(true);
-    }
+    ui::AXTree tree;
+    ui::AXTreeUpdate update;
+    update.nodes = event_msg.nodes;
+    tree.Unserialize(update);
+    VLOG(0) << "Accessibility update: \n"
+            << "routing id=" << routing_id()
+            << " event="
+            << AccessibilityEventToString(event.event_type)
+            << "\n" << tree.ToString();
 #endif
   }
 
   Send(new AccessibilityHostMsg_Events(routing_id(), event_msgs));
 
   SendLocationChanges();
 }
 
 void RendererAccessibilityComplete::SendLocationChanges() {
   std::queue<WebAXObject> objs_to_explore;
@@ skipping 30 matching lines @@
   Send(new AccessibilityHostMsg_LocationChanges(routing_id(), messages));
 }
 
 RendererAccessibilityComplete::BrowserTreeNode*
 RendererAccessibilityComplete::CreateBrowserTreeNode() {
   return new RendererAccessibilityComplete::BrowserTreeNode();
 }
 
 void RendererAccessibilityComplete::SerializeChangedNodes(
     const blink::WebAXObject& obj,
-    std::vector<AccessibilityNodeData>* dst,
+    std::vector<ui::AXNodeData>* dst,
     std::set<int>* ids_serialized) {
   if (ids_serialized->find(obj.axID()) != ids_serialized->end())
     return;
   ids_serialized->insert(obj.axID());
 
   // This method has three responsibilities:
-  // 1. Serialize |obj| into an AccessibilityNodeData, and append it to
+  // 1. Serialize |obj| into an ui::AXNodeData, and append it to
   //    the end of the |dst| vector to be send to the browser process.
   // 2. Determine if |obj| has any new children that the browser doesn't
   //    know about yet, and call SerializeChangedNodes recursively on those.
   // 3. Update our internal data structure that keeps track of what nodes
   //    the browser knows about.
 
   // First, find the BrowserTreeNode for this id in our data structure where
   // we keep track of what accessibility objects the browser already knows
   // about. If we don't find it, then this must be the new root of the
   // accessibility tree.
@@ skipping 69 matching lines @@
     if (new_child_ids.find(old_child_id) == new_child_ids.end()) {
       browser_id_map_.erase(old_child_id);
       ClearBrowserTreeNode(old_child);
       delete old_child;
     } else {
       browser_child_id_map[old_child_id] = old_child;
     }
   }
 
   // Serialize this node. This fills in all of the fields in
-  // AccessibilityNodeData except child_ids, which we handle below.
-  dst->push_back(AccessibilityNodeData());
-  AccessibilityNodeData* serialized_node = &dst->back();
+  // ui::AXNodeData except child_ids, which we handle below.
+  dst->push_back(ui::AXNodeData());
+  ui::AXNodeData* serialized_node = &dst->back();
   SerializeAccessibilityNode(obj, serialized_node);
   if (serialized_node->id == browser_root_->id)
-    serialized_node->role = blink::WebAXRoleRootWebArea;
+    serialized_node->role = ui::AX_ROLE_ROOT_WEB_AREA;
 
   // Iterate over the children, make note of the ones that are new
   // and need to be serialized, and update the BrowserTreeNode
   // data structure to reflect the new tree.
   std::vector<WebAXObject> children_to_serialize;
   int child_count = obj.childCount();
   browser_node->children.reserve(child_count);
   for (int i = 0; i < child_count; i++) {
     WebAXObject child = obj.childAt(i);
     int child_id = child.axID();
@@ skipping 40 matching lines @@
 }
 
 void RendererAccessibilityComplete::OnDoDefaultAction(int acc_obj_id) {
   const WebDocument& document = GetMainDocument();
   if (document.isNull())
     return;
 
   WebAXObject obj = document.accessibilityObjectFromID(acc_obj_id);
   if (obj.isDetached()) {
 #ifndef NDEBUG
-    if (logging_)
-      LOG(WARNING) << "DoDefaultAction on invalid object id " << acc_obj_id;
+    LOG(WARNING) << "DoDefaultAction on invalid object id " << acc_obj_id;
 #endif
     return;
   }
 
   obj.performDefaultAction();
 }
 
 void RendererAccessibilityComplete::OnScrollToMakeVisible(
     int acc_obj_id, gfx::Rect subfocus) {
   const WebDocument& document = GetMainDocument();
   if (document.isNull())
     return;
 
   WebAXObject obj = document.accessibilityObjectFromID(acc_obj_id);
   if (obj.isDetached()) {
 #ifndef NDEBUG
-    if (logging_)
-      LOG(WARNING) << "ScrollToMakeVisible on invalid object id " << acc_obj_id;
+    LOG(WARNING) << "ScrollToMakeVisible on invalid object id " << acc_obj_id;
 #endif
     return;
   }
 
   obj.scrollToMakeVisibleWithSubFocus(
       WebRect(subfocus.x(), subfocus.y(),
               subfocus.width(), subfocus.height()));
 
   // Make sure the browser gets an event when the scroll
   // position actually changes.
   // TODO(dmazzoni): remove this once this bug is fixed:
   // https://bugs.webkit.org/show_bug.cgi?id=73460
-  HandleWebAccessibilityEvent(
-      document.accessibilityObject(),
-      blink::WebAXEventLayoutComplete);
+  HandleAXEvent(document.accessibilityObject(),
+                ui::AX_EVENT_LAYOUT_COMPLETE);
 }
 
 void RendererAccessibilityComplete::OnScrollToPoint(
     int acc_obj_id, gfx::Point point) {
   const WebDocument& document = GetMainDocument();
   if (document.isNull())
     return;
 
   WebAXObject obj = document.accessibilityObjectFromID(acc_obj_id);
   if (obj.isDetached()) {
 #ifndef NDEBUG
-    if (logging_)
-      LOG(WARNING) << "ScrollToPoint on invalid object id " << acc_obj_id;
+    LOG(WARNING) << "ScrollToPoint on invalid object id " << acc_obj_id;
 #endif
     return;
   }
 
   obj.scrollToGlobalPoint(WebPoint(point.x(), point.y()));
 
   // Make sure the browser gets an event when the scroll
   // position actually changes.
   // TODO(dmazzoni): remove this once this bug is fixed:
   // https://bugs.webkit.org/show_bug.cgi?id=73460
-  HandleWebAccessibilityEvent(
-      document.accessibilityObject(),
-      blink::WebAXEventLayoutComplete);
+  HandleAXEvent(document.accessibilityObject(),
+                ui::AX_EVENT_LAYOUT_COMPLETE);
 }
 
 void RendererAccessibilityComplete::OnSetTextSelection(
     int acc_obj_id, int start_offset, int end_offset) {
   const WebDocument& document = GetMainDocument();
   if (document.isNull())
     return;
 
   WebAXObject obj = document.accessibilityObjectFromID(acc_obj_id);
   if (obj.isDetached()) {
 #ifndef NDEBUG
-    if (logging_)
-      LOG(WARNING) << "SetTextSelection on invalid object id " << acc_obj_id;
+    LOG(WARNING) << "SetTextSelection on invalid object id " << acc_obj_id;
 #endif
     return;
   }
 
   // TODO(dmazzoni): support elements other than <input>.
   blink::WebNode node = obj.node();
   if (!node.isNull() && node.isElementNode()) {
     blink::WebElement element = node.to<blink::WebElement>();
     blink::WebInputElement* input_element =
         blink::toWebInputElement(&element);
     if (input_element && input_element->isTextField())
       input_element->setSelectionRange(start_offset, end_offset);
   }
 }
 
 void RendererAccessibilityComplete::OnEventsAck() {
   DCHECK(ack_pending_);
   ack_pending_ = false;
   SendPendingAccessibilityEvents();
 }
 
 void RendererAccessibilityComplete::OnSetFocus(int acc_obj_id) {
   const WebDocument& document = GetMainDocument();
   if (document.isNull())
     return;
 
   WebAXObject obj = document.accessibilityObjectFromID(acc_obj_id);
   if (obj.isDetached()) {
 #ifndef NDEBUG
-    if (logging_) {
-      LOG(WARNING) << "OnSetAccessibilityFocus on invalid object id "
-                   << acc_obj_id;
-    }
+    LOG(WARNING) << "OnSetAccessibilityFocus on invalid object id "
+                 << acc_obj_id;
 #endif
     return;
   }
 
   WebAXObject root = document.accessibilityObject();
   if (root.isDetached()) {
 #ifndef NDEBUG
-    if (logging_) {
-      LOG(WARNING) << "OnSetAccessibilityFocus but root is invalid";
-    }
+    LOG(WARNING) << "OnSetAccessibilityFocus but root is invalid";
 #endif
     return;
   }
 
   // By convention, calling SetFocus on the root of the tree should clear the
   // current focus. Otherwise set the focus to the new node.
   if (acc_obj_id == root.axID())
     render_view()->GetWebView()->clearFocusedNode();
   else
     obj.setFocused(true);
 }
 
 void RendererAccessibilityComplete::OnFatalError() {
   CHECK(false) << "Invalid accessibility tree.";
 }
 
 }  // namespace content