Home | History | Annotate | Download | only in accessibility 
      1 // Copyright (c) 2012 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 "content/browser/accessibility/browser_accessibility_manager.h"
      6 
      7 #include "base/logging.h"
      8 #include "content/browser/accessibility/browser_accessibility.h"
      9 #include "content/common/accessibility_messages.h"
     10 #include "ui/accessibility/ax_tree_serializer.h"
     11 
     12 namespace content {
     13 
     14 ui::AXTreeUpdate MakeAXTreeUpdate(
     15     const ui::AXNodeData& node1,
     16     const ui::AXNodeData& node2 /* = ui::AXNodeData() */,
     17     const ui::AXNodeData& node3 /* = ui::AXNodeData() */,
     18     const ui::AXNodeData& node4 /* = ui::AXNodeData() */,
     19     const ui::AXNodeData& node5 /* = ui::AXNodeData() */,
     20     const ui::AXNodeData& node6 /* = ui::AXNodeData() */,
     21     const ui::AXNodeData& node7 /* = ui::AXNodeData() */,
     22     const ui::AXNodeData& node8 /* = ui::AXNodeData() */,
     23     const ui::AXNodeData& node9 /* = ui::AXNodeData() */) {
     24   CR_DEFINE_STATIC_LOCAL(ui::AXNodeData, empty_data, ());
     25   int32 no_id = empty_data.id;
     26 
     27   ui::AXTreeUpdate update;
     28   update.nodes.push_back(node1);
     29   if (node2.id != no_id)
     30     update.nodes.push_back(node2);
     31   if (node3.id != no_id)
     32     update.nodes.push_back(node3);
     33   if (node4.id != no_id)
     34     update.nodes.push_back(node4);
     35   if (node5.id != no_id)
     36     update.nodes.push_back(node5);
     37   if (node6.id != no_id)
     38     update.nodes.push_back(node6);
     39   if (node7.id != no_id)
     40     update.nodes.push_back(node7);
     41   if (node8.id != no_id)
     42     update.nodes.push_back(node8);
     43   if (node9.id != no_id)
     44     update.nodes.push_back(node9);
     45   return update;
     46 }
     47 
     48 BrowserAccessibility* BrowserAccessibilityFactory::Create() {
     49   return BrowserAccessibility::Create();
     50 }
     51 
     52 #if !defined(OS_MACOSX) && \
     53     !defined(OS_WIN) && \
     54     !defined(OS_ANDROID) \
     55 // We have subclassess of BrowserAccessibilityManager on Mac, and Win. For any
     56 // other platform, instantiate the base class.
     57 // static
     58 BrowserAccessibilityManager* BrowserAccessibilityManager::Create(
     59     const ui::AXTreeUpdate& initial_tree,
     60     BrowserAccessibilityDelegate* delegate,
     61     BrowserAccessibilityFactory* factory) {
     62   return new BrowserAccessibilityManager(initial_tree, delegate, factory);
     63 }
     64 #endif
     65 
     66 BrowserAccessibilityManager::BrowserAccessibilityManager(
     67     BrowserAccessibilityDelegate* delegate,
     68     BrowserAccessibilityFactory* factory)
     69     : delegate_(delegate),
     70       factory_(factory),
     71       tree_(new ui::AXSerializableTree()),
     72       focus_(NULL),
     73       osk_state_(OSK_ALLOWED) {
     74   tree_->SetDelegate(this);
     75 }
     76 
     77 BrowserAccessibilityManager::BrowserAccessibilityManager(
     78     const ui::AXTreeUpdate& initial_tree,
     79     BrowserAccessibilityDelegate* delegate,
     80     BrowserAccessibilityFactory* factory)
     81     : delegate_(delegate),
     82       factory_(factory),
     83       tree_(new ui::AXSerializableTree()),
     84       focus_(NULL),
     85       osk_state_(OSK_ALLOWED) {
     86   tree_->SetDelegate(this);
     87   Initialize(initial_tree);
     88 }
     89 
     90 BrowserAccessibilityManager::~BrowserAccessibilityManager() {
     91   tree_.reset(NULL);
     92 }
     93 
     94 void BrowserAccessibilityManager::Initialize(
     95     const ui::AXTreeUpdate& initial_tree) {
     96   if (!tree_->Unserialize(initial_tree)) {
     97     if (delegate_) {
     98       LOG(ERROR) << tree_->error();
     99       delegate_->AccessibilityFatalError();
    100     } else {
    101       LOG(FATAL) << tree_->error();
    102     }
    103   }
    104 
    105   if (!focus_)
    106     SetFocus(tree_->GetRoot(), false);
    107 }
    108 
    109 // static
    110 ui::AXTreeUpdate BrowserAccessibilityManager::GetEmptyDocument() {
    111   ui::AXNodeData empty_document;
    112   empty_document.id = 0;
    113   empty_document.role = ui::AX_ROLE_ROOT_WEB_AREA;
    114   ui::AXTreeUpdate update;
    115   update.nodes.push_back(empty_document);
    116   return update;
    117 }
    118 
    119 BrowserAccessibility* BrowserAccessibilityManager::GetRoot() {
    120   return GetFromAXNode(tree_->GetRoot());
    121 }
    122 
    123 BrowserAccessibility* BrowserAccessibilityManager::GetFromAXNode(
    124     ui::AXNode* node) {
    125   return GetFromID(node->id());
    126 }
    127 
    128 BrowserAccessibility* BrowserAccessibilityManager::GetFromID(int32 id) {
    129   base::hash_map<int32, BrowserAccessibility*>::iterator iter =
    130       id_wrapper_map_.find(id);
    131   if (iter != id_wrapper_map_.end())
    132     return iter->second;
    133   return NULL;
    134 }
    135 
    136 void BrowserAccessibilityManager::OnWindowFocused() {
    137   if (focus_)
    138     NotifyAccessibilityEvent(ui::AX_EVENT_FOCUS, GetFromAXNode(focus_));
    139 }
    140 
    141 void BrowserAccessibilityManager::OnWindowBlurred() {
    142   if (focus_)
    143     NotifyAccessibilityEvent(ui::AX_EVENT_BLUR, GetFromAXNode(focus_));
    144 }
    145 
    146 void BrowserAccessibilityManager::GotMouseDown() {
    147   osk_state_ = OSK_ALLOWED_WITHIN_FOCUSED_OBJECT;
    148   NotifyAccessibilityEvent(ui::AX_EVENT_FOCUS, GetFromAXNode(focus_));
    149 }
    150 
    151 bool BrowserAccessibilityManager::UseRootScrollOffsetsWhenComputingBounds() {
    152   return true;
    153 }
    154 
    155 void BrowserAccessibilityManager::OnAccessibilityEvents(
    156     const std::vector<AccessibilityHostMsg_EventParams>& params) {
    157   bool should_send_initial_focus = false;
    158 
    159   // Process all changes to the accessibility tree first.
    160   for (uint32 index = 0; index < params.size(); index++) {
    161     const AccessibilityHostMsg_EventParams& param = params[index];
    162     if (!tree_->Unserialize(param.update)) {
    163       if (delegate_) {
    164         LOG(ERROR) << tree_->error();
    165         delegate_->AccessibilityFatalError();
    166       } else {
    167         CHECK(false) << tree_->error();
    168       }
    169       return;
    170     }
    171 
    172     // Set focus to the root if it's not anywhere else.
    173     if (!focus_) {
    174       SetFocus(tree_->GetRoot(), false);
    175       should_send_initial_focus = true;
    176     }
    177   }
    178 
    179   OnTreeUpdateFinished();
    180 
    181   if (should_send_initial_focus &&
    182       (!delegate_ || delegate_->AccessibilityViewHasFocus())) {
    183     NotifyAccessibilityEvent(ui::AX_EVENT_FOCUS, GetFromAXNode(focus_));
    184   }
    185 
    186   // Now iterate over the events again and fire the events.
    187   for (uint32 index = 0; index < params.size(); index++) {
    188     const AccessibilityHostMsg_EventParams& param = params[index];
    189 
    190     // Find the node corresponding to the id that's the target of the
    191     // event (which may not be the root of the update tree).
    192     ui::AXNode* node = tree_->GetFromId(param.id);
    193     if (!node)
    194       continue;
    195 
    196     ui::AXEvent event_type = param.event_type;
    197     if (event_type == ui::AX_EVENT_FOCUS ||
    198         event_type == ui::AX_EVENT_BLUR) {
    199       SetFocus(node, false);
    200 
    201       if (osk_state_ != OSK_DISALLOWED_BECAUSE_TAB_HIDDEN &&
    202           osk_state_ != OSK_DISALLOWED_BECAUSE_TAB_JUST_APPEARED)
    203         osk_state_ = OSK_ALLOWED;
    204 
    205       // Don't send a native focus event if the window itself doesn't
    206       // have focus.
    207       if (delegate_ && !delegate_->AccessibilityViewHasFocus())
    208         continue;
    209     }
    210 
    211     // Send the event event to the operating system.
    212     NotifyAccessibilityEvent(event_type, GetFromAXNode(node));
    213   }
    214 }
    215 
    216 void BrowserAccessibilityManager::OnLocationChanges(
    217     const std::vector<AccessibilityHostMsg_LocationChangeParams>& params) {
    218   for (size_t i = 0; i < params.size(); ++i) {
    219     BrowserAccessibility* obj = GetFromID(params[i].id);
    220     if (!obj)
    221       continue;
    222     ui::AXNode* node = obj->node();
    223     node->SetLocation(params[i].new_location);
    224     obj->OnLocationChanged();
    225   }
    226 }
    227 
    228 BrowserAccessibility* BrowserAccessibilityManager::GetActiveDescendantFocus(
    229     BrowserAccessibility* root) {
    230   BrowserAccessibility* node = BrowserAccessibilityManager::GetFocus(root);
    231   if (!node)
    232     return NULL;
    233 
    234   int active_descendant_id;
    235   if (node->GetIntAttribute(ui::AX_ATTR_ACTIVEDESCENDANT_ID,
    236                             &active_descendant_id)) {
    237     BrowserAccessibility* active_descendant =
    238         node->manager()->GetFromID(active_descendant_id);
    239     if (active_descendant)
    240       return active_descendant;
    241   }
    242   return node;
    243 }
    244 
    245 BrowserAccessibility* BrowserAccessibilityManager::GetFocus(
    246     BrowserAccessibility* root) {
    247   if (focus_ && (!root || focus_->IsDescendantOf(root->node())))
    248     return GetFromAXNode(focus_);
    249 
    250   return NULL;
    251 }
    252 
    253 void BrowserAccessibilityManager::SetFocus(ui::AXNode* node, bool notify) {
    254   if (focus_ != node)
    255     focus_ = node;
    256 
    257   if (notify && node && delegate_)
    258     delegate_->AccessibilitySetFocus(node->id());
    259 }
    260 
    261 void BrowserAccessibilityManager::SetFocus(
    262     BrowserAccessibility* obj, bool notify) {
    263   if (obj->node())
    264     SetFocus(obj->node(), notify);
    265 }
    266 
    267 void BrowserAccessibilityManager::DoDefaultAction(
    268     const BrowserAccessibility& node) {
    269   if (delegate_)
    270     delegate_->AccessibilityDoDefaultAction(node.GetId());
    271 }
    272 
    273 void BrowserAccessibilityManager::ScrollToMakeVisible(
    274     const BrowserAccessibility& node, gfx::Rect subfocus) {
    275   if (delegate_) {
    276     delegate_->AccessibilityScrollToMakeVisible(node.GetId(), subfocus);
    277   }
    278 }
    279 
    280 void BrowserAccessibilityManager::ScrollToPoint(
    281     const BrowserAccessibility& node, gfx::Point point) {
    282   if (delegate_) {
    283     delegate_->AccessibilityScrollToPoint(node.GetId(), point);
    284   }
    285 }
    286 
    287 void BrowserAccessibilityManager::SetTextSelection(
    288     const BrowserAccessibility& node, int start_offset, int end_offset) {
    289   if (delegate_) {
    290     delegate_->AccessibilitySetTextSelection(
    291         node.GetId(), start_offset, end_offset);
    292   }
    293 }
    294 
    295 gfx::Rect BrowserAccessibilityManager::GetViewBounds() {
    296   if (delegate_)
    297     return delegate_->AccessibilityGetViewBounds();
    298   return gfx::Rect();
    299 }
    300 
    301 BrowserAccessibility* BrowserAccessibilityManager::NextInTreeOrder(
    302     BrowserAccessibility* node) {
    303   if (!node)
    304     return NULL;
    305 
    306   if (node->PlatformChildCount() > 0)
    307     return node->PlatformGetChild(0);
    308   while (node) {
    309     if (node->GetParent() &&
    310         node->GetIndexInParent() <
    311             static_cast<int>(node->GetParent()->PlatformChildCount()) - 1) {
    312       return node->GetParent()->PlatformGetChild(node->GetIndexInParent() + 1);
    313     }
    314     node = node->GetParent();
    315   }
    316 
    317   return NULL;
    318 }
    319 
    320 BrowserAccessibility* BrowserAccessibilityManager::PreviousInTreeOrder(
    321     BrowserAccessibility* node) {
    322   if (!node)
    323     return NULL;
    324 
    325   if (node->GetParent() && node->GetIndexInParent() > 0) {
    326     node = node->GetParent()->PlatformGetChild(node->GetIndexInParent() - 1);
    327     while (node->PlatformChildCount() > 0)
    328       node = node->PlatformGetChild(node->PlatformChildCount() - 1);
    329     return node;
    330   }
    331 
    332   return node->GetParent();
    333 }
    334 
    335 void BrowserAccessibilityManager::OnNodeWillBeDeleted(ui::AXNode* node) {
    336   if (node == focus_ && tree_) {
    337     if (node != tree_->GetRoot())
    338       SetFocus(tree_->GetRoot(), false);
    339     else
    340       focus_ = NULL;
    341   }
    342   if (id_wrapper_map_.find(node->id()) == id_wrapper_map_.end())
    343     return;
    344   GetFromAXNode(node)->Destroy();
    345   id_wrapper_map_.erase(node->id());
    346 }
    347 
    348 void BrowserAccessibilityManager::OnNodeCreated(ui::AXNode* node) {
    349   BrowserAccessibility* wrapper = factory_->Create();
    350   wrapper->Init(this, node);
    351   id_wrapper_map_[node->id()] = wrapper;
    352   wrapper->OnDataChanged();
    353 }
    354 
    355 void BrowserAccessibilityManager::OnNodeChanged(ui::AXNode* node) {
    356   GetFromAXNode(node)->OnDataChanged();
    357 }
    358 
    359 void BrowserAccessibilityManager::OnNodeCreationFinished(ui::AXNode* node) {
    360   GetFromAXNode(node)->OnUpdateFinished();
    361 }
    362 
    363 void BrowserAccessibilityManager::OnNodeChangeFinished(ui::AXNode* node) {
    364   GetFromAXNode(node)->OnUpdateFinished();
    365 }
    366 
    367 ui::AXTreeUpdate BrowserAccessibilityManager::SnapshotAXTreeForTesting() {
    368   scoped_ptr<ui::AXTreeSource<const ui::AXNode*> > tree_source(
    369       tree_->CreateTreeSource());
    370   ui::AXTreeSerializer<const ui::AXNode*> serializer(tree_source.get());
    371   ui::AXTreeUpdate update;
    372   serializer.SerializeChanges(tree_->GetRoot(), &update);
    373   return update;
    374 }
    375 
    376 }  // namespace content
    377