BASELINE: Update Chromium to 47.0.2526.14

Also adding in sources needed for spellchecking.

Change-Id: Idd44170fa1616f26315188970a8d5ba7d472b18a
Reviewed-by: Michael Brüning <michael.bruning@theqtcompany.com>

1 files changed, 164 insertions, 58 deletions

diff --git a/chromium/content/browser/accessibility/browser_accessibility_manager.cc b/chromium/content/browser/accessibility/browser_accessibility_manager.cc
index 15c1a35ceda..76ab1e74925 100644
--- a/chromium/content/browser/accessibility/browser_accessibility_manager.cc
+++ b/chromium/content/browser/accessibility/browser_accessibility_manager.cc
@@ -11,7 +11,36 @@
 
 namespace content {
 
-ui::AXTreeUpdate MakeAXTreeUpdate(
+namespace {
+
+// Search the tree recursively from |node| and return any node that has
+// a child tree ID of |ax_tree_id|.
+BrowserAccessibility* FindNodeWithChildTreeId(BrowserAccessibility* node,
+                                              int ax_tree_id) {
+  if (!node)
+    return nullptr;
+
+  if (node->GetIntAttribute(ui::AX_ATTR_CHILD_TREE_ID) == ax_tree_id)
+    return node;
+
+  for (unsigned int i = 0; i < node->InternalChildCount(); ++i) {
+    BrowserAccessibility* child = node->InternalGetChild(i);
+    BrowserAccessibility* result = FindNodeWithChildTreeId(child, ax_tree_id);
+    if (result)
+      return result;
+  }
+
+  return nullptr;
+}
+
+}  // namespace
+
+// Map from AXTreeID to BrowserAccessibilityManager
+using AXTreeIDMap =
+    base::hash_map<AXTreeIDRegistry::AXTreeID, BrowserAccessibilityManager*>;
+base::LazyInstance<AXTreeIDMap> g_ax_tree_id_map = LAZY_INSTANCE_INITIALIZER;
+
+SimpleAXTreeUpdate MakeAXTreeUpdate(
     const ui::AXNodeData& node1,
     const ui::AXNodeData& node2 /* = ui::AXNodeData() */,
     const ui::AXNodeData& node3 /* = ui::AXNodeData() */,
@@ -24,7 +53,7 @@ ui::AXTreeUpdate MakeAXTreeUpdate(
   CR_DEFINE_STATIC_LOCAL(ui::AXNodeData, empty_data, ());
   int32 no_id = empty_data.id;
 
-  ui::AXTreeUpdate update;
+  SimpleAXTreeUpdate update;
   update.nodes.push_back(node1);
   if (node2.id != no_id)
     update.nodes.push_back(node2);
@@ -58,20 +87,29 @@ BrowserAccessibilityFindInPageInfo::BrowserAccessibilityFindInPageInfo()
       end_offset(-1),
       active_request_id(-1) {}
 
-#if !defined(OS_MACOSX) && \
-    !defined(OS_WIN) && \
-    !defined(OS_ANDROID) \
-// We have subclassess of BrowserAccessibilityManager on Mac, and Win. For any
-// other platform, instantiate the base class.
+#if !defined(OS_WIN) && \
+    !defined(OS_MACOSX) && \
+    !defined(OS_ANDROID) && \
+    !(defined(OS_LINUX) && !defined(OS_CHROMEOS) && defined(USE_X11))
+// We have subclassess of BrowserAccessibility on some platforms.
+// For other platforms, instantiate the base class.
 // static
 BrowserAccessibilityManager* BrowserAccessibilityManager::Create(
-    const ui::AXTreeUpdate& initial_tree,
+    const SimpleAXTreeUpdate& initial_tree,
     BrowserAccessibilityDelegate* delegate,
     BrowserAccessibilityFactory* factory) {
   return new BrowserAccessibilityManager(initial_tree, delegate, factory);
 }
 #endif
 
+// static
+BrowserAccessibilityManager* BrowserAccessibilityManager::FromID(
+    AXTreeIDRegistry::AXTreeID ax_tree_id) {
+  AXTreeIDMap* ax_tree_id_map = g_ax_tree_id_map.Pointer();
+  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)
@@ -80,12 +118,14 @@ BrowserAccessibilityManager::BrowserAccessibilityManager(
       tree_(new ui::AXSerializableTree()),
       focus_(NULL),
       user_is_navigating_away_(false),
-      osk_state_(OSK_ALLOWED) {
+      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,
+    const SimpleAXTreeUpdate& initial_tree,
     BrowserAccessibilityDelegate* delegate,
     BrowserAccessibilityFactory* factory)
     : delegate_(delegate),
@@ -93,7 +133,9 @@ BrowserAccessibilityManager::BrowserAccessibilityManager(
       tree_(new ui::AXSerializableTree()),
       focus_(NULL),
       user_is_navigating_away_(false),
-      osk_state_(OSK_ALLOWED) {
+      osk_state_(OSK_ALLOWED),
+      ax_tree_id_(AXTreeIDRegistry::kNoAXTreeID),
+      parent_node_id_from_parent_tree_(0) {
   tree_->SetDelegate(this);
   Initialize(initial_tree);
 }
@@ -103,7 +145,7 @@ BrowserAccessibilityManager::~BrowserAccessibilityManager() {
 }
 
 void BrowserAccessibilityManager::Initialize(
-    const ui::AXTreeUpdate& initial_tree) {
+    const SimpleAXTreeUpdate& initial_tree) {
   if (!tree_->Unserialize(initial_tree)) {
     if (delegate_) {
       LOG(ERROR) << tree_->error();
@@ -118,17 +160,20 @@ void BrowserAccessibilityManager::Initialize(
 }
 
 // static
-ui::AXTreeUpdate BrowserAccessibilityManager::GetEmptyDocument() {
+SimpleAXTreeUpdate
+BrowserAccessibilityManager::GetEmptyDocument() {
   ui::AXNodeData empty_document;
   empty_document.id = 0;
   empty_document.role = ui::AX_ROLE_ROOT_WEB_AREA;
-  ui::AXTreeUpdate update;
+  SimpleAXTreeUpdate update;
   update.nodes.push_back(empty_document);
   return update;
 }
 
 BrowserAccessibility* BrowserAccessibilityManager::GetRoot() {
-  return GetFromAXNode(tree_->root());
+  // tree_->root() can be null during AXTreeDelegate callbacks.
+  ui::AXNode* root = tree_->root();
+  return root ? GetFromAXNode(root) : nullptr;
 }
 
 BrowserAccessibility* BrowserAccessibilityManager::GetFromAXNode(
@@ -144,6 +189,41 @@ BrowserAccessibility* BrowserAccessibilityManager::GetFromID(int32 id) {
   return NULL;
 }
 
+BrowserAccessibility*
+BrowserAccessibilityManager::GetParentNodeFromParentTree() {
+  if (!GetRoot())
+    return nullptr;
+
+  int parent_tree_id = GetRoot()->GetIntAttribute(ui::AX_ATTR_PARENT_TREE_ID);
+  BrowserAccessibilityManager* parent_manager =
+      BrowserAccessibilityManager::FromID(parent_tree_id);
+  if (!parent_manager)
+    return nullptr;
+
+  // Try to use the cached parent node from the most recent time this
+  // was called.
+  if (parent_node_id_from_parent_tree_) {
+    BrowserAccessibility* parent_node = parent_manager->GetFromID(
+        parent_node_id_from_parent_tree_);
+    if (parent_node) {
+      int parent_child_tree_id =
+          parent_node->GetIntAttribute(ui::AX_ATTR_CHILD_TREE_ID);
+      if (parent_child_tree_id == ax_tree_id_)
+        return parent_node;
+    }
+  }
+
+  // If that fails, search for it and cache it for next time.
+  BrowserAccessibility* parent_node = FindNodeWithChildTreeId(
+      parent_manager->GetRoot(), ax_tree_id_);
+  if (parent_node) {
+    parent_node_id_from_parent_tree_ = parent_node->GetId();
+    return parent_node;
+  }
+
+  return nullptr;
+}
+
 void BrowserAccessibilityManager::OnWindowFocused() {
   if (focus_)
     NotifyAccessibilityEvent(ui::AX_EVENT_FOCUS, GetFromAXNode(focus_));
@@ -180,13 +260,13 @@ bool BrowserAccessibilityManager::UseRootScrollOffsetsWhenComputingBounds() {
 }
 
 void BrowserAccessibilityManager::OnAccessibilityEvents(
-    const std::vector<AccessibilityHostMsg_EventParams>& params) {
+    const std::vector<AXEventNotificationDetails>& details) {
   bool should_send_initial_focus = false;
 
   // Process all changes to the accessibility tree first.
-  for (uint32 index = 0; index < params.size(); index++) {
-    const AccessibilityHostMsg_EventParams& param = params[index];
-    if (!tree_->Unserialize(param.update)) {
+  for (uint32 index = 0; index < details.size(); ++index) {
+    const AXEventNotificationDetails& detail = details[index];
+    if (!tree_->Unserialize(detail.update)) {
       if (delegate_) {
         LOG(ERROR) << tree_->error();
         delegate_->AccessibilityFatalError();
@@ -209,16 +289,16 @@ void BrowserAccessibilityManager::OnAccessibilityEvents(
   }
 
   // Now iterate over the events again and fire the events.
-  for (uint32 index = 0; index < params.size(); index++) {
-    const AccessibilityHostMsg_EventParams& param = params[index];
+  for (uint32 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(param.id);
+    ui::AXNode* node = tree_->GetFromId(detail.id);
     if (!node)
       continue;
 
-    ui::AXEvent event_type = param.event_type;
+    ui::AXEvent event_type = detail.event_type;
     if (event_type == ui::AX_EVENT_FOCUS ||
         event_type == ui::AX_EVENT_BLUR) {
       SetFocus(node, false);
@@ -313,9 +393,10 @@ BrowserAccessibility* BrowserAccessibilityManager::GetFocus(
     return NULL;
 
   BrowserAccessibility* obj = GetFromAXNode(focus_);
-  if (delegate() && obj->HasBoolAttribute(ui::AX_ATTR_IS_AX_TREE_HOST)) {
+  if (obj->HasIntAttribute(ui::AX_ATTR_CHILD_TREE_ID)) {
     BrowserAccessibilityManager* child_manager =
-        delegate()->AccessibilityGetChildFrame(obj->GetId());
+        BrowserAccessibilityManager::FromID(
+            obj->GetIntAttribute(ui::AX_ATTR_CHILD_TREE_ID));
     if (child_manager)
       return child_manager->GetFocus(child_manager->GetRoot());
   }
@@ -389,37 +470,55 @@ gfx::Rect BrowserAccessibilityManager::GetViewBounds() {
 }
 
 BrowserAccessibility* BrowserAccessibilityManager::NextInTreeOrder(
-    BrowserAccessibility* node) {
+    BrowserAccessibility* node) const {
   if (!node)
-    return NULL;
+    return nullptr;
 
-  if (node->PlatformChildCount() > 0)
+  if (node->PlatformChildCount())
     return node->PlatformGetChild(0);
+
   while (node) {
-    if (node->GetParent() &&
-        node->GetIndexInParent() <
-            static_cast<int>(node->GetParent()->PlatformChildCount()) - 1) {
-      return node->GetParent()->PlatformGetChild(node->GetIndexInParent() + 1);
-    }
+    auto sibling = node->GetNextSibling();
+    if (sibling)
+      return sibling;
+
     node = node->GetParent();
   }
 
-  return NULL;
+  return nullptr;
 }
 
 BrowserAccessibility* BrowserAccessibilityManager::PreviousInTreeOrder(
-    BrowserAccessibility* node) {
+    BrowserAccessibility* node) const {
   if (!node)
-    return NULL;
+    return nullptr;
 
-  if (node->GetParent() && node->GetIndexInParent() > 0) {
-    node = node->GetParent()->PlatformGetChild(node->GetIndexInParent() - 1);
-    while (node->PlatformChildCount() > 0)
-      node = node->PlatformGetChild(node->PlatformChildCount() - 1);
-    return node;
-  }
+  auto sibling = node->GetPreviousSibling();
+  if (!sibling)
+    return node->GetParent();
+
+  if (sibling->PlatformChildCount())
+    return sibling->PlatformDeepestLastChild();
 
-  return node->GetParent();
+  return sibling;
+}
+
+BrowserAccessibility* BrowserAccessibilityManager::PreviousTextOnlyObject(
+    BrowserAccessibility* node) const {
+      BrowserAccessibility* previous_node = PreviousInTreeOrder(node);
+  while (previous_node && !previous_node->IsTextOnlyObject())
+    previous_node = PreviousInTreeOrder(previous_node);
+
+  return previous_node;
+}
+
+BrowserAccessibility* BrowserAccessibilityManager::NextTextOnlyObject(
+    BrowserAccessibility* node) const {
+  BrowserAccessibility* next_node = NextInTreeOrder(node);
+  while (next_node && !next_node->IsTextOnlyObject())
+    next_node = NextInTreeOrder(next_node);
+
+  return next_node;
 }
 
 void BrowserAccessibilityManager::OnNodeWillBeDeleted(ui::AXTree* tree,
@@ -460,26 +559,33 @@ void BrowserAccessibilityManager::OnAtomicUpdateFinished(
     ui::AXTree* tree,
     bool root_changed,
     const std::vector<ui::AXTreeDelegate::Change>& changes) {
+  if (GetRoot()->HasIntAttribute(ui::AX_ATTR_TREE_ID) &&
+      GetRoot()->GetIntAttribute(ui::AX_ATTR_TREE_ID) != ax_tree_id_) {
+    g_ax_tree_id_map.Get().erase(ax_tree_id_);
+    ax_tree_id_ = GetRoot()->GetIntAttribute(ui::AX_ATTR_TREE_ID);
+    g_ax_tree_id_map.Get().insert(std::make_pair(ax_tree_id_, this));
+  }
 }
 
 BrowserAccessibilityDelegate*
     BrowserAccessibilityManager::GetDelegateFromRootManager() {
-  BrowserAccessibilityManager* manager = this;
-  while (manager->delegate()) {
-    BrowserAccessibility* host_node_in_parent_frame =
-        manager->delegate()->AccessibilityGetParentFrame();
-    if (!host_node_in_parent_frame)
-      break;
-    manager = host_node_in_parent_frame->manager();
-  }
-  return manager->delegate();
-}
-
-ui::AXTreeUpdate BrowserAccessibilityManager::SnapshotAXTreeForTesting() {
-  scoped_ptr<ui::AXTreeSource<const ui::AXNode*> > tree_source(
+  if (!GetRoot())
+    return nullptr;
+  int parent_tree_id = GetRoot()->GetIntAttribute(ui::AX_ATTR_PARENT_TREE_ID);
+  BrowserAccessibilityManager* parent_manager =
+      BrowserAccessibilityManager::FromID(parent_tree_id);
+  if (parent_manager)
+    return parent_manager->GetDelegateFromRootManager();
+  return delegate();
+}
+
+SimpleAXTreeUpdate
+BrowserAccessibilityManager::SnapshotAXTreeForTesting() {
+  scoped_ptr<ui::AXTreeSource<const ui::AXNode*, ui::AXNodeData> > tree_source(
       tree_->CreateTreeSource());
-  ui::AXTreeSerializer<const ui::AXNode*> serializer(tree_source.get());
-  ui::AXTreeUpdate update;
+  ui::AXTreeSerializer<const ui::AXNode*, ui::AXNodeData> serializer(
+      tree_source.get());
+  SimpleAXTreeUpdate update;
   serializer.SerializeChanges(tree_->root(), &update);
   return update;
 }