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
24using blink::WebAXObject;
25using blink::WebDocument;
26using blink::WebFrame;
27using blink::WebNode;
28using blink::WebPoint;
29using blink::WebRect;
30using blink::WebSettings;
31using blink::WebView;
32
33namespace content {
34
35RendererAccessibilityComplete::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
65RendererAccessibilityComplete::~RendererAccessibilityComplete() {
66}
67
68bool 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
91void 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
103void RendererAccessibilityComplete::HandleWebAccessibilityEvent(
104    const blink::WebAXObject& obj, blink::WebAXEvent event) {
105  HandleAXEvent(obj, AXEventFromBlink(event));
106}
107
108void 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
155RendererAccessibilityType RendererAccessibilityComplete::GetType() {
156  return RendererAccessibilityTypeComplete;
157}
158
159void 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
239void 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
280void 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
296void 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
322void 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
346void 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
371void 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
384void RendererAccessibilityComplete::OnEventsAck() {
385  DCHECK(ack_pending_);
386  ack_pending_ = false;
387  SendPendingAccessibilityEvents();
388}
389
390void 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
420void 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
430void RendererAccessibilityComplete::OnFatalError() {
431  CHECK(false) << "Invalid accessibility tree.";
432}
433
434}  // namespace content
435