Add a WebContentsImpl API to snapshot the accessibility tree.

content/browser/frame_host/render_frame_host_impl.cc

 // Copyright 2013 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/browser/frame_host/render_frame_host_impl.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/containers/hash_tables.h"
 #include "base/lazy_instance.h"
@@ skipping 46 matching lines @@
 #include "content/public/browser/permission_type.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/stream_handle.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/common/url_utils.h"
 #include "ui/accessibility/ax_tree.h"
+#include "ui/accessibility/ax_tree_update.h"
 #include "url/gurl.h"
 
 #if defined(OS_MACOSX)
 #include "content/browser/frame_host/popup_menu_helper_mac.h"
 #endif
 
 #if defined(ENABLE_MEDIA_MOJO_RENDERER)
 #include "media/mojo/interfaces/media_renderer.mojom.h"
 #include "media/mojo/services/mojo_renderer_service.h"
 #endif
@@ skipping 297 matching lines @@
     IPC_MESSAGE_HANDLER(FrameHostMsg_BeginNavigation,
                         OnBeginNavigation)
     IPC_MESSAGE_HANDLER(FrameHostMsg_DispatchLoad, OnDispatchLoad)
     IPC_MESSAGE_HANDLER(FrameHostMsg_TextSurroundingSelectionResponse,
                         OnTextSurroundingSelectionResponse)
     IPC_MESSAGE_HANDLER(AccessibilityHostMsg_Events, OnAccessibilityEvents)
     IPC_MESSAGE_HANDLER(AccessibilityHostMsg_LocationChanges,
                         OnAccessibilityLocationChanges)
     IPC_MESSAGE_HANDLER(AccessibilityHostMsg_FindInPageResult,
                         OnAccessibilityFindInPageResult)
+    IPC_MESSAGE_HANDLER(AccessibilityHostMsg_SnapshotResponse,
+                        OnAccessibilitySnapshotResponse)
     IPC_MESSAGE_HANDLER(FrameHostMsg_ToggleFullscreen, OnToggleFullscreen)
     // The following message is synthetic and doesn't come from RenderFrame, but
     // from RenderProcessHost.
     IPC_MESSAGE_HANDLER(FrameHostMsg_RenderProcessGone, OnRenderProcessGone)
 #if defined(OS_MACOSX) || defined(OS_ANDROID)
     IPC_MESSAGE_HANDLER(FrameHostMsg_ShowPopup, OnShowPopup)
     IPC_MESSAGE_HANDLER(FrameHostMsg_HidePopup, OnHidePopup)
 #endif
   IPC_END_MESSAGE_MAP()
 
@@ skipping 991 matching lines @@
     BrowserAccessibilityManager* manager =
         GetOrCreateBrowserAccessibilityManager();
     if (manager) {
       manager->OnFindInPageResult(
           params.request_id, params.match_index, params.start_id,
           params.start_offset, params.end_id, params.end_offset);
     }
   }
 }
 
+void RenderFrameHostImpl::OnAccessibilitySnapshotResponse(
+    int token,

[Charlie Reis, 2015/04/02 23:09:06]

"token" seems like an ambiguous name here.

[dmazzoni, 2015/04/03 22:49:41]

Happy to switch to "id" if you prefer, but deferring fixing this until we
resolve the next comment bleow:

[Charlie Reis, 2015/04/06 21:56:51]

"id" isn't any less ambiguous, but at least it's consistent with
OnJavaScriptExecuteResponse.  I guess we can do that until a general approach is
added.

[dmazzoni, 2015/04/09 18:39:01]

Done.

+    const ui::AXTreeUpdate& snapshot) {
+  std::map<int, AXTreeSnapshotCallback>::iterator it =
+      ax_tree_snapshot_callbacks_.find(token);
+  if (it != ax_tree_snapshot_callbacks_.end()) {
+    it->second.Run(snapshot);
+    ax_tree_snapshot_callbacks_.erase(it);
+  } else {
+    NOTREACHED() << "Received AX tree snapshot response for unknown request";
+  }
+}
+
 void RenderFrameHostImpl::OnToggleFullscreen(bool enter_fullscreen) {
   if (enter_fullscreen)
     delegate_->EnterFullscreenMode(GetLastCommittedURL().GetOrigin());
   else
     delegate_->ExitFullscreenMode();
 
   // The previous call might change the fullscreen state. We need to make sure
   // the renderer is aware of that, which is done via the resize message.
   render_view_host_->WasResized();
 }
