Add an accessibility mode for editable text fields only.

content/renderer/renderer_accessibility.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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
-#include "content/common/accessibility_messages.h"
 #include "content/public/common/content_switches.h"
 #include "content/renderer/render_view_impl.h"
 #include "content/renderer/renderer_accessibility.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebAccessibilityObject.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebNode.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "webkit/glue/webaccessibility.h"
@@ skipping 58 matching lines @@
     case WebKit::WebAccessibilityNotificationValueChanged:
       *type = AccessibilityNotificationValueChangedD;
       break;
     default:
       NOTREACHED();
       return false;
   }
   return true;
 }
 
-RendererAccessibility::RendererAccessibility(RenderViewImpl* render_view)
+RendererAccessibility::RendererAccessibility(RenderViewImpl* render_view,
+                                             AccessibilityMode mode)
     : content::RenderViewObserver(render_view),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       browser_root_(NULL),
       last_scroll_offset_(gfx::Size()),
+      mode_(mode),
       ack_pending_(false),
       logging_(false) {
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
-  if (command_line.HasSwitch(switches::kEnableAccessibility))
-    WebAccessibilityObject::enableAccessibility();
   if (command_line.HasSwitch(switches::kEnableAccessibilityLogging))
     logging_ = true;
 }
 
 RendererAccessibility::~RendererAccessibility() {
 }
 
 bool RendererAccessibility::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(RendererAccessibility, message)
-    IPC_MESSAGE_HANDLER(AccessibilityMsg_Enable, OnEnable)
+    IPC_MESSAGE_HANDLER(AccessibilityMsg_SetMode, OnSetMode)
     IPC_MESSAGE_HANDLER(AccessibilityMsg_SetFocus, OnSetFocus)
     IPC_MESSAGE_HANDLER(AccessibilityMsg_DoDefaultAction,
                         OnDoDefaultAction)
     IPC_MESSAGE_HANDLER(AccessibilityMsg_Notifications_ACK,
                         OnNotificationsAck)
     IPC_MESSAGE_HANDLER(AccessibilityMsg_ScrollToMakeVisible,
                         OnScrollToMakeVisible)
     IPC_MESSAGE_HANDLER(AccessibilityMsg_ScrollToPoint,
                         OnScrollToPoint)
     IPC_MESSAGE_HANDLER(AccessibilityMsg_SetTextSelection,
@@ skipping 178 matching lines @@
         }
       }
       if (!is_child_of_parent) {
         obj = parent;
         notification.id = obj.axID();
         includes_children = true;
       }
     }
 
     AccessibilityHostMsg_NotificationParams notification_msg;
+    if (!BuildAccessibilityTree(
+            obj, includes_children, &notification_msg.acc_tree)) {
+      continue;
+    }
     WebAccessibilityNotificationToAccessibilityNotification(
         notification.type, &notification_msg.notification_type);
     notification_msg.id = notification.id;
     notification_msg.includes_children = includes_children;
-    notification_msg.acc_tree = WebAccessibility(obj, includes_children);
     if (obj.axID() == root_id) {
       DCHECK_EQ(notification_msg.acc_tree.role,
                 WebAccessibility::ROLE_WEB_AREA);
       notification_msg.acc_tree.role = WebAccessibility::ROLE_ROOT_WEB_AREA;
     }
     notification_msgs.push_back(notification_msg);
 
     if (includes_children)
       UpdateBrowserTree(notification_msg.acc_tree);
 
@@ skipping 158 matching lines @@
       input_element->setSelectionRange(start_offset, end_offset);
   }
 }
 
 void RendererAccessibility::OnNotificationsAck() {
   DCHECK(ack_pending_);
   ack_pending_ = false;
   SendPendingAccessibilityNotifications();
 }
 
-void RendererAccessibility::OnEnable() {
-  if (WebAccessibilityObject::accessibilityEnabled())
+void RendererAccessibility::OnSetMode(AccessibilityMode mode) {
+  if (mode_ == mode) {
     return;
+  }
+
+  mode_ = mode;
+  if (mode_ == AccessibilityModeOff) {
+    // Note: should we have a way to turn off WebKit accessibility?
+    // Right now it's a one-way switch.
+    return;
+  }
 
   WebAccessibilityObject::enableAccessibility();
 
   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 'load complete' notification.
     PostAccessibilityNotification(
         document.accessibilityObject(),
@@ skipping 52 matching lines @@
 
 WebDocument RendererAccessibility::GetMainDocument() {
   WebView* view = render_view()->GetWebView();
   WebFrame* main_frame = view ? view->mainFrame() : NULL;
 
   if (main_frame)
     return main_frame->document();
   else
     return WebDocument();
 }
+
+bool RendererAccessibility::IsEditableText(const WebAccessibilityObject& obj) {
+  return (obj.roleValue() == WebKit::WebAccessibilityRoleTextArea ||
+          obj.roleValue() == WebKit::WebAccessibilityRoleTextField);
+}
+
+void RendererAccessibility::RecursiveAddEditableTextNodesToTree(
+    const WebAccessibilityObject& src,
+    WebAccessibility* dst) {
+  if (IsEditableText(src)) {
+    dst->children.push_back(WebAccessibility(src, false));
+  } else {
+    int child_count = src.childCount();
+    std::set<int32> child_ids;
+    for (int i = 0; i < child_count; ++i) {
+      WebAccessibilityObject child = src.childAt(i);
+      if (!child.isValid())
+        continue;
+      RecursiveAddEditableTextNodesToTree(child, dst);
+    }
+  }
+}
+
+bool RendererAccessibility::BuildAccessibilityTree(
+    const WebAccessibilityObject& src,
+    bool include_children,
+    WebAccessibility* dst) {
+  const WebDocument& document = GetMainDocument();
+  if (document.isNull())
+    return false;
+  WebAccessibilityObject root = document.accessibilityObject();
+
+  if (mode_ == AccessibilityModeComplete) {
+    dst->Init(src, include_children);
+    return true;
+  }
+
+  // In Editable Text mode, we send a "collapsed" tree of only editable

[David Tseng, 2012/04/05 01:01:25]

Ignoring notifications seems risky; what happens if a children changed
notification gets fired on a parent of a text field that then removes the text
field?

[dmazzoni, 2012/04/06 21:47:22]

Actually it turns out I can get rid of this code path because it will never be
called. If a notification is sent on a node other than an editable text node,
the logic in SendPendingAccessibilityNotifications will go up to the root (see
the comment starting with "The browser may not have this object yet...").

I modified this method to return void.

We should add more optimizations later to send as few notifications as possible,
but this seems to work now.

+  // text nodes as direct descendants of the root. If a notification is
+  // sent on any node other than the root or an editable text node, ignore it.
+  CHECK_EQ(mode_, AccessibilityModeEditableTextOnly);
+  if (IsEditableText(src)) {
+    dst->Init(src, false);
+    return true;
+  }
+
+  if (src.axID() != root.axID())
+    return false;
+
+  // Initialize the main document node, but don't add any children.
+  dst->Init(src, false);
+
+  // Find all editable text nodes and add them as children.
+  RecursiveAddEditableTextNodesToTree(src, dst);
+
+  return true;
+}