Inject AXAuraObjCache into AX object wrapper classes

This eliminates calls to AXAuraObjCache::GetInstance() and is a step
towards making the cache not be a singleton.

Bug: 888147
Test: views_unittests
Change-Id: I94dee9693881ff760be1c32b084072379e5d803b
Reviewed-on: https://chromium-review.googlesource.com/c/1359093
Commit-Queue: James Cook <jamescook@chromium.org>
Reviewed-by: David Tseng <dtseng@chromium.org>
Cr-Commit-Position: refs/heads/master@{#614740}

ui/views/accessibility/ax_aura_obj_cache.cc

@@ -207,7 +207,7 @@ AXAuraObjWrapper* AXAuraObjCache::CreateInternal(
   if (it != aura_view_to_id_map.end())
     return Get(it->second);
 
-  auto wrapper = std::make_unique<AuraViewWrapper>(aura_view);
+  auto wrapper = std::make_unique<AuraViewWrapper>(this, aura_view);
   int32_t id = wrapper->GetUniqueId();
   aura_view_to_id_map[aura_view] = id;
   cache_[id] = std::move(wrapper);

ui/views/accessibility/ax_view_obj_wrapper.cc

@@ -14,9 +14,10 @@
 
 namespace views {
 
-AXViewObjWrapper::AXViewObjWrapper(View* view)  : view_(view) {
+AXViewObjWrapper::AXViewObjWrapper(AXAuraObjCache* aura_obj_cache, View* view)
+    : aura_obj_cache_(aura_obj_cache), view_(view) {
   if (view->GetWidget())
-    AXAuraObjCache::GetInstance()->GetOrCreate(view->GetWidget());
+    aura_obj_cache_->GetOrCreate(view->GetWidget());
   view->AddObserver(this);
 }
 
@@ -35,12 +36,11 @@ AXAuraObjWrapper* AXViewObjWrapper::GetParent() {
   if (!view_)
     return nullptr;
 
-  AXAuraObjCache* cache = AXAuraObjCache::GetInstance();
   if (view_->parent())
-    return cache->GetOrCreate(view_->parent());
+    return aura_obj_cache_->GetOrCreate(view_->parent());
 
   if (view_->GetWidget())
-    return cache->GetOrCreate(view_->GetWidget());
+    return aura_obj_cache_->GetOrCreate(view_->GetWidget());
 
   return nullptr;
 }
@@ -58,8 +58,7 @@ void AXViewObjWrapper::GetChildren(
     if (!view_->child_at(i)->visible())
       continue;
 
-    AXAuraObjWrapper* child =
-        AXAuraObjCache::GetInstance()->GetOrCreate(view_->child_at(i));
+    AXAuraObjWrapper* child = aura_obj_cache_->GetOrCreate(view_->child_at(i));
     out_children->push_back(child);
   }
 }

ui/views/accessibility/ax_view_obj_wrapper.h

@@ -12,12 +12,14 @@
 #include "ui/views/view_observer.h"
 
 namespace views {
+class AXAuraObjCache;
 class View;
 
 // Describes a |View| for use with other AX classes.
 class AXViewObjWrapper : public AXAuraObjWrapper, public ViewObserver {
  public:
-  explicit AXViewObjWrapper(View* view);
+  // |aura_obj_cache| must outlive this object.
+  AXViewObjWrapper(AXAuraObjCache* aura_obj_cache, View* view);
   ~AXViewObjWrapper() override;
 
   View* view() { return view_; }
@@ -34,6 +36,8 @@ class AXViewObjWrapper : public AXAuraObjWrapper, public ViewObserver {
   void OnViewIsDeleting(View* observed_view) override;
 
  private:
+  AXAuraObjCache* const aura_obj_cache_;
+
   View* view_;
 
   DISALLOW_COPY_AND_ASSIGN(AXViewObjWrapper);

ui/views/accessibility/ax_widget_obj_wrapper.cc

@@ -13,13 +13,15 @@
 
 namespace views {
 
-AXWidgetObjWrapper::AXWidgetObjWrapper(Widget* widget) : widget_(widget) {
+AXWidgetObjWrapper::AXWidgetObjWrapper(AXAuraObjCache* aura_obj_cache,
+                                       Widget* widget)
+    : aura_obj_cache_(aura_obj_cache), widget_(widget) {
   widget->AddObserver(this);
   widget->AddRemovalsObserver(this);
 }
 
 AXWidgetObjWrapper::~AXWidgetObjWrapper() {
-  if (!AXAuraObjCache::GetInstance()->is_destroying()) {
+  if (!aura_obj_cache_->is_destroying()) {
     widget_->RemoveObserver(this);
     widget_->RemoveRemovalsObserver(this);
   }
@@ -31,7 +33,7 @@ bool AXWidgetObjWrapper::IsIgnored() {
 }
 
 AXAuraObjWrapper* AXWidgetObjWrapper::GetParent() {
-  return AXAuraObjCache::GetInstance()->GetOrCreate(widget_->GetNativeView());
+  return aura_obj_cache_->GetOrCreate(widget_->GetNativeView());
 }
 
 void AXWidgetObjWrapper::GetChildren(
@@ -41,8 +43,7 @@ void AXWidgetObjWrapper::GetChildren(
     return;
   }
 
-  out_children->push_back(
-      AXAuraObjCache::GetInstance()->GetOrCreate(widget_->GetRootView()));
+  out_children->push_back(aura_obj_cache_->GetOrCreate(widget_->GetRootView()));
 }
 
 void AXWidgetObjWrapper::Serialize(ui::AXNodeData* out_node_data) {
@@ -62,21 +63,21 @@ int32_t AXWidgetObjWrapper::GetUniqueId() const {
 }
 
 void AXWidgetObjWrapper::OnWidgetDestroying(Widget* widget) {
-  AXAuraObjCache::GetInstance()->Remove(widget);
+  aura_obj_cache_->Remove(widget);
 }
 
 void AXWidgetObjWrapper::OnWidgetClosing(Widget* widget) {
-  AXAuraObjCache::GetInstance()->Remove(widget);
+  aura_obj_cache_->Remove(widget);
 }
 
 void AXWidgetObjWrapper::OnWidgetVisibilityChanged(Widget*, bool) {
   // If a widget changes visibility it may affect what's focused, in particular
   // when a widget that contains the focused view gets hidden.
-  AXAuraObjCache::GetInstance()->OnFocusedViewChanged();
+  aura_obj_cache_->OnFocusedViewChanged();
 }
 
 void AXWidgetObjWrapper::OnWillRemoveView(Widget* widget, View* view) {
-  AXAuraObjCache::GetInstance()->RemoveViewSubtree(view);
+  aura_obj_cache_->RemoveViewSubtree(view);
 }
 
 }  // namespace views

ui/views/accessibility/ax_widget_obj_wrapper.h

@@ -14,6 +14,7 @@
 #include "ui/views/widget/widget_removals_observer.h"
 
 namespace views {
+class AXAuraObjCache;
 class Widget;
 
 // Describes a |Widget| for use with other AX classes.
@@ -21,7 +22,8 @@ class AXWidgetObjWrapper : public AXAuraObjWrapper,
                            public WidgetObserver,
                            public WidgetRemovalsObserver {
  public:
-  explicit AXWidgetObjWrapper(Widget* widget);
+  // |aura_obj_cache| must outlive this object.
+  AXWidgetObjWrapper(AXAuraObjCache* aura_obj_cache, Widget* widget);
   ~AXWidgetObjWrapper() override;
 
   // AXAuraObjWrapper overrides.
@@ -40,6 +42,8 @@ class AXWidgetObjWrapper : public AXAuraObjWrapper,
   void OnWillRemoveView(Widget* widget, View* view) override;
 
  private:
+  AXAuraObjCache* const aura_obj_cache_;
+
   Widget* widget_;
 
   const ui::AXUniqueId unique_id_;

ui/views/accessibility/ax_window_obj_wrapper.cc

@@ -40,44 +40,23 @@ Widget* GetWidgetForWindow(aura::Window* window) {
 
 }  // namespace
 
-// A helper to fire an event on a window, taking into account its associated
-// widget and that widget's root view.
-void FireEvent(aura::Window* window, ax::mojom::Event event_type) {
-  AXAuraObjCache::GetInstance()->FireEvent(
-      AXAuraObjCache::GetInstance()->GetOrCreate(window), event_type);
-
-  Widget* widget = GetWidgetForWindow(window);
-  if (widget) {
-    AXAuraObjCache::GetInstance()->FireEvent(
-        AXAuraObjCache::GetInstance()->GetOrCreate(widget), event_type);
-
-    views::View* root_view = widget->GetRootView();
-    if (root_view)
-      root_view->NotifyAccessibilityEvent(event_type, true);
-  }
-
-  aura::Window::Windows children =
-      AXAuraWindowUtils::Get()->GetChildren(window);
-  for (size_t i = 0; i < children.size(); ++i)
-    FireEvent(children[i], ax::mojom::Event::kLocationChanged);
-}
-
-AXWindowObjWrapper::AXWindowObjWrapper(aura::Window* window)
-    : window_(window),
+AXWindowObjWrapper::AXWindowObjWrapper(AXAuraObjCache* aura_obj_cache,
+                                       aura::Window* window)
+    : aura_obj_cache_(aura_obj_cache),
+      window_(window),
       is_alert_(false),
       is_root_window_(window->IsRootWindow()) {
   window->AddObserver(this);
 
   if (is_root_window_)
-    AXAuraObjCache::GetInstance()->OnRootWindowObjCreated(window);
+    aura_obj_cache_->OnRootWindowObjCreated(window);
 }
 
 AXWindowObjWrapper::~AXWindowObjWrapper() {
   if (is_root_window_)
-    AXAuraObjCache::GetInstance()->OnRootWindowObjDestroyed(window_);
+    aura_obj_cache_->OnRootWindowObjDestroyed(window_);
 
   window_->RemoveObserver(this);
-  window_ = NULL;
 }
 
 bool AXWindowObjWrapper::IsIgnored() {
@@ -89,7 +68,7 @@ AXAuraObjWrapper* AXWindowObjWrapper::GetParent() {
   if (!parent)
     return nullptr;
 
-  return AXAuraObjCache::GetInstance()->GetOrCreate(parent);
+  return aura_obj_cache_->GetOrCreate(parent);
 }
 
 void AXWindowObjWrapper::GetChildren(
@@ -97,14 +76,13 @@ void AXWindowObjWrapper::GetChildren(
   aura::Window::Windows children =
       AXAuraWindowUtils::Get()->GetChildren(window_);
   for (size_t i = 0; i < children.size(); ++i) {
-    out_children->push_back(
-        AXAuraObjCache::GetInstance()->GetOrCreate(children[i]));
+    out_children->push_back(aura_obj_cache_->GetOrCreate(children[i]));
   }
 
   // Also consider any associated widgets as children.
   Widget* widget = GetWidgetForWindow(window_);
   if (widget && widget->IsVisible())
-    out_children->push_back(AXAuraObjCache::GetInstance()->GetOrCreate(widget));
+    out_children->push_back(aura_obj_cache_->GetOrCreate(widget));
 }
 
 void AXWindowObjWrapper::Serialize(ui::AXNodeData* out_node_data) {
@@ -146,19 +124,19 @@ int32_t AXWindowObjWrapper::GetUniqueId() const {
 }
 
 void AXWindowObjWrapper::OnWindowDestroyed(aura::Window* window) {
-  AXAuraObjCache::GetInstance()->Remove(window, nullptr);
+  aura_obj_cache_->Remove(window, nullptr);
 }
 
 void AXWindowObjWrapper::OnWindowDestroying(aura::Window* window) {
   Widget* widget = GetWidgetForWindow(window);
   if (widget)
-    AXAuraObjCache::GetInstance()->Remove(widget);
+    aura_obj_cache_->Remove(widget);
 }
 
 void AXWindowObjWrapper::OnWindowHierarchyChanged(
     const HierarchyChangeParams& params) {
   if (params.phase == WindowObserver::HierarchyChangeParams::HIERARCHY_CHANGED)
-    AXAuraObjCache::GetInstance()->Remove(params.target, params.old_parent);
+    aura_obj_cache_->Remove(params.target, params.old_parent);
 }
 
 void AXWindowObjWrapper::OnWindowBoundsChanged(
@@ -176,15 +154,13 @@ void AXWindowObjWrapper::OnWindowPropertyChanged(aura::Window* window,
                                                  const void* key,
                                                  intptr_t old) {
   if (window == window_ && key == ui::kChildAXTreeID) {
-    AXAuraObjCache::GetInstance()->FireEvent(
-        this, ax::mojom::Event::kChildrenChanged);
+    aura_obj_cache_->FireEvent(this, ax::mojom::Event::kChildrenChanged);
   }
 }
 
 void AXWindowObjWrapper::OnWindowVisibilityChanged(aura::Window* window,
                                                    bool visible) {
-  AXAuraObjCache::GetInstance()->FireEvent(this,
-                                           ax::mojom::Event::kStateChanged);
+  aura_obj_cache_->FireEvent(this, ax::mojom::Event::kStateChanged);
 }
 
 void AXWindowObjWrapper::OnWindowTransformed(aura::Window* window,
@@ -199,4 +175,24 @@ void AXWindowObjWrapper::OnWindowTitleChanged(aura::Window* window) {
   FireEvent(window, ax::mojom::Event::kTextChanged);
 }
 
+void AXWindowObjWrapper::FireEvent(aura::Window* window,
+                                   ax::mojom::Event event_type) {
+  aura_obj_cache_->FireEvent(aura_obj_cache_->GetOrCreate(window), event_type);
+
+  Widget* widget = GetWidgetForWindow(window);
+  if (widget) {
+    aura_obj_cache_->FireEvent(aura_obj_cache_->GetOrCreate(widget),
+                               event_type);
+
+    views::View* root_view = widget->GetRootView();
+    if (root_view)
+      root_view->NotifyAccessibilityEvent(event_type, true);
+  }
+
+  aura::Window::Windows children =
+      AXAuraWindowUtils::Get()->GetChildren(window);
+  for (size_t i = 0; i < children.size(); ++i)
+    FireEvent(children[i], ax::mojom::Event::kLocationChanged);
+}
+
 }  // namespace views

ui/views/accessibility/ax_window_obj_wrapper.h

@@ -8,6 +8,7 @@
 #include <stdint.h>
 
 #include "base/macros.h"
+#include "ui/accessibility/ax_enums.mojom.h"
 #include "ui/accessibility/platform/ax_unique_id.h"
 #include "ui/aura/window_observer.h"
 #include "ui/views/accessibility/ax_aura_obj_wrapper.h"
@@ -17,12 +18,14 @@ class Window;
 }  // namespace aura
 
 namespace views {
+class AXAuraObjCache;
 
 // Describes a |Window| for use with other AX classes.
 class AXWindowObjWrapper : public AXAuraObjWrapper,
                            public aura::WindowObserver {
  public:
-  explicit AXWindowObjWrapper(aura::Window* window);
+  // |aura_obj_cache| and |window| must outlive this object.
+  AXWindowObjWrapper(AXAuraObjCache* aura_obj_cache, aura::Window* window);
   ~AXWindowObjWrapper() override;
 
   // Whether this window is an alert window.
@@ -55,6 +58,12 @@ class AXWindowObjWrapper : public AXAuraObjWrapper,
   void OnWindowTitleChanged(aura::Window* window) override;
 
  private:
+  // Fires an event on a window, taking into account its associated widget and
+  // that widget's root view.
+  void FireEvent(aura::Window* window, ax::mojom::Event event_type);
+
+  AXAuraObjCache* const aura_obj_cache_;
+
   aura::Window* window_;
 
   bool is_alert_;