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