Initial support for native accessibility in ARC

components/exo/shell_surface_unittest.cc

 // Copyright 2015 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 "ash/common/accessibility_delegate.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm/wm_event.h"
 #include "ash/common/wm_shell.h"
 #include "ash/common/wm_window.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/wm/window_state_aura.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
+#include "components/exo/ax_tree_source_surface.h"
 #include "components/exo/buffer.h"
 #include "components/exo/display.h"
 #include "components/exo/shell_surface.h"
 #include "components/exo/sub_surface.h"
 #include "components/exo/surface.h"
 #include "components/exo/test/exo_test_base.h"
 #include "components/exo/test/exo_test_helper.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/window.h"
@@ skipping 798 matching lines @@
   ash::WmShell::Get()->accessibility_delegate()->ToggleSpokenFeedback(
       ash::A11Y_NOTIFICATION_NONE);
   shell_surface.OnAccessibilityModeChanged();
   shell_surface2.OnAccessibilityModeChanged();
 
   EXPECT_TRUE(shell_surface.shadow_underlay()->IsVisible());
   EXPECT_EQ(shadow_bounds, shell_surface.shadow_underlay()->bounds());
   EXPECT_EQ(shadow_bounds, shell_surface2.shadow_underlay()->bounds());
 }
 
+class FakeAXTreeSource : public AXTreeSourceSurface {
+ public:
+  bool GetTreeData(ui::AXTreeData* data) const override {
+    // In a real implementation, the embedder would point to this tree with a
+    // child tree id.
+    return false;
+  }
+
+  ui::AXNode* GetRoot() const override { return nullptr; }
+
+  ui::AXNode* GetFromId(int32_t id) const override { return nullptr; }
+
+  int32_t GetId(ui::AXNode* node) const override { return 1; }
+
+  void GetChildren(ui::AXNode* node,
+                   std::vector<ui::AXNode*>* out_children) const override {}
+
+  ui::AXNode* GetParent(ui::AXNode* node) const override { return nullptr; }
+
+  bool IsValid(ui::AXNode* node) const override { return false; }
+
+  bool IsEqual(ui::AXNode* node1, ui::AXNode* node2) const override {
+    return false;
+  }
+
+  ui::AXNode* GetNull() const override { return nullptr; }
+
+  void SerializeNode(ui::AXNode* node,
+                     ui::AXNodeData* out_data) const override {}
+
+ protected:
+  void Reset() override {
+    // Reset indicates we should initialize or reinitialize tree data
+    // e.g. when new observers are added.
+    // For testing, fire an event.
+    NotifyAccessibilityEvent(2U, ui::AX_EVENT_FOCUS);
+  }
+};
+
+class FakeAXTreeSourceObserver : public AXTreeSourceSurface::Observer {
+ public:
+  void OnAccessibilityEvent(uint32_t node_id, ui::AXEvent event) override {
+    // A real implementation might send this event to an extension.
+    events.push_back(std::pair<uint32_t, ui::AXEvent>(node_id, event));
+  }
+
+  std::vector<std::pair<uint32_t, ui::AXEvent>> events;
+};
+
+TEST_F(ShellSurfaceTest, AccessibilityNodeData) {
+  gfx::Size buffer_size(256, 256);
+  Buffer buffer(exo_test_helper()->CreateGpuMemoryBuffer(buffer_size));
+  Surface surface;
+  ShellSurface shell_surface(&surface, nullptr, gfx::Rect(640, 480), true,
+                             false, ash::kShellWindowId_DefaultContainer);
+
+  surface.Attach(&buffer);
+
+  FakeAXTreeSource tree_source;
+  FakeAXTreeSourceObserver tree_source_observer;
+
+  // An embedder might get here by tracking focused windows.
+  surface.set_ax_tree_source(&tree_source);
+
+  // At this point, the tree source is empty. Once an embedder sees a shell
+  // surface window, the embedder can observe the tree source at which point the
+  // source tree will fetch data and fire any initial events. The test simulates
+  // the steps expected.
+  tree_source.AddObserver(&tree_source_observer);
+
+  ASSERT_EQ(1U, tree_source_observer.events.size());
+  ASSERT_EQ(2U, tree_source_observer.events.front().first);
+  ASSERT_EQ(ui::AX_EVENT_FOCUS, tree_source_observer.events.front().second);
+}
+
 }  // namespace
 }  // namespace exo