src/content/browser/frame_host/frame_tree.cc

   1 // Copyright 2013 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_tree.h"
   6
   7 #include <queue>
   8
   9 #include "base/bind.h"
  10 #include "base/callback.h"
  11 #include "content/browser/frame_host/frame_tree_node.h"
  12 #include "content/browser/frame_host/navigator.h"
  13 #include "content/browser/frame_host/render_frame_host_factory.h"
  14 #include "content/browser/frame_host/render_frame_host_impl.h"
  15 #include "content/browser/renderer_host/render_view_host_factory.h"
  16 #include "content/browser/renderer_host/render_view_host_impl.h"
  17
  18 namespace content {
  19
  20 namespace {
  21 // Used with FrameTree::ForEach() to search for the FrameTreeNode
  22 // corresponding to |frame_tree_node_id|.
  23 bool FrameTreeNodeForId(int64 frame_tree_node_id,
  24                         FrameTreeNode** out_node,
  25                         FrameTreeNode* node) {
  26   if (node->frame_tree_node_id() == frame_tree_node_id) {
  27     *out_node = node;
  28     // Terminate iteration once the node has been found.
  29     return false;
  30   }
  31   return true;
  32 }
  33
  34 bool FrameTreeNodeForRoutingId(int routing_id,
  35                                int process_id,
  36                                FrameTreeNode** out_node,
  37                                FrameTreeNode* node) {
  38   // TODO(creis): Look through the swapped out RFHs as well.
  39   if (node->current_frame_host()->GetProcess()->GetID() == process_id &&
  40       node->current_frame_host()->GetRoutingID() == routing_id) {
  41     *out_node = node;
  42     // Terminate iteration once the node has been found.
  43     return false;
  44   }
  45   return true;
  46 }
  47
  48 // Iterate over the FrameTree to reset any node affected by the loss of the
  49 // given RenderViewHost's process.
  50 bool ResetNodesForNewProcess(RenderViewHost* render_view_host,
  51                              FrameTreeNode* node) {
  52   if (render_view_host == node->current_frame_host()->render_view_host())
  53     node->ResetForNewProcess();
  54   return true;
  55 }
  56
  57 }  // namespace
  58
  59 FrameTree::FrameTree(Navigator* navigator,
  60                      RenderFrameHostDelegate* render_frame_delegate,
  61                      RenderViewHostDelegate* render_view_delegate,
  62                      RenderWidgetHostDelegate* render_widget_delegate,
  63                      RenderFrameHostManager::Delegate* manager_delegate)
  64     : render_frame_delegate_(render_frame_delegate),
  65       render_view_delegate_(render_view_delegate),
  66       render_widget_delegate_(render_widget_delegate),
  67       manager_delegate_(manager_delegate),
  68       root_(new FrameTreeNode(this,
  69                               navigator,
  70                               render_frame_delegate,
  71                               render_view_delegate,
  72                               render_widget_delegate,
  73                               manager_delegate,
  74                               std::string())),
  75       focused_frame_tree_node_id_(-1) {
  76 }
  77
  78 FrameTree::~FrameTree() {
  79 }
  80
  81 FrameTreeNode* FrameTree::FindByID(int64 frame_tree_node_id) {
  82   FrameTreeNode* node = NULL;
  83   ForEach(base::Bind(&FrameTreeNodeForId, frame_tree_node_id, &node));
  84   return node;
  85 }
  86
  87 FrameTreeNode* FrameTree::FindByRoutingID(int routing_id, int process_id) {
  88   FrameTreeNode* node = NULL;
  89   ForEach(
  90       base::Bind(&FrameTreeNodeForRoutingId, routing_id, process_id, &node));
  91   return node;
  92 }
  93
  94 void FrameTree::ForEach(
  95     const base::Callback<bool(FrameTreeNode*)>& on_node) const {
  96   std::queue<FrameTreeNode*> queue;
  97   queue.push(root_.get());
  98
  99   while (!queue.empty()) {
 100     FrameTreeNode* node = queue.front();
 101     queue.pop();
 102     if (!on_node.Run(node))
 103       break;
 104
 105     for (size_t i = 0; i < node->child_count(); ++i)
 106       queue.push(node->child_at(i));
 107   }
 108 }
 109
 110 RenderFrameHostImpl* FrameTree::AddFrame(FrameTreeNode* parent,
 111                                          int new_routing_id,
 112                                          const std::string& frame_name) {
 113   scoped_ptr<FrameTreeNode> node(new FrameTreeNode(
 114       this, parent->navigator(), render_frame_delegate_, render_view_delegate_,
 115       render_widget_delegate_, manager_delegate_, frame_name));
 116   FrameTreeNode* node_ptr = node.get();
 117   // AddChild is what creates the RenderFrameHost.
 118   parent->AddChild(node.Pass(), new_routing_id);
 119   return node_ptr->current_frame_host();
 120 }
 121
 122 void FrameTree::RemoveFrame(FrameTreeNode* child) {
 123   FrameTreeNode* parent = child->parent();
 124   if (!parent) {
 125     NOTREACHED() << "Unexpected RemoveFrame call for main frame.";
 126     return;
 127   }
 128
 129   // Notify observers of the frame removal.
 130   RenderFrameHostImpl* render_frame_host = child->current_frame_host();
 131   if (!on_frame_removed_.is_null()) {
 132     on_frame_removed_.Run(
 133         render_frame_host->render_view_host(),
 134         render_frame_host->GetRoutingID());
 135   }
 136
 137   parent->RemoveChild(child);
 138 }
 139
 140 void FrameTree::ResetForMainFrameSwap() {
 141   root_->ResetForNewProcess();
 142   focused_frame_tree_node_id_ = -1;
 143 }
 144
 145 void FrameTree::RenderProcessGone(RenderViewHost* render_view_host) {
 146   // Walk the full tree looking for nodes that may be affected.  Once a frame
 147   // crashes, all of its child FrameTreeNodes go away.
 148   // Note that the helper function may call ResetForNewProcess on a node, which
 149   // clears its children before we iterate over them.  That's ok, because
 150   // ForEach does not add a node's children to the queue until after visiting
 151   // the node itself.
 152   ForEach(base::Bind(&ResetNodesForNewProcess, render_view_host));
 153 }
 154
 155 RenderFrameHostImpl* FrameTree::GetMainFrame() const {
 156   return root_->current_frame_host();
 157 }
 158
 159 FrameTreeNode* FrameTree::GetFocusedFrame() {
 160   return FindByID(focused_frame_tree_node_id_);
 161 }
 162
 163 void FrameTree::SetFocusedFrame(FrameTreeNode* node) {
 164   focused_frame_tree_node_id_ = node->frame_tree_node_id();
 165 }
 166
 167 void FrameTree::SetFrameRemoveListener(
 168     const base::Callback<void(RenderViewHostImpl*, int)>& on_frame_removed) {
 169   on_frame_removed_ = on_frame_removed;
 170 }
 171
 172 RenderViewHostImpl* FrameTree::CreateRenderViewHostForMainFrame(
 173     SiteInstance* site_instance,
 174     int routing_id,
 175     int main_frame_routing_id,
 176     bool swapped_out,
 177     bool hidden) {
 178   DCHECK(main_frame_routing_id != MSG_ROUTING_NONE);
 179   RenderViewHostMap::iterator iter =
 180       render_view_host_map_.find(site_instance->GetId());
 181   if (iter != render_view_host_map_.end()) {
 182     // If a RenderViewHost is pending shutdown for this |site_instance|, put it
 183     // in the map of RenderViewHosts pending shutdown. Otherwise there should
 184     // not be a RenderViewHost for the SiteInstance.
 185     CHECK_EQ(RenderViewHostImpl::STATE_PENDING_SHUTDOWN,
 186              iter->second->rvh_state());
 187     render_view_host_pending_shutdown_map_.insert(
 188         std::pair<int, RenderViewHostImpl*>(site_instance->GetId(),
 189                                             iter->second));
 190     render_view_host_map_.erase(iter);
 191   }
 192   RenderViewHostImpl* rvh = static_cast<RenderViewHostImpl*>(
 193       RenderViewHostFactory::Create(site_instance,
 194                                     render_view_delegate_,
 195                                     render_widget_delegate_,
 196                                     routing_id,
 197                                     main_frame_routing_id,
 198                                     swapped_out,
 199                                     hidden));
 200
 201   render_view_host_map_[site_instance->GetId()] = rvh;
 202   return rvh;
 203 }
 204
 205 RenderViewHostImpl* FrameTree::GetRenderViewHostForSubFrame(
 206     SiteInstance* site_instance) {
 207   RenderViewHostMap::iterator iter =
 208       render_view_host_map_.find(site_instance->GetId());
 209   // TODO(creis): Mirror the frame tree so this check can't fail.
 210   if (iter == render_view_host_map_.end())
 211     return NULL;
 212   return iter->second;
 213 }
 214
 215 void FrameTree::RegisterRenderFrameHost(
 216     RenderFrameHostImpl* render_frame_host) {
 217   SiteInstance* site_instance =
 218       render_frame_host->render_view_host()->GetSiteInstance();
 219   RenderViewHostMap::iterator iter =
 220       render_view_host_map_.find(site_instance->GetId());
 221   CHECK(iter != render_view_host_map_.end());
 222
 223   iter->second->increment_ref_count();
 224 }
 225
 226 void FrameTree::UnregisterRenderFrameHost(
 227     RenderFrameHostImpl* render_frame_host) {
 228   SiteInstance* site_instance =
 229       render_frame_host->render_view_host()->GetSiteInstance();
 230   int32 site_instance_id = site_instance->GetId();
 231   RenderViewHostMap::iterator iter =
 232       render_view_host_map_.find(site_instance_id);
 233   if (iter != render_view_host_map_.end() &&
 234       iter->second == render_frame_host->render_view_host()) {
 235     // Decrement the refcount and shutdown the RenderViewHost if no one else is
 236     // using it.
 237     CHECK_GT(iter->second->ref_count(), 0);
 238     iter->second->decrement_ref_count();
 239     if (iter->second->ref_count() == 0) {
 240       iter->second->Shutdown();
 241       render_view_host_map_.erase(iter);
 242     }
 243   } else {
 244     // The RenderViewHost should be in the list of RenderViewHosts pending
 245     // shutdown.
 246     bool render_view_host_found = false;
 247     std::pair<RenderViewHostMultiMap::iterator,
 248               RenderViewHostMultiMap::iterator> result =
 249         render_view_host_pending_shutdown_map_.equal_range(site_instance_id);
 250     for (RenderViewHostMultiMap::iterator multi_iter = result.first;
 251          multi_iter != result.second;
 252          ++multi_iter) {
 253       if (multi_iter->second != render_frame_host->render_view_host())
 254         continue;
 255       render_view_host_found = true;
 256       RenderViewHostImpl* rvh = multi_iter->second;
 257       // Decrement the refcount and shutdown the RenderViewHost if no one else
 258       // is using it.
 259       CHECK_GT(rvh->ref_count(), 0);
 260       rvh->decrement_ref_count();
 261       if (rvh->ref_count() == 0) {
 262         rvh->Shutdown();
 263         render_view_host_pending_shutdown_map_.erase(multi_iter);
 264       }
 265       break;
 266     }
 267     CHECK(render_view_host_found);
 268   }
 269 }
 270
 271 }  // namespace content