Added the selected text marker range to the dictionary for the selection change notification

content/browser/accessibility/browser_accessibility_manager.cc

 // Copyright (c) 2012 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 "content/browser/accessibility/browser_accessibility_manager.h"
 
 #include <stddef.h>
 
 #include "base/logging.h"
 #include "build/build_config.h"
@@ skipping 105 matching lines @@
   auto iter = ax_tree_id_map->find(ax_tree_id);
   return iter == ax_tree_id_map->end() ? nullptr : iter->second;
 }
 
 BrowserAccessibilityManager::BrowserAccessibilityManager(
     BrowserAccessibilityDelegate* delegate,
     BrowserAccessibilityFactory* factory)
     : delegate_(delegate),
       factory_(factory),
       tree_(new ui::AXSerializableTree()),
+      focus_(NULL),
       user_is_navigating_away_(false),
       osk_state_(OSK_ALLOWED),
       ax_tree_id_(AXTreeIDRegistry::kNoAXTreeID),
       parent_node_id_from_parent_tree_(0) {
   tree_->SetDelegate(this);
 }
 
 BrowserAccessibilityManager::BrowserAccessibilityManager(
     const ui::AXTreeUpdate& initial_tree,
     BrowserAccessibilityDelegate* delegate,
     BrowserAccessibilityFactory* factory)
     : delegate_(delegate),
       factory_(factory),
       tree_(new ui::AXSerializableTree()),
