src/content/renderer/accessibility/renderer_accessibility_complete.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/renderer/accessibility/renderer_accessibility_complete.h"
   6
   7 #include <queue>
   8
   9 #include "base/bind.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "content/renderer/accessibility/blink_ax_enum_conversion.h"
  12 #include "content/renderer/render_frame_impl.h"
  13 #include "content/renderer/render_view_impl.h"
  14 #include "third_party/WebKit/public/web/WebAXObject.h"
  15 #include "third_party/WebKit/public/web/WebDocument.h"
  16 #include "third_party/WebKit/public/web/WebFrame.h"
  17 #include "third_party/WebKit/public/web/WebInputElement.h"
  18 #include "third_party/WebKit/public/web/WebLocalFrame.h"
  19 #include "third_party/WebKit/public/web/WebNode.h"
  20 #include "third_party/WebKit/public/web/WebSettings.h"
  21 #include "third_party/WebKit/public/web/WebView.h"
  22 #include "ui/accessibility/ax_tree.h"
  23
  24 using blink::WebAXObject;
  25 using blink::WebDocument;
  26 using blink::WebFrame;
  27 using blink::WebNode;
  28 using blink::WebPoint;
  29 using blink::WebRect;
  30 using blink::WebSettings;
  31 using blink::WebView;
  32
  33 namespace content {
  34
  35 RendererAccessibilityComplete::RendererAccessibilityComplete(
  36     RenderFrameImpl* render_frame)
  37     : RendererAccessibility(render_frame),
  38       tree_source_(render_frame),
  39       serializer_(&tree_source_),
  40       last_scroll_offset_(gfx::Size()),
  41       ack_pending_(false),
  42       weak_factory_(this) {
  43   WebView* web_view = render_frame_->GetRenderView()->GetWebView();
  44   WebSettings* settings = web_view->settings();
  45   settings->setAccessibilityEnabled(true);
  46
  47 #if !defined(OS_ANDROID)
  48   // Skip inline text boxes on Android - since there are no native Android
  49   // APIs that compute the bounds of a range of text, it's a waste to
  50   // include these in the AX tree.
  51   settings->setInlineTextBoxAccessibilityEnabled(true);
  52 #endif
  53
  54   const WebDocument& document = GetMainDocument();
  55   if (!document.isNull()) {
  56     // It's possible that the webview has already loaded a webpage without
  57     // accessibility being enabled. Initialize the browser's cached
  58     // accessibility tree by sending it a notification.
  59     HandleAXEvent(document.accessibilityObject(),
  60                   ui::AX_EVENT_LAYOUT_COMPLETE);
  61   }
  62 }
  63
  64 RendererAccessibilityComplete::~RendererAccessibilityComplete() {
  65 }
  66
  67 bool RendererAccessibilityComplete::OnMessageReceived(
  68     const IPC::Message& message) {
  69   bool handled = true;
  70   IPC_BEGIN_MESSAGE_MAP(RendererAccessibilityComplete, message)
  71     IPC_MESSAGE_HANDLER(AccessibilityMsg_SetFocus, OnSetFocus)
  72     IPC_MESSAGE_HANDLER(AccessibilityMsg_DoDefaultAction,
  73                         OnDoDefaultAction)
  74     IPC_MESSAGE_HANDLER(AccessibilityMsg_Events_ACK,
  75                         OnEventsAck)
  76     IPC_MESSAGE_HANDLER(AccessibilityMsg_ScrollToMakeVisible,
  77                         OnScrollToMakeVisible)
  78     IPC_MESSAGE_HANDLER(AccessibilityMsg_ScrollToPoint,
  79                         OnScrollToPoint)
  80     IPC_MESSAGE_HANDLER(AccessibilityMsg_SetTextSelection,
  81                         OnSetTextSelection)
  82     IPC_MESSAGE_HANDLER(AccessibilityMsg_HitTest, OnHitTest)
  83     IPC_MESSAGE_HANDLER(AccessibilityMsg_FatalError, OnFatalError)
  84     IPC_MESSAGE_UNHANDLED(handled = false)
  85   IPC_END_MESSAGE_MAP()
  86   return handled;
  87 }
  88
  89 void RendererAccessibilityComplete::FocusedNodeChanged(const WebNode& node) {
  90   const WebDocument& document = GetMainDocument();
  91   if (document.isNull())
  92     return;
  93
  94   if (node.isNull()) {
  95     // When focus is cleared, implicitly focus the document.
  96     // TODO(dmazzoni): Make Blink send this notification instead.
  97     HandleAXEvent(document.accessibilityObject(), ui::AX_EVENT_BLUR);
  98   }
  99 }
 100
 101 void RendererAccessibilityComplete::HandleWebAccessibilityEvent(
 102     const blink::WebAXObject& obj, blink::WebAXEvent event) {
 103   HandleAXEvent(obj, AXEventFromBlink(event));
 104 }
 105
 106 void RendererAccessibilityComplete::HandleAXEvent(
 107     const blink::WebAXObject& obj, ui::AXEvent event) {
 108   const WebDocument& document = GetMainDocument();
 109   if (document.isNull())
 110     return;
 111
 112   gfx::Size scroll_offset = document.frame()->scrollOffset();
 113   if (scroll_offset != last_scroll_offset_) {
 114     // Make sure the browser is always aware of the scroll position of
 115     // the root document element by posting a generic notification that
 116     // will update it.
 117     // TODO(dmazzoni): remove this as soon as
 118     // https://bugs.webkit.org/show_bug.cgi?id=73460 is fixed.
 119     last_scroll_offset_ = scroll_offset;
 120     if (!obj.equals(document.accessibilityObject())) {
 121       HandleAXEvent(document.accessibilityObject(),
 122                     ui::AX_EVENT_LAYOUT_COMPLETE);
 123     }
 124   }
 125
 126   // Add the accessibility object to our cache and ensure it's valid.
 127   AccessibilityHostMsg_EventParams acc_event;
 128   acc_event.id = obj.axID();
 129   acc_event.event_type = event;
 130
 131   // Discard duplicate accessibility events.
 132   for (uint32 i = 0; i < pending_events_.size(); ++i) {
 133     if (pending_events_[i].id == acc_event.id &&
 134         pending_events_[i].event_type ==
 135             acc_event.event_type) {
 136       return;
 137     }
 138   }
 139   pending_events_.push_back(acc_event);
 140
 141   if (!ack_pending_ && !weak_factory_.HasWeakPtrs()) {
 142     // When no accessibility events are in-flight post a task to send
 143     // the events to the browser. We use PostTask so that we can queue
 144     // up additional events.
 145     base::MessageLoop::current()->PostTask(
 146         FROM_HERE,
 147         base::Bind(&RendererAccessibilityComplete::
 148                        SendPendingAccessibilityEvents,
 149                    weak_factory_.GetWeakPtr()));
 150   }
 151 }
 152
 153 RendererAccessibilityType RendererAccessibilityComplete::GetType() {
 154   return RendererAccessibilityTypeComplete;
 155 }
 156
 157 void RendererAccessibilityComplete::SendPendingAccessibilityEvents() {
 158   const WebDocument& document = GetMainDocument();
 159   if (document.isNull())
 160     return;
 161
 162   if (pending_events_.empty())
 163     return;
 164
 165   if (render_frame_->is_swapped_out())
 166     return;
 167
 168   ack_pending_ = true;
 169
 170   // Make a copy of the events, because it's possible that
 171   // actions inside this loop will cause more events to be
 172   // queued up.
 173   std::vector<AccessibilityHostMsg_EventParams> src_events =
 174       pending_events_;
 175   pending_events_.clear();
 176
 177   // Generate an event message from each Blink event.
 178   std::vector<AccessibilityHostMsg_EventParams> event_msgs;
 179
 180   // If there's a layout complete message, we need to send location changes.
 181   bool had_layout_complete_messages = false;
 182
 183   // Loop over each event and generate an updated event message.
 184   for (size_t i = 0; i < src_events.size(); ++i) {
 185     AccessibilityHostMsg_EventParams& event = src_events[i];
 186     if (event.event_type == ui::AX_EVENT_LAYOUT_COMPLETE)
 187       had_layout_complete_messages = true;
 188
 189     WebAXObject obj = document.accessibilityObjectFromID(event.id);
 190
 191     // Make sure the object still exists.
 192     if (!obj.updateBackingStoreAndCheckValidity())
 193       continue;
 194
 195     // Make sure it's a descendant of our root node - exceptions include the
 196     // scroll area that's the parent of the main document (we ignore it), and
 197     // possibly nodes attached to a different document.
 198     if (!tree_source_.IsInTree(obj))
 199       continue;
 200
 201     // When we get a "selected children changed" event, Blink
 202     // doesn't also send us events for each child that changed
 203     // selection state, so make sure we re-send that whole subtree.
 204     if (event.event_type ==
 205         ui::AX_EVENT_SELECTED_CHILDREN_CHANGED) {
 206       serializer_.DeleteClientSubtree(obj);
 207     }
 208
 209     AccessibilityHostMsg_EventParams event_msg;
 210     tree_source_.CollectChildFrameIdMapping(
 211         &event_msg.node_to_frame_routing_id_map,
 212         &event_msg.node_to_browser_plugin_instance_id_map);
 213     event_msg.event_type = event.event_type;
 214     event_msg.id = event.id;
 215     serializer_.SerializeChanges(obj, &event_msg.update);
 216     event_msgs.push_back(event_msg);
 217
 218     // For each node in the update, set the location in our map from
 219     // ids to locations.
 220     for (size_t i = 0; i < event_msg.update.nodes.size(); ++i) {
 221       locations_[event_msg.update.nodes[i].id] =
 222           event_msg.update.nodes[i].location;
 223     }
 224
 225     VLOG(0) << "Accessibility event: " << ui::ToString(event.event_type)
 226             << " on node id " << event_msg.id
 227             << "\n" << event_msg.update.ToString();
 228   }
 229
 230   Send(new AccessibilityHostMsg_Events(routing_id(), event_msgs));
 231
 232   if (had_layout_complete_messages)
 233     SendLocationChanges();
 234 }
 235
 236 void RendererAccessibilityComplete::SendLocationChanges() {
 237   std::vector<AccessibilityHostMsg_LocationChangeParams> messages;
 238
 239   // Do a breadth-first explore of the whole blink AX tree.
 240   base::hash_map<int, gfx::Rect> new_locations;
 241   std::queue<WebAXObject> objs_to_explore;
 242   objs_to_explore.push(tree_source_.GetRoot());
 243   while (objs_to_explore.size()) {
 244     WebAXObject obj = objs_to_explore.front();
 245     objs_to_explore.pop();
 246
 247     // See if we had a previous location. If not, this whole subtree must
 248     // be new, so don't continue to explore this branch.
 249     int id = obj.axID();
 250     base::hash_map<int, gfx::Rect>::iterator iter = locations_.find(id);
 251     if (iter == locations_.end())
 252       continue;
 253
 254     // If the location has changed, append it to the IPC message.
 255     gfx::Rect new_location = obj.boundingBoxRect();
 256     if (iter != locations_.end() && iter->second != new_location) {
 257       AccessibilityHostMsg_LocationChangeParams message;
 258       message.id = id;
 259       message.new_location = new_location;
 260       messages.push_back(message);
 261     }
 262
 263     // Save the new location.
 264     new_locations[id] = new_location;
 265
 266     // Explore children of this object.
 267     std::vector<blink::WebAXObject> children;
 268     tree_source_.GetChildren(obj, &children);
 269     for (size_t i = 0; i < children.size(); ++i)
 270       objs_to_explore.push(children[i]);
 271   }
 272   locations_.swap(new_locations);
 273
 274   Send(new AccessibilityHostMsg_LocationChanges(routing_id(), messages));
 275 }
 276
 277 void RendererAccessibilityComplete::OnDoDefaultAction(int acc_obj_id) {
 278   const WebDocument& document = GetMainDocument();
 279   if (document.isNull())
 280     return;
 281
 282   WebAXObject obj = document.accessibilityObjectFromID(acc_obj_id);
 283   if (obj.isDetached()) {
 284 #ifndef NDEBUG
 285     LOG(WARNING) << "DoDefaultAction on invalid object id " << acc_obj_id;
 286 #endif
 287     return;
 288   }
 289
 290   obj.performDefaultAction();
 291 }
 292
 293 void RendererAccessibilityComplete::OnScrollToMakeVisible(
 294     int acc_obj_id, gfx::Rect subfocus) {
 295   const WebDocument& document = GetMainDocument();
 296   if (document.isNull())
 297     return;
 298
 299   WebAXObject obj = document.accessibilityObjectFromID(acc_obj_id);
 300   if (obj.isDetached()) {
 301 #ifndef NDEBUG
 302     LOG(WARNING) << "ScrollToMakeVisible on invalid object id " << acc_obj_id;
 303 #endif
 304     return;
 305   }
 306
 307   obj.scrollToMakeVisibleWithSubFocus(
 308       WebRect(subfocus.x(), subfocus.y(),
 309               subfocus.width(), subfocus.height()));
 310
 311   // Make sure the browser gets an event when the scroll
 312   // position actually changes.
 313   // TODO(dmazzoni): remove this once this bug is fixed:
 314   // https://bugs.webkit.org/show_bug.cgi?id=73460
 315   HandleAXEvent(document.accessibilityObject(),
 316                 ui::AX_EVENT_LAYOUT_COMPLETE);
 317 }
 318
 319 void RendererAccessibilityComplete::OnScrollToPoint(
 320     int acc_obj_id, gfx::Point point) {
 321   const WebDocument& document = GetMainDocument();
 322   if (document.isNull())
 323     return;
 324
 325   WebAXObject obj = document.accessibilityObjectFromID(acc_obj_id);
 326   if (obj.isDetached()) {
 327 #ifndef NDEBUG
 328     LOG(WARNING) << "ScrollToPoint on invalid object id " << acc_obj_id;
 329 #endif
 330     return;
 331   }
 332
 333   obj.scrollToGlobalPoint(WebPoint(point.x(), point.y()));
 334
 335   // Make sure the browser gets an event when the scroll
 336   // position actually changes.
 337   // TODO(dmazzoni): remove this once this bug is fixed:
 338   // https://bugs.webkit.org/show_bug.cgi?id=73460
 339   HandleAXEvent(document.accessibilityObject(),
 340                 ui::AX_EVENT_LAYOUT_COMPLETE);
 341 }
 342
 343 void RendererAccessibilityComplete::OnSetTextSelection(
 344     int acc_obj_id, int start_offset, int end_offset) {
 345   const WebDocument& document = GetMainDocument();
 346   if (document.isNull())
 347     return;
 348
 349   WebAXObject obj = document.accessibilityObjectFromID(acc_obj_id);
 350   if (obj.isDetached()) {
 351 #ifndef NDEBUG
 352     LOG(WARNING) << "SetTextSelection on invalid object id " << acc_obj_id;
 353 #endif
 354     return;
 355   }
 356
 357   // TODO(dmazzoni): support elements other than <input>.
 358   blink::WebNode node = obj.node();
 359   if (!node.isNull() && node.isElementNode()) {
 360     blink::WebElement element = node.to<blink::WebElement>();
 361     blink::WebInputElement* input_element =
 362         blink::toWebInputElement(&element);
 363     if (input_element && input_element->isTextField())
 364       input_element->setSelectionRange(start_offset, end_offset);
 365   }
 366 }
 367
 368 void RendererAccessibilityComplete::OnHitTest(gfx::Point point) {
 369   const WebDocument& document = GetMainDocument();
 370   if (document.isNull())
 371     return;
 372   WebAXObject root_obj = document.accessibilityObject();
 373   if (!root_obj.updateBackingStoreAndCheckValidity())
 374     return;
 375
 376   WebAXObject obj = root_obj.hitTest(point);
 377   if (!obj.isDetached())
 378     HandleAXEvent(obj, ui::AX_EVENT_HOVER);
 379 }
 380
 381 void RendererAccessibilityComplete::OnEventsAck() {
 382   DCHECK(ack_pending_);
 383   ack_pending_ = false;
 384   SendPendingAccessibilityEvents();
 385 }
 386
 387 void RendererAccessibilityComplete::OnSetFocus(int acc_obj_id) {
 388   const WebDocument& document = GetMainDocument();
 389   if (document.isNull())
 390     return;
 391
 392   WebAXObject obj = document.accessibilityObjectFromID(acc_obj_id);
 393   if (obj.isDetached()) {
 394 #ifndef NDEBUG
 395     LOG(WARNING) << "OnSetAccessibilityFocus on invalid object id "
 396                  << acc_obj_id;
 397 #endif
 398     return;
 399   }
 400
 401   WebAXObject root = document.accessibilityObject();
 402   if (root.isDetached()) {
 403 #ifndef NDEBUG
 404     LOG(WARNING) << "OnSetAccessibilityFocus but root is invalid";
 405 #endif
 406     return;
 407   }
 408
 409   // By convention, calling SetFocus on the root of the tree should clear the
 410   // current focus. Otherwise set the focus to the new node.
 411   if (acc_obj_id == root.axID())
 412     render_frame_->GetRenderView()->GetWebView()->clearFocusedElement();
 413   else
 414     obj.setFocused(true);
 415 }
 416
 417 void RendererAccessibilityComplete::OnFatalError() {
 418   CHECK(false) << "Invalid accessibility tree.";
 419 }
 420
 421 }  // namespace content