Take a snapshot of the AXTree

content/browser/web_contents/web_contents_android.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/web_contents/web_contents_android.h"
 
 #include "base/android/jni_android.h"
+#include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
+#include "content/browser/accessibility/browser_accessibility_android.h"
+#include "content/browser/accessibility/browser_accessibility_manager.h"
 #include "content/browser/android/interstitial_page_delegate_android.h"
 #include "content/browser/frame_host/interstitial_page_impl.h"
 #include "content/browser/media/android/browser_media_player_manager.h"
 #include "content/browser/media/media_web_contents_observer.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/common/devtools_messages.h"
 #include "content/common/frame_messages.h"
 #include "content/common/input_messages.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_switches.h"
 #include "jni/WebContentsImpl_jni.h"
 #include "net/android/network_library.h"
+#include "ui/accessibility/ax_node_data.h"
 
 using base::android::AttachCurrentThread;
 using base::android::ConvertJavaStringToUTF8;
 using base::android::ConvertJavaStringToUTF16;
 using base::android::ConvertUTF8ToJavaString;
+using base::android::ConvertUTF16ToJavaString;
 using base::android::ScopedJavaGlobalRef;
+using base::android::ToJavaIntArray;
 
 namespace {
 
 void JavaScriptResultCallback(const ScopedJavaGlobalRef<jobject>& callback,
                               const base::Value* result) {
   JNIEnv* env = base::android::AttachCurrentThread();
   std::string json;
   base::JSONWriter::Write(result, &json);
   ScopedJavaLocalRef<jstring> j_json = ConvertUTF8ToJavaString(env, json);
   content::Java_WebContentsImpl_onEvaluateJavaScriptResult(

[dmazzoni, 2015/04/10 19:20:00]

Is there a reason not to use "namespace content" inside this file? It doesn't
make sense to me to see content:: frequently when this source file is already
within content.

If there's a good reason, I'd suggest some "using" declarations at the top to
make the code more readable, like:

using content::BrowserAccessibilityManager

etc.

[sgurun-gerrit only, 2015/04/10 23:24:50]

Done.

       env, j_json.obj(), callback.obj());
 }
 
+ScopedJavaLocalRef<jobject> WalkAXTreeDepthFirst(JNIEnv* env,
+      content::BrowserAccessibilityAndroid* node) {
+
+  ScopedJavaLocalRef<jstring> j_text =
+      ConvertUTF16ToJavaString(env,node->GetText());
+  ScopedJavaLocalRef<jstring> j_class =
+      ConvertUTF8ToJavaString(env,node->GetClassName());
+  const gfx::Rect& location = node->GetLocation();
+  ScopedJavaLocalRef<jobject> j_node =
+      content::Java_WebContentsImpl_createAXNode(env,
+          node->GetId(), location.x(), location.y(), node->GetScrollX(),
+          node->GetScrollY(), location.width(), location.height(),
+          j_text.obj(), j_class.obj());
+
+  for(uint32 i = 0; i < node->PlatformChildCount(); i++) {
+    content::BrowserAccessibilityAndroid* child =
+        static_cast<content::BrowserAccessibilityAndroid*>(
+            node->PlatformGetChild(i));
+    content::Java_WebContentsImpl_addAXNodeAsChild(env,
+        j_node.obj(), WalkAXTreeDepthFirst(env, child).obj());
+  }
+  return j_node;
+}
+
+
+void AXTreeSnapshotCallback(const ScopedJavaGlobalRef<jobject>& callback,
+                            const ui::AXTreeUpdate& result) {
+  JNIEnv* env = base::android::AttachCurrentThread();
+  scoped_ptr<content::BrowserAccessibilityManager> manager(
+      content::BrowserAccessibilityManager::Create(result, nullptr));
+  content::BrowserAccessibilityAndroid* root =
+      static_cast<content::BrowserAccessibilityAndroid*>(manager->GetRoot());
+  // TODO(sgurun) check if root can be null here.

[dmazzoni, 2015/04/10 19:20:00]

You should probably first check if result.nodes is empty and consider that a
failure if so.

Otherwise, BrowserAccessibilityManager will parse the AXTreeUpdate and it will
always have a valid root if so.

I just realize that if it fails to parse it either calls the delegate if it has
one, or exits with a fatal error if not, so you may want to consider whether you
want to provide a delegate.

There's no valid reason you should get a bad AXTreeUpdate, it's just a question
of if you have a compromised or corrupted renderer if you want to return an
error or just crash the whole program.

[sgurun-gerrit only, 2015/04/10 23:24:50]

Thanks, for webview we probably don't worry too much about a corrupted renderer
case since webview is single process, and if renderer is compromised/corrupted a
crash is likely imminent anyway. checked for the condition result.nodes is
empty.

[boliu, 2015/04/10 23:47:17]

Drive by meta-comment:

Single-process-ness of webview is irrelevant here. This is content code that is
multi-process in clank.

Also it's just generally bad even in webview-only code trust information from
renderer. We should follow chrome's pattern of checking as well.

+  ScopedJavaLocalRef<jobject> j_root = WalkAXTreeDepthFirst(env, root);
+  content::Java_WebContentsImpl_onAXTreeSnapshot(
+      env, j_root.obj(), callback.obj());
+}
+
 void ReleaseAllMediaPlayers(content::WebContents* web_contents,
                             content::RenderFrameHost* render_frame_host) {
   content::BrowserMediaPlayerManager* manager =
       static_cast<content::WebContentsImpl*>(web_contents)->
           media_web_contents_observer()->GetMediaPlayerManager(
               render_frame_host);
   if (manager)
     manager->ReleaseAllMediaPlayers();
 }
 
@@ skipping 442 matching lines @@
     JNIEnv* env,
     jobject jobj) {
   return static_cast<content::WebContentsImpl*>(web_contents_)->
       HasAccessedInitialDocument();
 }
 
 jint WebContentsAndroid::GetThemeColor(JNIEnv* env, jobject obj) {
   return web_contents_->GetThemeColor();
 }
 
+void WebContentsAndroid::RequestAXTreeSnapshot(JNIEnv* env,
+                                               jobject obj,
+                                               jobject callback) {
+  // Secure the Java callback in a scoped object and give ownership of it to the
+  // base::Callback.
+  ScopedJavaGlobalRef<jobject> j_callback;
+  j_callback.Reset(env, callback);
+  content::WebContentsImpl::AXTreeSnapshotCallback snapshot_callback =
+      base::Bind(&AXTreeSnapshotCallback, j_callback);
+
+  static_cast<WebContentsImpl*>(web_contents_)->RequestAXTreeSnapshot(
+      snapshot_callback);
+}
+
 }  // namespace content