@@ skipping 393 matching lines @@
   // As a sanity check, make sure the frame belongs to the same BrowserContext.
   CHECK_EQ(GetSiteInstance()->GetBrowserContext(),
            other_render_frame_host->GetSiteInstance()->GetBrowserContext());
   return GetSiteInstance() == other_render_frame_host->GetSiteInstance();
 }
 
 void RenderFrameHostImpl::SetAccessibilityMode(AccessibilityMode mode) {
   Send(new FrameMsg_SetAccessibilityMode(routing_id_, mode));
 }
 
+void RenderFrameHostImpl::RequestAXTreeSnapshot(
+    AXTreeSnapshotCallback callback) {
+  static int next_token = 1;

[Charlie Reis, 2015/04/02 23:09:06]

This feels like an awkward pattern.  We haven't really needed to track callbacks
for individual calls to RFH APIs before.  Why is it needed here?  I don't see
any uses of it in this CL, so I don't know alternatives to suggest or why you
might need multiple outstanding requests.

[dmazzoni, 2015/04/03 22:49:41]

FWIW, I copied this code nearly verbatim from ExecuteJavaScript, above. Happy to
replace it, but it doesn't seem that awkward to me - and most importantly, I
think it's more important that RFHI exposes a simple and pretty foolproof API
(make a request, get a callback) so that the slight messiness of waiting for the
IPC response and matching it with the callback is localized here rather than
leaked.

See the bug for more context on how this might be used. The rest of the code
that's going to make use of this is still being written and I don't know exactly
how it might be used. It seemed the most general possible to implement it this
way.

The other possibilities would be:
1. Only allow one outstanding request, reject others while one is pending
2. Keep a list of all callbacks while one request is pending

With either of those solutions, we'd probably have to implement a timeout too,
otherwise if a render process dies then no callbacks after that one would
succeed. I'm not sure that's actually any simpler. With the current solution we
don't really need a timeout - if a render process dies then one request might
never return and we might leak the closure, but subsequent requests would be
unaffected.

[Charlie Reis, 2015/04/06 21:56:50]

Oh, I'd never seen that.  Ok, I'll defer, since that seems to go back quite a
way.

(The pattern doesn't seem scalable to me-- RFHI shouldn't have to track state
for every one of its request/response APIs, especially if that state needs
maintenance for things like the process dying.  Maybe some day that can be made
generalizable, but this will do for the moment.)
If the renderer process dies, we should be able to clear all the current
callbacks, right?  We won't hear any response for them after that.

(If you agree, Avi and I can do a similar thing for ExecuteJavaScript.)

+  int token = next_token++;
+  Send(new AccessibilityMsg_SnapshotTree(routing_id_, token));
+  ax_tree_snapshot_callbacks_.insert(std::make_pair(token, callback));
+}
+
 void RenderFrameHostImpl::SetAccessibilityCallbackForTesting(
     const base::Callback<void(ui::AXEvent, int)>& callback) {
   accessibility_testing_callback_ = callback;
 }
 
 const ui::AXTree* RenderFrameHostImpl::GetAXTreeForTesting() {
   return ax_tree_for_testing_.get();
 }
 
 BrowserAccessibilityManager*
@@ skipping 131 matching lines @@
     return;
 
   permission_manager->RegisterPermissionUsage(
       PermissionType::GEOLOCATION,
       GetLastCommittedURL().GetOrigin(),
       frame_tree_node()->frame_tree()->GetMainFrame()
           ->GetLastCommittedURL().GetOrigin());
 }
 
 }  // namespace content