ui/views/accessibility/ax_aura_obj_cache.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/views/accessibility/ax_aura_obj_cache.h"
   6
   7 #include "base/memory/singleton.h"
   8 #include "base/stl_util.h"
   9 #include "ui/aura/window.h"
  10 #include "ui/views/accessibility/ax_aura_obj_wrapper.h"
  11 #include "ui/views/accessibility/ax_view_obj_wrapper.h"
  12 #include "ui/views/accessibility/ax_widget_obj_wrapper.h"
  13 #include "ui/views/accessibility/ax_window_obj_wrapper.h"
  14 #include "ui/views/view.h"
  15 #include "ui/views/widget/widget.h"
  16
  17 namespace views {
  18
  19 // static
  20 AXAuraObjCache* AXAuraObjCache::GetInstance() {
  21   return base::Singleton<AXAuraObjCache>::get();
  22 }
  23
  24 AXAuraObjWrapper* AXAuraObjCache::GetOrCreate(View* view) {
  25   return CreateInternal<AXViewObjWrapper>(view, view_to_id_map_);
  26 }
  27
  28 AXAuraObjWrapper* AXAuraObjCache::GetOrCreate(Widget* widget) {
  29   return CreateInternal<AXWidgetObjWrapper>(widget, widget_to_id_map_);
  30 }
  31
  32 AXAuraObjWrapper* AXAuraObjCache::GetOrCreate(aura::Window* window) {
  33   return CreateInternal<AXWindowObjWrapper>(window, window_to_id_map_);
  34 }
  35
  36 int32 AXAuraObjCache::GetID(View* view) {
  37   return GetIDInternal(view, view_to_id_map_);
  38 }
  39
  40 int32 AXAuraObjCache::GetID(Widget* widget) {
  41   return GetIDInternal(widget, widget_to_id_map_);
  42 }
  43
  44 int32 AXAuraObjCache::GetID(aura::Window* window) {
  45   return GetIDInternal(window, window_to_id_map_);
  46 }
  47
  48 void AXAuraObjCache::Remove(View* view) {
  49   RemoveInternal(view, view_to_id_map_);
  50 }
  51
  52 void AXAuraObjCache::RemoveViewSubtree(View* view) {
  53   Remove(view);
  54   for (int i = 0; i < view->child_count(); ++i)
  55     RemoveViewSubtree(view->child_at(i));
  56 }
  57
  58 void AXAuraObjCache::Remove(Widget* widget) {
  59   RemoveInternal(widget, widget_to_id_map_);
  60
  61   // When an entire widget is deleted, it doesn't always send a notification
  62   // on each of its views, so we need to explore them recursively.
  63   if (widget->GetRootView())
  64     RemoveViewSubtree(widget->GetRootView());
  65 }
  66
  67 void AXAuraObjCache::Remove(aura::Window* window) {
  68   RemoveInternal(window, window_to_id_map_);
  69 }
  70
  71 AXAuraObjWrapper* AXAuraObjCache::Get(int32 id) {
  72   std::map<int32, AXAuraObjWrapper*>::iterator it = cache_.find(id);
  73
  74   if (it == cache_.end())
  75     return NULL;
  76
  77   return it->second;
  78 }
  79
  80 void AXAuraObjCache::Remove(int32 id) {
  81   AXAuraObjWrapper* obj = Get(id);
  82
  83   if (id == -1 || !obj)
  84     return;
  85
  86   cache_.erase(id);
  87   delete obj;
  88 }
  89
  90 void AXAuraObjCache::GetTopLevelWindows(
  91     std::vector<AXAuraObjWrapper*>* children) {
  92   for (std::map<aura::Window*, int32>::iterator it = window_to_id_map_.begin();
  93        it != window_to_id_map_.end(); ++it) {
  94     if (!it->first->parent())
  95       children->push_back(GetOrCreate(it->first));
  96   }
  97 }
  98
  99 AXAuraObjCache::AXAuraObjCache() : current_id_(1), is_destroying_(false) {
 100 }
 101
 102 AXAuraObjCache::~AXAuraObjCache() {
 103   is_destroying_ = true;
 104   STLDeleteContainerPairSecondPointers(cache_.begin(), cache_.end());
 105   cache_.clear();
 106 }
 107
 108 template <typename AuraViewWrapper, typename AuraView>
 109 AXAuraObjWrapper* AXAuraObjCache::CreateInternal(
 110     AuraView* aura_view, std::map<AuraView*, int32>& aura_view_to_id_map) {
 111   if (!aura_view)
 112     return NULL;
 113
 114   typename std::map<AuraView*, int32>::iterator it =
 115       aura_view_to_id_map.find(aura_view);
 116
 117   if (it != aura_view_to_id_map.end())
 118     return Get(it->second);
 119
 120   AXAuraObjWrapper* wrapper = new AuraViewWrapper(aura_view);
 121   aura_view_to_id_map[aura_view] = current_id_;
 122   cache_[current_id_] = wrapper;
 123   current_id_++;
 124   return wrapper;
 125 }
 126
 127 template<typename AuraView> int32 AXAuraObjCache::GetIDInternal(
 128     AuraView* aura_view, std::map<AuraView*, int32>& aura_view_to_id_map) {
 129   if (!aura_view)
 130     return -1;
 131
 132   typename std::map<AuraView*, int32>::iterator it =
 133       aura_view_to_id_map.find(aura_view);
 134
 135   if (it != aura_view_to_id_map.end())
 136     return it->second;
 137
 138   return -1;
 139 }
 140
 141 template<typename AuraView>
 142 void AXAuraObjCache::RemoveInternal(
 143     AuraView* aura_view, std::map<AuraView*, int32>& aura_view_to_id_map) {
 144   int32 id = GetID(aura_view);
 145   if (id == -1)
 146     return;
 147   aura_view_to_id_map.erase(aura_view);
 148   Remove(id);
 149 }
 150
 151 }  // namespace views