Remove ScopedVector from content/browser/ [1].

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 56 matching lines @@
   EncodePageState(page_state, &data);
   DCHECK(!data.empty()) << "Shouldn't generate an empty PageState.";
   node->frame_entry->SetPageState(PageState::CreateFromEncodedData(data));
 
   // Don't pass the file list to subframes, since that would result in multiple
   // copies of it ending up in the combined list in GetPageState (via
   // RecursivelyGenerateFrameState).
   std::vector<base::NullableString16> empty_file_list;
 
   for (const ExplodedFrameState& child_state : state.children) {
-    NavigationEntryImpl::TreeNode* child_node =
-        new NavigationEntryImpl::TreeNode(node, nullptr);
-    node->children.push_back(child_node);
-    RecursivelyGenerateFrameEntries(child_state, empty_file_list, child_node);
+    node->children.push_back(
+        base::MakeUnique<NavigationEntryImpl::TreeNode>(node, nullptr));
+    RecursivelyGenerateFrameEntries(child_state, empty_file_list,
+                                    node->children.back().get());
   }
 }
 
 void RecursivelyGenerateFrameState(
     NavigationEntryImpl::TreeNode* node,
     ExplodedFrameState* state,
     std::vector<base::NullableString16>* referenced_files) {
   // The FrameNavigationEntry's PageState contains just the ExplodedFrameState
   // for that particular frame.
   ExplodedPageState exploded_page_state;
   if (!DecodePageState(node->frame_entry->page_state().ToEncodedData(),
                        &exploded_page_state)) {
     NOTREACHED();
     return;
   }
   ExplodedFrameState frame_state = exploded_page_state.top;
 
   // Copy the FrameNavigationEntry's frame state into the destination state.
   *state = frame_state;
 
   // Copy the frame's files into the PageState's |referenced_files|.
   referenced_files->reserve(referenced_files->size() +
                             exploded_page_state.referenced_files.size());
   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],
+    RecursivelyGenerateFrameState(node->children[i].get(), &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) {
@@ skipping 47 matching lines @@
   bool is_target_frame =
       target_frame_tree_node && MatchesFrame(target_frame_tree_node);
   std::unique_ptr<NavigationEntryImpl::TreeNode> copy(
       new NavigationEntryImpl::TreeNode(
           parent_node,
           is_target_frame ? frame_navigation_entry : frame_entry->Clone()));
 
   // Recursively clone the children if needed.
   if (!is_target_frame || clone_children_of_target) {
     for (size_t i = 0; i < children.size(); i++) {
-      NavigationEntryImpl::TreeNode* child = children[i];
+      const auto& child = children[i];
 
       // Don't check whether it's still in the tree if |current_frame_tree_node|
       // is null.
       if (!current_frame_tree_node) {
         copy->children.push_back(child->CloneAndReplace(
             frame_navigation_entry, clone_children_of_target,
             target_frame_tree_node, nullptr, copy.get()));
         continue;
       }
 
@@ skipping 624 matching lines @@
   NavigationEntryImpl::TreeNode* parent_node =
       FindFrameEntry(frame_tree_node->parent());
   if (!parent_node) {
     // The renderer should not send a commit for a subframe before its parent.
     // TODO(creis): Kill the renderer if we get here.
     return;
   }
 
   // Now check whether we have a TreeNode for the node itself.
   const std::string& unique_name = frame_tree_node->unique_name();
-  for (TreeNode* child : parent_node->children) {
+  for (const auto& child : parent_node->children) {
     if (child->frame_entry->frame_unique_name() == unique_name) {
       // If the document of the FrameNavigationEntry is changing, we must clear
       // any child FrameNavigationEntries.
       if (child->frame_entry->document_sequence_number() !=
           document_sequence_number)
         child->children.clear();
 
       // Update the existing FrameNavigationEntry (e.g., for replaceState).
       child->frame_entry->UpdateEntry(
           unique_name, item_sequence_number, document_sequence_number,
           site_instance, std::move(source_site_instance), url, referrer,
           redirect_chain, page_state, method, post_id);
       return;
     }
   }
 
   // No entry exists yet, so create a new one.
   // Unordered list, since we expect to look up entries by frame sequence number
   // or unique name.
   FrameNavigationEntry* frame_entry = new FrameNavigationEntry(
       unique_name, item_sequence_number, document_sequence_number,
       site_instance, std::move(source_site_instance), url, referrer, method,
       post_id);
   frame_entry->SetPageState(page_state);
   frame_entry->set_redirect_chain(redirect_chain);
   parent_node->children.push_back(
-      new NavigationEntryImpl::TreeNode(parent_node, frame_entry));
+      base::MakeUnique<NavigationEntryImpl::TreeNode>(parent_node,
+                                                      frame_entry));
 }
 
 FrameNavigationEntry* NavigationEntryImpl::GetFrameEntry(
     FrameTreeNode* frame_tree_node) const {
   NavigationEntryImpl::TreeNode* tree_node = FindFrameEntry(frame_tree_node);
   return tree_node ? tree_node->frame_entry.get() : nullptr;
 }
 
 std::map<std::string, bool> NavigationEntryImpl::GetSubframeUniqueNames(
     FrameTreeNode* frame_tree_node) const {
   std::map<std::string, bool> names;
   NavigationEntryImpl::TreeNode* tree_node = FindFrameEntry(frame_tree_node);
   if (tree_node) {
     // Return the names of all immediate children.
-    for (TreeNode* child : tree_node->children) {
+    for (const auto& child : tree_node->children) {
       // Keep track of whether we would be loading about:blank, since the
       // renderer should be allowed to just commit the initial blank frame if
       // that was the default URL.  PageState doesn't matter there, because
       // content injected into about:blank frames doesn't use it.
       //
       // Be careful not to rely on FrameNavigationEntry's URLs in this check,
       // because the committed URL in the browser could be rewritten to
       // about:blank.
       // See RenderProcessHostImpl::FilterURL to know which URLs are rewritten.
       // See https://crbug.com/657896 for details.
@@ skipping 20 matching lines @@
   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);
+      for (const auto& child : node->children) {
+        work_queue.push(child.get());
       }
       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);
+      auto it = std::find_if(
+          parent_node->children.begin(), parent_node->children.end(),
+          [node](const std::unique_ptr<NavigationEntryImpl::TreeNode>& item) {
+            return item.get() == 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);
 }
 
@@ skipping 13 matching lines @@
   NavigationEntryImpl::TreeNode* node = nullptr;
   std::queue<NavigationEntryImpl::TreeNode*> work_queue;
   work_queue.push(root_node());
   while (!work_queue.empty()) {
     node = work_queue.front();
     work_queue.pop();
     if (node->MatchesFrame(frame_tree_node))
       return node;
 
     // Enqueue any children and keep looking.
-    for (auto* child : node->children)
-      work_queue.push(child);
+    for (const auto& child : node->children)
+      work_queue.push(child.get());
   }
   return nullptr;
 }
 
 }  // namespace content