+      focus_(NULL),
       user_is_navigating_away_(false),
       osk_state_(OSK_ALLOWED),
       ax_tree_id_(AXTreeIDRegistry::kNoAXTreeID),
       parent_node_id_from_parent_tree_(0) {
   tree_->SetDelegate(this);
   Initialize(initial_tree);
 }
 
 BrowserAccessibilityManager::~BrowserAccessibilityManager() {
   tree_.reset(NULL);
   g_ax_tree_id_map.Get().erase(ax_tree_id_);
 }
 
 void BrowserAccessibilityManager::Initialize(
     const ui::AXTreeUpdate& initial_tree) {
   if (!tree_->Unserialize(initial_tree)) {
     if (delegate_) {
       LOG(ERROR) << tree_->error();
       delegate_->AccessibilityFatalError();
     } else {
       LOG(FATAL) << tree_->error();
     }
   }
+
+  if (!focus_)
+    SetFocus(tree_->root(), false);
 }
 
 // static
 ui::AXTreeUpdate
 BrowserAccessibilityManager::GetEmptyDocument() {
   ui::AXNodeData empty_document;
   empty_document.id = 0;
   empty_document.role = ui::AX_ROLE_ROOT_WEB_AREA;
   ui::AXTreeUpdate update;
   update.nodes.push_back(empty_document);
@@ skipping 58 matching lines @@
   }
 
   return nullptr;
 }
 
 const ui::AXTreeData& BrowserAccessibilityManager::GetTreeData() {
   return tree_->data();
 }
 
 void BrowserAccessibilityManager::OnWindowFocused() {
-  BrowserAccessibility* focus = GetFocus();
-  if (focus)
-    NotifyAccessibilityEvent(ui::AX_EVENT_FOCUS, focus);
+  if (focus_)
+    NotifyAccessibilityEvent(ui::AX_EVENT_FOCUS, GetFromAXNode(focus_));
 }
 
 void BrowserAccessibilityManager::OnWindowBlurred() {
-  BrowserAccessibility* focus = GetFocus();
-  if (focus)
-    NotifyAccessibilityEvent(ui::AX_EVENT_BLUR, focus);
+  if (focus_)
+    NotifyAccessibilityEvent(ui::AX_EVENT_BLUR, GetFromAXNode(focus_));
 }
 
 void BrowserAccessibilityManager::UserIsNavigatingAway() {
   user_is_navigating_away_ = true;
 }
 
 void BrowserAccessibilityManager::UserIsReloading() {
   user_is_navigating_away_ = true;
 }
 
 void BrowserAccessibilityManager::NavigationSucceeded() {
   user_is_navigating_away_ = false;
 }
 
 void BrowserAccessibilityManager::NavigationFailed() {
   user_is_navigating_away_ = false;
 }
 
 void BrowserAccessibilityManager::GotMouseDown() {
-  BrowserAccessibility* focus = GetFocus();
-  if (!focus)
+  if (!focus_)
     return;
 
   osk_state_ = OSK_ALLOWED_WITHIN_FOCUSED_OBJECT;
-  NotifyAccessibilityEvent(ui::AX_EVENT_FOCUS, focus);
+  NotifyAccessibilityEvent(ui::AX_EVENT_FOCUS, GetFromAXNode(focus_));
 }
 
 bool BrowserAccessibilityManager::UseRootScrollOffsetsWhenComputingBounds() {
   return true;
 }
 
 void BrowserAccessibilityManager::OnAccessibilityEvents(
     const std::vector<AXEventNotificationDetails>& details) {
+  bool should_send_initial_focus = false;
+
   // Process all changes to the accessibility tree first.
   for (uint32_t index = 0; index < details.size(); ++index) {
     const AXEventNotificationDetails& detail = details[index];
     if (!tree_->Unserialize(detail.update)) {
       if (delegate_) {
         LOG(ERROR) << tree_->error();
         delegate_->AccessibilityFatalError();
       } else {
         CHECK(false) << tree_->error();
       }
       return;
     }
+
+    // Set focus to the root if it's not anywhere else.
+    if (!focus_) {
+      SetFocus(tree_->root(), false);
+      should_send_initial_focus = true;
+    }
   }
 
+  if (should_send_initial_focus && NativeViewHasFocus())
+    NotifyAccessibilityEvent(ui::AX_EVENT_FOCUS, GetFromAXNode(focus_));
+
   // Now iterate over the events again and fire the events.
   for (uint32_t index = 0; index < details.size(); index++) {
     const AXEventNotificationDetails& detail = details[index];
 
     // Find the node corresponding to the id that's the target of the
     // event (which may not be the root of the update tree).
     ui::AXNode* node = tree_->GetFromId(detail.id);
     if (!node)
       continue;
 
     ui::AXEvent event_type = detail.event_type;
     if (event_type == ui::AX_EVENT_FOCUS ||
         event_type == ui::AX_EVENT_BLUR) {
+      SetFocus(node, false);
+
       if (osk_state_ != OSK_DISALLOWED_BECAUSE_TAB_HIDDEN &&
           osk_state_ != OSK_DISALLOWED_BECAUSE_TAB_JUST_APPEARED)
         osk_state_ = OSK_ALLOWED;
 
       // Don't send a native focus event if the window itself doesn't
       // have focus.
       if (!NativeViewHasFocus())
         continue;
     }
 
@@ skipping 45 matching lines @@
       node = ancestor;
     ancestor = ancestor->GetParent();
   }
 
   // The "scrolled to anchor" notification is a great way to get a
   // screen reader to jump directly to a specific location in a document.
   NotifyAccessibilityEvent(ui::AX_EVENT_SCROLLED_TO_ANCHOR, node);
 }
 
 BrowserAccessibility* BrowserAccessibilityManager::GetActiveDescendantFocus(
-    BrowserAccessibility* focus) {
-  if (!focus)
+    BrowserAccessibility* root) {
+  BrowserAccessibility* node = BrowserAccessibilityManager::GetFocus(root);
+  if (!node)
     return NULL;
 
   int active_descendant_id;
-  if (focus->GetIntAttribute(ui::AX_ATTR_ACTIVEDESCENDANT_ID,
-                             &active_descendant_id)) {
+  if (node->GetIntAttribute(ui::AX_ATTR_ACTIVEDESCENDANT_ID,
+                            &active_descendant_id)) {
     BrowserAccessibility* active_descendant =
-        focus->manager()->GetFromID(active_descendant_id);
+        node->manager()->GetFromID(active_descendant_id);
     if (active_descendant)
       return active_descendant;
   }
-  return focus;
+  return node;
 }
 
 bool BrowserAccessibilityManager::NativeViewHasFocus() {
   BrowserAccessibilityDelegate* delegate = GetDelegateFromRootManager();
   if (delegate)
     return delegate->AccessibilityViewHasFocus();
   return false;
 }
 
-BrowserAccessibility* BrowserAccessibilityManager::GetFocus() {
-  int32_t focus_id = GetTreeData().focus_id;
-  BrowserAccessibility* obj = GetFromID(focus_id);
-  if (!obj)
-    return GetRoot();
+BrowserAccessibility* BrowserAccessibilityManager::GetFocus(
+    BrowserAccessibility* root) {
+  if (!focus_)
+    return nullptr;
 
+  if (root && !focus_->IsDescendantOf(root->node()))
+    return nullptr;
+
+  BrowserAccessibility* obj = GetFromAXNode(focus_);
+  DCHECK(obj);
   if (obj->HasIntAttribute(ui::AX_ATTR_CHILD_TREE_ID)) {
     BrowserAccessibilityManager* child_manager =
         BrowserAccessibilityManager::FromID(
             obj->GetIntAttribute(ui::AX_ATTR_CHILD_TREE_ID));
     if (child_manager)
-      return child_manager->GetFocus();
+      return child_manager->GetFocus(child_manager->GetRoot());
   }
 
   return obj;
 }
 
-void BrowserAccessibilityManager::SetFocus(const BrowserAccessibility& node) {
-  if (delegate_)
-    delegate_->AccessibilitySetFocus(node.GetId());
+void BrowserAccessibilityManager::SetFocus(ui::AXNode* node, bool notify) {
+  if (focus_ != node)
+    focus_ = node;
+
+  if (notify && node && delegate_)
+    delegate_->AccessibilitySetFocus(node->id());
 }
 
-void BrowserAccessibilityManager::SetFocusLocallyForTesting(
-    BrowserAccessibility* node) {
-  ui::AXTreeData data = GetTreeData();
-  data.focus_id = node->GetId();
-  tree_->UpdateData(data);
+void BrowserAccessibilityManager::SetFocus(BrowserAccessibility* obj,
+                                           bool notify) {
+  if (obj->node())
+    SetFocus(obj->node(), notify);
 }
 
 void BrowserAccessibilityManager::DoDefaultAction(
     const BrowserAccessibility& node) {
   if (delegate_)
     delegate_->AccessibilityDoDefaultAction(node.GetId());
 }
 
 void BrowserAccessibilityManager::ScrollToMakeVisible(
     const BrowserAccessibility& node, gfx::Rect subfocus) {
@@ skipping 215 matching lines @@
 
   return text;
 }
 
 void BrowserAccessibilityManager::OnTreeDataChanged(ui::AXTree* tree) {
 }
 
 void BrowserAccessibilityManager::OnNodeWillBeDeleted(ui::AXTree* tree,
                                                       ui::AXNode* node) {
   DCHECK(node);
+  if (node == focus_ && tree_) {
+    if (node != tree_->root())
+      SetFocus(tree_->root(), false);
+    else
+      focus_ = NULL;
+  }
   if (id_wrapper_map_.find(node->id()) == id_wrapper_map_.end())
     return;
   GetFromAXNode(node)->Destroy();
   id_wrapper_map_.erase(node->id());
 }
 
 void BrowserAccessibilityManager::OnSubtreeWillBeDeleted(ui::AXTree* tree,
                                                          ui::AXNode* node) {
   DCHECK(node);
   BrowserAccessibility* obj = GetFromAXNode(node);
@@ skipping 64 matching lines @@
       tree_->CreateTreeSource());
   ui::AXTreeSerializer<const ui::AXNode*,
                        ui::AXNodeData,
                        ui::AXTreeData> serializer(tree_source.get());
   ui::AXTreeUpdate update;
   serializer.SerializeChanges(tree_->root(), &update);
   return update;
 }
 
 }  // namespace content