Add is_srcdoc to FrameNavigationEntry and restore about::srcdoc URL.

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 27 matching lines @@
 // The returned ID is guaranteed to be nonzero (which is the "no ID" indicator).
 int GetUniqueIDInConstructor() {
   static int unique_id_counter = 0;
   return ++unique_id_counter;
 }
 
 void RecursivelyGenerateFrameEntries(
     const ExplodedFrameState& state,
     const std::vector<base::NullableString16>& referenced_files,
     NavigationEntryImpl::TreeNode* node) {
+  GURL renderer_url(state.url_string.string());
+  bool is_srcdoc = (renderer_url == GURL(content::kAboutSrcDocURL));
+  GURL browser_url = is_srcdoc ? GURL(url::kAboutBlankURL) : renderer_url;
+
   node->frame_entry = new FrameNavigationEntry(
       UTF16ToUTF8(state.target.string()), state.item_sequence_number,
-      state.document_sequence_number, nullptr, nullptr,
-      GURL(state.url_string.string()),
-      Referrer(GURL(state.referrer.string()), state.referrer_policy), "GET",
-      -1);
+      state.document_sequence_number, nullptr, nullptr, browser_url,
+      Referrer(GURL(state.referrer.string()), state.referrer_policy), "GET", -1,
+      is_srcdoc);
 
   // Set a single-frame PageState on the entry.
   ExplodedPageState page_state;
 
   // Copy the incoming PageState's list of referenced files into the main
   // frame's PageState.  (We don't pass the list to subframes below.)
   // TODO(creis): Grant access to this list for each process that renders
   // this page, even for OOPIFs.  Eventually keep track of a verified list of
   // files per frame, so that we only grant access to processes that need it.
   if (referenced_files.size() > 0)
@@ skipping 189 matching lines @@
     bool is_renderer_initiated)
     : frame_tree_(new TreeNode(nullptr,
                                new FrameNavigationEntry("",
                                                         -1,
                                                         -1,
                                                         std::move(instance),
                                                         nullptr,
                                                         url,
                                                         referrer,
                                                         "GET",
-                                                        -1))),
+                                                        -1,
+                                                        false))),
       unique_id_(GetUniqueIDInConstructor()),
       bindings_(kInvalidBindings),
       page_type_(PAGE_TYPE_NORMAL),
       update_virtual_url_with_url_(false),
       title_(title),
       transition_type_(transition_type),
       restore_type_(RestoreType::NONE),
       is_overriding_user_agent_(false),
       http_status_code_(0),
       is_renderer_initiated_(is_renderer_initiated),
@@ skipping 517 matching lines @@
     FrameTreeNode* frame_tree_node,
     int64_t item_sequence_number,
     int64_t document_sequence_number,
     SiteInstanceImpl* site_instance,
     scoped_refptr<SiteInstanceImpl> source_site_instance,
     const GURL& url,
     const Referrer& referrer,
     const std::vector<GURL>& redirect_chain,
     const PageState& page_state,
     const std::string& method,
-    int64_t post_id) {
+    int64_t post_id,
+    bool is_srcdoc) {
   // If this is called for the main frame, the FrameNavigationEntry is
   // guaranteed to exist, so just update it directly and return.
   if (frame_tree_node->IsMainFrame()) {
     // If the document of the FrameNavigationEntry is changing, we must clear
     // any child FrameNavigationEntries.
     if (root_node()->frame_entry->document_sequence_number() !=
         document_sequence_number)
       root_node()->children.clear();
 
     root_node()->frame_entry->UpdateEntry(
         frame_tree_node->unique_name(), item_sequence_number,
         document_sequence_number, site_instance,
         std::move(source_site_instance), url, referrer, redirect_chain,
-        page_state, method, post_id);
+        page_state, method, post_id, is_srcdoc);
     return;
   }
 
   // We should already have a TreeNode for the parent node by the time this node
   // commits.  Find it first.
   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) {
     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);
+          redirect_chain, page_state, method, post_id, is_srcdoc);
       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);
+      post_id, is_srcdoc);
   frame_entry->SetPageState(page_state);
   frame_entry->set_redirect_chain(redirect_chain);
   parent_node->children.push_back(
       new 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) {
       // 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 include iframe srcdoc URLs in this check, which do

[Charlie Reis, 2016/11/07 21:32:58]

Note: This code also depended on detecting the srcdoc case.  I can update it
later if needed, but it's something that either the current or alternative
approach might be able to clean up.

[arthursonzogni, 2016/11/08 12:21:30]

Yes, this code could be cleaned here by the two approachs. I will wait the
decision to follow one of them and then clean this part.

       // need their PageState.  The committed URL in that case gets rewritten to
       // about:blank, but we can detect it via the PageState's URL.
       //
       // See https://crbug.com/657896 for details.
       bool is_about_blank = false;
       ExplodedPageState exploded_page_state;
       if (DecodePageState(child->frame_entry->page_state().ToEncodedData(),
                           &exploded_page_state)) {
         ExplodedFrameState frame_state = exploded_page_state.top;
         if (UTF16ToUTF8(frame_state.url_string.string()) == url::kAboutBlankURL)
@@ skipping 66 matching lines @@
       return node;
 
     // Enqueue any children and keep looking.
     for (auto* child : node->children)
       work_queue.push(child);
   }
   return nullptr;
 }
 
 }  // namespace content