content/browser/frame_host/frame_accessibility.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 "content/browser/frame_host/frame_accessibility.h"
   6
   7 #include "content/browser/frame_host/frame_tree.h"
   8 #include "content/browser/frame_host/frame_tree_node.h"
   9 #include "content/browser/frame_host/render_frame_host_delegate.h"
  10 #include "content/browser/frame_host/render_frame_host_impl.h"
  11 #include "content/public/browser/browser_context.h"
  12
  13 namespace content {
  14
  15 // static
  16 FrameAccessibility* FrameAccessibility::GetInstance() {
  17   return Singleton<FrameAccessibility>::get();
  18 }
  19
  20 FrameAccessibility::ChildFrameMapping::ChildFrameMapping()
  21     : parent_frame_host(nullptr),
  22       accessibility_node_id(0),
  23       child_frame_tree_node_id(0),
  24       browser_plugin_instance_id(0) {}
  25
  26 FrameAccessibility::FrameAccessibility() {}
  27
  28 FrameAccessibility::~FrameAccessibility() {}
  29
  30 void FrameAccessibility::AddChildFrame(
  31     RenderFrameHostImpl* parent_frame_host,
  32     int accessibility_node_id,
  33     int64 child_frame_tree_node_id) {
  34   for (std::vector<ChildFrameMapping>::iterator iter = mappings_.begin();
  35        iter != mappings_.end();
  36        ++iter) {
  37     // TODO(dmazzoni): the renderer should keep track of these mappings
  38     // and clear an existing mapping before setting a new one, that would
  39     // be safer than just updating existing mappings. http://crbug.com/413464
  40     if (iter->parent_frame_host == parent_frame_host &&
  41         (iter->accessibility_node_id == accessibility_node_id ||
  42          iter->child_frame_tree_node_id == child_frame_tree_node_id)) {
  43       iter->accessibility_node_id = accessibility_node_id;
  44       iter->child_frame_tree_node_id = child_frame_tree_node_id;
  45       return;
  46     }
  47   }
  48
  49   ChildFrameMapping new_mapping;
  50   new_mapping.parent_frame_host = parent_frame_host;
  51   new_mapping.accessibility_node_id = accessibility_node_id;
  52   new_mapping.child_frame_tree_node_id = child_frame_tree_node_id;
  53   mappings_.push_back(new_mapping);
  54 }
  55
  56 void FrameAccessibility::AddGuestWebContents(
  57     RenderFrameHostImpl* parent_frame_host,
  58     int accessibility_node_id,
  59     int browser_plugin_instance_id) {
  60   for (std::vector<ChildFrameMapping>::iterator iter = mappings_.begin();
  61        iter != mappings_.end();
  62        ++iter) {
  63     // TODO(dmazzoni): the renderer should keep track of these mappings
  64     // and clear an existing mapping before setting a new one, that would
  65     // be safer than just updating existing mappings. http://crbug.com/413464
  66     if (iter->parent_frame_host == parent_frame_host &&
  67         (iter->accessibility_node_id == accessibility_node_id ||
  68          iter->browser_plugin_instance_id == browser_plugin_instance_id)) {
  69       iter->accessibility_node_id = accessibility_node_id;
  70       iter->browser_plugin_instance_id = browser_plugin_instance_id;
  71       return;
  72     }
  73   }
  74
  75   ChildFrameMapping new_mapping;
  76   new_mapping.parent_frame_host = parent_frame_host;
  77   new_mapping.accessibility_node_id = accessibility_node_id;
  78   new_mapping.browser_plugin_instance_id = browser_plugin_instance_id;
  79   mappings_.push_back(new_mapping);
  80 }
  81
  82 void FrameAccessibility::OnRenderFrameHostDestroyed(
  83     RenderFrameHostImpl* render_frame_host) {
  84   // Since the order doesn't matter, the fastest way to remove all items
  85   // with this render_frame_host is to iterate over the vector backwards,
  86   // swapping each one with the back element if we need to delete it.
  87   int initial_len = static_cast<int>(mappings_.size());
  88   for (int i = initial_len - 1; i >= 0; i--) {
  89     if (mappings_[i].parent_frame_host == render_frame_host) {
  90       mappings_[i] = mappings_.back();
  91       mappings_.pop_back();
  92     }
  93   }
  94 }
  95
  96 RenderFrameHostImpl* FrameAccessibility::GetChild(
  97     RenderFrameHostImpl* parent_frame_host,
  98     int accessibility_node_id) {
  99   for (std::vector<ChildFrameMapping>::iterator iter = mappings_.begin();
 100        iter != mappings_.end();
 101        ++iter) {
 102     if (iter->parent_frame_host != parent_frame_host ||
 103         iter->accessibility_node_id != accessibility_node_id) {
 104       continue;
 105     }
 106
 107     if (iter->child_frame_tree_node_id) {
 108       return GetRFHIFromFrameTreeNodeId(
 109           parent_frame_host, iter->child_frame_tree_node_id);
 110     }
 111
 112     if (iter->browser_plugin_instance_id) {
 113       RenderFrameHost* guest =
 114           parent_frame_host->delegate()->GetGuestByInstanceID(
 115               iter->browser_plugin_instance_id);
 116       if (guest)
 117         return static_cast<RenderFrameHostImpl*>(guest);
 118     }
 119   }
 120
 121   return nullptr;
 122 }
 123
 124 void FrameAccessibility::GetAllChildFrames(
 125     RenderFrameHostImpl* parent_frame_host,
 126     std::vector<RenderFrameHostImpl*>* child_frame_hosts) {
 127   CHECK(child_frame_hosts);
 128
 129   for (std::vector<ChildFrameMapping>::iterator iter = mappings_.begin();
 130        iter != mappings_.end();
 131        ++iter) {
 132     if (iter->parent_frame_host != parent_frame_host)
 133       continue;
 134
 135     if (iter->child_frame_tree_node_id) {
 136       RenderFrameHostImpl* child_frame_host = GetRFHIFromFrameTreeNodeId(
 137           parent_frame_host, iter->child_frame_tree_node_id);
 138       if (child_frame_host)
 139         child_frame_hosts->push_back(child_frame_host);
 140     }
 141
 142     if (iter->browser_plugin_instance_id) {
 143       RenderFrameHost* guest =
 144           parent_frame_host->delegate()->GetGuestByInstanceID(
 145               iter->browser_plugin_instance_id);
 146       if (guest)
 147         child_frame_hosts->push_back(static_cast<RenderFrameHostImpl*>(guest));
 148     }
 149   }
 150 }
 151
 152 bool FrameAccessibility::GetParent(
 153     RenderFrameHostImpl* child_frame_host,
 154     RenderFrameHostImpl** out_parent_frame_host,
 155     int* out_accessibility_node_id) {
 156   for (std::vector<ChildFrameMapping>::iterator iter = mappings_.begin();
 157        iter != mappings_.end();
 158        ++iter) {
 159     if (iter->child_frame_tree_node_id) {
 160       FrameTreeNode* child_node =
 161           FrameTree::GloballyFindByID(iter->child_frame_tree_node_id);
 162       if (child_node &&
 163           child_node->current_frame_host() == child_frame_host) {
 164         // Assert that the child node is a descendant of the parent frame in
 165         // the frame tree. It may not be a direct descendant because the
 166         // parent frame's accessibility tree may span multiple frames from the
 167         // same origin.
 168         FrameTreeNode* parent_node = iter->parent_frame_host->frame_tree_node();
 169         FrameTreeNode* child_node_ancestor = child_node->parent();
 170         while (child_node_ancestor && child_node_ancestor != parent_node)
 171           child_node_ancestor = child_node_ancestor->parent();
 172         if (child_node_ancestor != parent_node) {
 173           NOTREACHED();
 174           return false;
 175         }
 176
 177         if (out_parent_frame_host)
 178           *out_parent_frame_host = iter->parent_frame_host;
 179         if (out_accessibility_node_id)
 180           *out_accessibility_node_id = iter->accessibility_node_id;
 181         return true;
 182       }
 183     }
 184
 185     if (iter->browser_plugin_instance_id) {
 186       RenderFrameHost* guest =
 187           iter->parent_frame_host->delegate()->GetGuestByInstanceID(
 188               iter->browser_plugin_instance_id);
 189       if (guest == child_frame_host) {
 190         if (out_parent_frame_host)
 191           *out_parent_frame_host = iter->parent_frame_host;
 192         if (out_accessibility_node_id)
 193           *out_accessibility_node_id = iter->accessibility_node_id;
 194         return true;
 195       }
 196     }
 197   }
 198
 199   return false;
 200 }
 201
 202 RenderFrameHostImpl* FrameAccessibility::GetRFHIFromFrameTreeNodeId(
 203     RenderFrameHostImpl* parent_frame_host,
 204     int64 child_frame_tree_node_id) {
 205   FrameTreeNode* child_node =
 206       FrameTree::GloballyFindByID(child_frame_tree_node_id);
 207   if (!child_node)
 208     return nullptr;
 209
 210   // Assert that the child node is a descendant of the parent frame in
 211   // the frame tree. It may not be a direct descendant because the
 212   // parent frame's accessibility tree may span multiple frames from the
 213   // same origin.
 214   FrameTreeNode* parent_node = parent_frame_host->frame_tree_node();
 215   FrameTreeNode* child_node_ancestor = child_node->parent();
 216   while (child_node_ancestor && child_node_ancestor != parent_node)
 217     child_node_ancestor = child_node_ancestor->parent();
 218   if (child_node_ancestor != parent_node) {
 219     NOTREACHED();
 220     return nullptr;
 221   }
 222
 223   return child_node->current_frame_host();
 224 }
 225
 226 }  // namespace content