Remove existing FrameNavigationEntry when new named frame is added.

content/browser/frame_host/navigation_entry_impl.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/navigation_entry_impl.h"
 
 #include <stddef.h>
 
 #include <queue>
 #include <utility>
@@ skipping 81 matching lines @@
   for (auto& file : exploded_page_state.referenced_files)
     referenced_files->push_back(file);
 
   state->children.resize(node->children.size());
   for (size_t i = 0; i < node->children.size(); ++i) {
     RecursivelyGenerateFrameState(node->children[i], &state->children[i],
                                   referenced_files);
   }
 }
 
+// Walk the ancestor chain for both the |frame_tree_node| and the |node|.
+// Comparing the inputs directly is not performed, as this method assumes they
+// already match each other. Returns false if a mismatch in unique name or
+// ancestor chain is detected, otherwise true.
+bool InSameTreePosition(FrameTreeNode* frame_tree_node,
+                        NavigationEntryImpl::TreeNode* node) {
+  FrameTreeNode* ftn = frame_tree_node->parent();
+  NavigationEntryImpl::TreeNode* current_node = node->parent;
+  while (ftn && current_node) {
+    if (!current_node->MatchesFrame(ftn))
+      return false;
+
+    if ((!current_node->parent && ftn->parent()) ||
+        (current_node->parent && !ftn->parent())) {
+      return false;
+    }
+
+    ftn = ftn->parent();
+    current_node = current_node->parent;
+  }
+  return true;
+}
+
 }  // namespace
 
 int NavigationEntryImpl::kInvalidBindings = -1;
 
 NavigationEntryImpl::TreeNode::TreeNode(TreeNode* parent,
                                         FrameNavigationEntry* frame_entry)
     : parent(parent), frame_entry(frame_entry) {}
 
 NavigationEntryImpl::TreeNode::~TreeNode() {
 }
@@ skipping 691 matching lines @@
   NavigationEntryImpl::TreeNode* tree_node = FindFrameEntry(frame_tree_node);
   return tree_node ? tree_node->frame_entry.get() : nullptr;
 }
 
 void NavigationEntryImpl::ClearChildren(FrameTreeNode* frame_tree_node) {
   NavigationEntryImpl::TreeNode* tree_node = FindFrameEntry(frame_tree_node);
   if (tree_node)
     tree_node->children.clear();
 }
 
+void NavigationEntryImpl::ClearStaleFrameEntriesForNewFrame(
+    FrameTreeNode* frame_tree_node) {
+  DCHECK(!frame_tree_node->IsMainFrame());
+
+  NavigationEntryImpl::TreeNode* node = nullptr;
+  std::queue<NavigationEntryImpl::TreeNode*> work_queue;
+  int count = 0;
+
+  work_queue.push(root_node());
+  while (!work_queue.empty()) {
+    node = work_queue.front();
+    work_queue.pop();
+
+    // Enqueue any children and keep looking if the current node doesn't match.
+    if (!node->MatchesFrame(frame_tree_node)) {
+      for (auto* child : node->children) {
+        work_queue.push(child);
+      }
+      continue;
+    }
+
+    // Remove the node from the tree if it is not in the same position in the
+    // tree of FrameNavigationEntries and the FrameTree.
+    if (!InSameTreePosition(frame_tree_node, node)) {
+      NavigationEntryImpl::TreeNode* parent_node = node->parent;
+      auto it = std::find(parent_node->children.begin(),
+                          parent_node->children.end(), node);
+      CHECK(it != parent_node->children.end());
+      parent_node->children.erase(it);
+    }
+    ++count;
+  }
+
+  // At most one match is expected, since it is based on unique frame name.
+  DCHECK_LE(count, 1);
+}
+
 void NavigationEntryImpl::SetScreenshotPNGData(
     scoped_refptr<base::RefCountedBytes> png_data) {
   screenshot_ = png_data;
   if (screenshot_.get())
     UMA_HISTOGRAM_MEMORY_KB("Overscroll.ScreenshotSize", screenshot_->size());
 }
 
 GURL NavigationEntryImpl::GetHistoryURLForDataURL() const {
   return GetBaseURLForDataURL().is_empty() ? GURL() : GetVirtualURL();
 }
@@ skipping 10 matching lines @@
       return node;
 
     // Enqueue any children and keep looking.
     for (auto* child : node->children)
       work_queue.push(child);
   }
   return nullptr;
 }
 
 }  // namespace content