content/browser/accessibility/browser_accessibility_manager.cc

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