DRAFT CL: Add FrameNavigationEntry and track subframe session histories.

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 "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/frame_host/navigation_controller_impl.h"
 #include "content/common/navigation_params.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/url_constants.h"
 #include "net/base/net_util.h"
 #include "ui/gfx/text_elider.h"
 
 // Use this to get a new unique ID for a NavigationEntry during construction.
 // The returned ID is guaranteed to be nonzero (which is the "no ID" indicator).
 static int GetUniqueIDInConstructor() {
   static int unique_id_counter = 0;
   return ++unique_id_counter;
 }
 
 namespace content {
 
 int NavigationEntryImpl::kInvalidBindings = -1;
 
-NavigationEntryImpl::TreeNode::TreeNode(FrameNavigationEntry* frame_entry)
-    : frame_entry(frame_entry) {
+NavigationEntryImpl::TreeNode::TreeNode(NavigationEntryImpl* entry,
+                                        FrameNavigationEntry* frame_entry)
+    : entry(entry),
+      frame_entry(nullptr) {
+  if (frame_entry)
+    SetFrameEntry(frame_entry);
 }
 
 NavigationEntryImpl::TreeNode::~TreeNode() {
 }
 
 NavigationEntryImpl::TreeNode* NavigationEntryImpl::TreeNode::Clone() const {
   // Clone the tree using a copy of the FrameNavigationEntry, without sharing.
+  // TODO(creis): Should not have an |entry| in TreeNode.  Currently sharing
+  // it, which is very wrong.
   NavigationEntryImpl::TreeNode* copy =
-      new NavigationEntryImpl::TreeNode(frame_entry->Clone());
+      new NavigationEntryImpl::TreeNode(entry, frame_entry->Clone());
 
   // TODO(creis): Clone children once we add them.
   return copy;
 }
 
+void NavigationEntryImpl::TreeNode::SetFrameEntry(
+    FrameNavigationEntry* new_frame_entry) {
+  frame_entry = new_frame_entry;
+  entry->frames_to_items_[new_frame_entry->frame_tree_node_id()] = this;
+
+  // TODO(creis): Move NE::frame_to_target_ to FNE::target_.
+  //entry->unique_names_to_items_[frame_entry->target()] = this;
+}
+
 NavigationEntry* NavigationEntry::Create() {
   return new NavigationEntryImpl();
 }
 
 NavigationEntryImpl* NavigationEntryImpl::FromNavigationEntry(
     NavigationEntry* entry) {
   return static_cast<NavigationEntryImpl*>(entry);
 }
 
 NavigationEntryImpl::NavigationEntryImpl()
     : NavigationEntryImpl(nullptr, -1, GURL(), Referrer(), base::string16(),
                           ui::PAGE_TRANSITION_LINK, false) {
 }
 
 NavigationEntryImpl::NavigationEntryImpl(SiteInstanceImpl* instance,
                                          int page_id,
                                          const GURL& url,
                                          const Referrer& referrer,
                                          const base::string16& title,
                                          ui::PageTransition transition_type,
                                          bool is_renderer_initiated)
-    : frame_tree_(
-          new TreeNode(new FrameNavigationEntry(instance, url, referrer))),
+    : frame_tree_(new TreeNode(
+          this, new FrameNavigationEntry(instance, url, referrer))),
       unique_id_(GetUniqueIDInConstructor()),
       bindings_(kInvalidBindings),
       page_type_(PAGE_TYPE_NORMAL),
       update_virtual_url_with_url_(false),
       title_(title),
       page_id_(page_id),
       transition_type_(transition_type),
       has_post_data_(false),
       post_id_(-1),
       restore_type_(RESTORE_NONE),
       is_overriding_user_agent_(false),
       http_status_code_(0),
       is_renderer_initiated_(is_renderer_initiated),
       should_replace_entry_(false),
       should_clear_history_list_(false),
-      can_load_local_resources_(false),
-      frame_tree_node_id_(-1) {
+      can_load_local_resources_(false) {
 }
 
 NavigationEntryImpl::~NavigationEntryImpl() {
 }
 
 int NavigationEntryImpl::GetUniqueID() const {
   return unique_id_;
 }
 
 PageType NavigationEntryImpl::GetPageType() const {
@@ skipping 37 matching lines @@
 void NavigationEntryImpl::SetTitle(const base::string16& title) {
   title_ = title;
   cached_display_title_.clear();
 }
 
 const base::string16& NavigationEntryImpl::GetTitle() const {
   return title_;
 }
 
 void NavigationEntryImpl::SetPageState(const PageState& state) {
-  page_state_ = state;
+  CHECK(state.ToEncodedData().empty() || state.IsValid());
+  frame_tree_->frame_entry->set_page_state(state);
 }
 
 const PageState& NavigationEntryImpl::GetPageState() const {
-  return page_state_;
+  return frame_tree_->frame_entry->page_state();
 }
 
 void NavigationEntryImpl::SetPageID(int page_id) {
   page_id_ = page_id;
 }
 
 int32 NavigationEntryImpl::GetPageID() const {
   return page_id_;
 }
 
@@ skipping 178 matching lines @@
   if (iter == extra_data_.end())
     return false;
   *data = iter->second;
   return true;
 }
 
 void NavigationEntryImpl::ClearExtraData(const std::string& key) {
   extra_data_.erase(key);
 }
 
+void NavigationEntryImpl::ResetFrameTree() {
+  frame_tree_.reset(new TreeNode(this, nullptr));
+}
+
+NavigationEntryImpl::TreeNode* NavigationEntryImpl::GetTreeNodeForFrame(
+    FrameTreeNode* frame_tree_node) {
+  // Search based on FTN ID and unique name.
+  // TODO(creis): We had been using a map of routing ID to frame sequence num.
+  // Is that useful here?
+  if (TreeNode* node = frames_to_items_[frame_tree_node->frame_tree_node_id()])
+    return node;
+  // TODO(creis): Move NE::frame_to_target_ to FNE::target_.
+  //if (TreeNode* node = unique_names_to_items_[frame_tree_node->name()])
+  //  return node;
+  return nullptr;
+}
+
+FrameNavigationEntry* NavigationEntryImpl::GetFrameEntryForFrame(
+    FrameTreeNode* frame_tree_node) {
+  TreeNode* node = GetTreeNodeForFrame(frame_tree_node);
+  if (node)
+    return node->frame_entry.get();
+  return nullptr;
+}
+
 NavigationEntryImpl* NavigationEntryImpl::Clone() const {
   NavigationEntryImpl* copy = new NavigationEntryImpl();
 
   // TODO(creis): Only share the same FrameNavigationEntries if cloning within
   // the same tab.
   copy->frame_tree_.reset(frame_tree_->Clone());
 
   // Copy all state over, unless cleared in ResetForCommit.
   copy->unique_id_ = unique_id_;
   copy->bindings_ = bindings_;
   copy->page_type_ = page_type_;
   copy->virtual_url_ = virtual_url_;
   copy->update_virtual_url_with_url_ = update_virtual_url_with_url_;
   copy->title_ = title_;
   copy->favicon_ = favicon_;
-  copy->page_state_ = page_state_;
   copy->page_id_ = page_id_;
   copy->ssl_ = ssl_;
   copy->transition_type_ = transition_type_;
   copy->user_typed_url_ = user_typed_url_;
   copy->has_post_data_ = has_post_data_;
   copy->post_id_ = post_id_;
   copy->restore_type_ = restore_type_;
   copy->original_request_url_ = original_request_url_;
   copy->is_overriding_user_agent_ = is_overriding_user_agent_;
   copy->timestamp_ = timestamp_;
@@ skipping 22 matching lines @@
   // cleared here.
   // TODO(creis): This state should be moved to NavigationRequest once
   // PlzNavigate is enabled.
   SetBrowserInitiatedPostData(nullptr);
   set_source_site_instance(nullptr);
   set_is_renderer_initiated(false);
   set_transferred_global_request_id(GlobalRequestID());
   set_should_replace_entry(false);
 
   set_should_clear_history_list(false);
-  set_frame_tree_node_id(-1);
 
 #if defined(OS_ANDROID)
   // Reset the time stamp so that the metrics are not reported if this entry is
   // loaded again in the future.
   set_intent_received_timestamp(base::TimeTicks());
 #endif
 }
 
 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();
 }
 
 CommonNavigationParams NavigationEntryImpl::ConstructCommonNavigationParams(
+    const FrameNavigationEntry& frame_entry,
     FrameMsg_Navigate_Type::Value navigation_type) const {
   FrameMsg_UILoadMetricsReportType::Value report_type =
       FrameMsg_UILoadMetricsReportType::NO_REPORT;
   base::TimeTicks ui_timestamp = base::TimeTicks();
 #if defined(OS_ANDROID)
   if (!intent_received_timestamp().is_null())
     report_type = FrameMsg_UILoadMetricsReportType::REPORT_INTENT;
   ui_timestamp = intent_received_timestamp();
 #endif
 
   return CommonNavigationParams(
-      GetURL(), GetReferrer(), GetTransitionType(), navigation_type,
-      !IsViewSourceMode(), ui_timestamp, report_type, GetBaseURLForDataURL(),
-      GetHistoryURLForDataURL());
+      frame_entry.url(), frame_entry.referrer(), GetTransitionType(),
+      navigation_type, !IsViewSourceMode(), ui_timestamp, report_type,
+      GetBaseURLForDataURL(), GetHistoryURLForDataURL());
 }
 
 CommitNavigationParams NavigationEntryImpl::ConstructCommitNavigationParams(
     base::TimeTicks navigation_start) const {
   // Set the redirect chain to the navigation's redirects, unless returning to a
   // completed navigation (whose previous redirects don't apply).
   std::vector<GURL> redirects;
   if (ui::PageTransitionIsNewNavigation(GetTransitionType())) {
     redirects = GetRedirectChain();
   }
 
   return CommitNavigationParams(GetIsOverridingUserAgent(), navigation_start,
                                 redirects, GetCanLoadLocalResources(),
                                 GetFrameToNavigate(), base::Time::Now());
 }
 
 HistoryNavigationParams NavigationEntryImpl::ConstructHistoryNavigationParams(
+    const FrameNavigationEntry& frame_entry,
     NavigationControllerImpl* controller) const {
   int pending_history_list_offset = controller->GetIndexOfEntry(this);
   int current_history_list_offset = controller->GetLastCommittedEntryIndex();
   int current_history_list_length = controller->GetEntryCount();
   if (should_clear_history_list()) {
     // Set the history list related parameters to the same values a
     // NavigationController would return before its first navigation. This will
     // fully clear the RenderView's view of the session history.
     pending_history_list_offset = -1;
     current_history_list_offset = -1;
     current_history_list_length = 0;
   }
   return HistoryNavigationParams(
-      GetPageState(), GetPageID(), pending_history_list_offset,
+      frame_entry.page_state(), GetPageID(), pending_history_list_offset,
       current_history_list_offset, current_history_list_length,
       should_clear_history_list());
 }
 
 StartNavigationParams NavigationEntryImpl::ConstructStartNavigationParams()
     const {
   std::vector<unsigned char> browser_initiated_post_data;
   if (GetBrowserInitiatedPostData()) {
     browser_initiated_post_data.assign(
         GetBrowserInitiatedPostData()->front(),
         GetBrowserInitiatedPostData()->front() +
             GetBrowserInitiatedPostData()->size());
   }
 
   return StartNavigationParams(
       GetHasPostData(), extra_headers(), browser_initiated_post_data,
       should_replace_entry(), transferred_global_request_id().child_id,
       transferred_global_request_id().request_id);
 }
 
 }  // namespace content