Pick frame to navigate in the browser process.

content/browser/frame_host/frame_tree.cc

 // Copyright 2013 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/frame_host/frame_tree.h"
 
 #include <queue>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/containers/hash_tables.h"
 #include "base/lazy_instance.h"
 #include "content/browser/frame_host/frame_tree_node.h"
 #include "content/browser/frame_host/navigator.h"
 #include "content/browser/frame_host/render_frame_host_factory.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/browser/frame_host/render_frame_proxy_host.h"
 #include "content/browser/renderer_host/render_view_host_factory.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 
 namespace content {
 
 namespace {
 
 // Used with FrameTree::ForEach() to search for the FrameTreeNode
-// corresponding to |frame_tree_node_id| whithin a specific FrameTree.
+// corresponding to |frame_tree_node_id| within a specific FrameTree.
 bool FrameTreeNodeForId(int64 frame_tree_node_id,
                         FrameTreeNode** out_node,
                         FrameTreeNode* node) {
   if (node->frame_tree_node_id() == frame_tree_node_id) {
     *out_node = node;
     // Terminate iteration once the node has been found.
     return false;
   }
   return true;
 }
 
+// Used with FrameTree::ForEach() to search for the FrameTreeNode with the given
+// |name| within a specific FrameTree.
+bool FrameTreeNodeForName(const std::string& name,
+                          FrameTreeNode** out_node,
+                          FrameTreeNode* node) {
+  if (node->frame_name() == name) {
+    *out_node = node;
+    // Terminate iteration once the node has been found.
+    return false;
+  }
+  return true;
+}
+
 bool CreateProxyForSiteInstance(const scoped_refptr<SiteInstance>& instance,
                                 FrameTreeNode* node) {
   // If a new frame is created in the current SiteInstance, other frames in
   // that SiteInstance don't need a proxy for the new frame.
   SiteInstance* current_instance =
       node->render_manager()->current_frame_host()->GetSiteInstance();
   if (current_instance != instance.get())
     node->render_manager()->CreateRenderFrameProxy(instance.get());
   return true;
 }
@@ skipping 49 matching lines @@
                               manager_delegate,
                               std::string())),
       focused_frame_tree_node_id_(-1),
       load_progress_(0.0) {
 }
 
 FrameTree::~FrameTree() {
 }
 
 FrameTreeNode* FrameTree::FindByID(int64 frame_tree_node_id) {
-  FrameTreeNode* node = NULL;
+  FrameTreeNode* node = nullptr;
   ForEach(base::Bind(&FrameTreeNodeForId, frame_tree_node_id, &node));
   return node;
 }
 
 FrameTreeNode* FrameTree::FindByRoutingID(int process_id, int routing_id) {
   RenderFrameHostImpl* render_frame_host =
       RenderFrameHostImpl::FromID(process_id, routing_id);
   if (render_frame_host) {
     FrameTreeNode* result = render_frame_host->frame_tree_node();
     if (this == result->frame_tree())
       return result;
   }
 
   RenderFrameProxyHost* render_frame_proxy_host =
       RenderFrameProxyHost::FromID(process_id, routing_id);
   if (render_frame_proxy_host) {
     FrameTreeNode* result = render_frame_proxy_host->frame_tree_node();
     if (this == result->frame_tree())
       return result;
   }
 
-  return NULL;
+  return nullptr;
+}
+
+FrameTreeNode* FrameTree::FindByName(const std::string& name) {
+  if (name.empty())
+    return root_.get();
+
+  FrameTreeNode* node = nullptr;
+  ForEach(base::Bind(&FrameTreeNodeForName, name, &node));
+  return node;
 }
 
 void FrameTree::ForEach(
     const base::Callback<bool(FrameTreeNode*)>& on_node) const {
-  ForEach(on_node, NULL);
+  ForEach(on_node, nullptr);
 }
 
 void FrameTree::ForEach(
     const base::Callback<bool(FrameTreeNode*)>& on_node,
     FrameTreeNode* skip_this_subtree) const {
   std::queue<FrameTreeNode*> queue;
   queue.push(root_.get());
 
   while (!queue.empty()) {
     FrameTreeNode* node = queue.front();
@@ skipping 125 matching lines @@
 
   render_view_host_map_[site_instance->GetId()] = rvh;
   return rvh;
 }
 
 RenderViewHostImpl* FrameTree::GetRenderViewHost(SiteInstance* site_instance) {
   RenderViewHostMap::iterator iter =
       render_view_host_map_.find(site_instance->GetId());
   // TODO(creis): Mirror the frame tree so this check can't fail.
   if (iter == render_view_host_map_.end())
-    return NULL;
+    return nullptr;
   return iter->second;
 }
 
 void FrameTree::RegisterRenderFrameHost(
     RenderFrameHostImpl* render_frame_host) {
   SiteInstance* site_instance = render_frame_host->GetSiteInstance();
   RenderViewHostMap::iterator iter =
       render_view_host_map_.find(site_instance->GetId());
   CHECK(iter != render_view_host_map_.end());
 
@@ skipping 77 matching lines @@
   load_progress_ = 0.0;
 }
 
 bool FrameTree::IsLoading() {
   bool is_loading = false;
   ForEach(base::Bind(&IsNodeLoading, &is_loading));
   return is_loading;
 }
 
 }  // namespace content