Update FrameNavigationEntry members when setting PageState.

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 41 matching lines @@
   // Set a single-frame PageState on the entry.
   ExplodedPageState page_state;
   page_state.top = state;
   std::string data;
   EncodePageState(page_state, &data);
   if (data.empty()) {
     // Temporarily generate a minidump to diagnose https://crbug.com/568703.
     base::debug::DumpWithoutCrashing();
     NOTREACHED() << "Shouldn't generate an empty PageState.";
   }
-  node->frame_entry->set_page_state(PageState::CreateFromEncodedData(data));
+  node->frame_entry->SetPageState(PageState::CreateFromEncodedData(data));
 
   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, child_node);
   }
 }
 
 void RecursivelyGenerateFrameState(
@@ skipping 258 matching lines @@
   title_ = title;
   cached_display_title_.clear();
 }
 
 const base::string16& NavigationEntryImpl::GetTitle() const {
   return title_;
 }
 
 void NavigationEntryImpl::SetPageState(const PageState& state) {
   if (!SiteIsolationPolicy::UseSubframeNavigationEntries()) {
-    frame_tree_->frame_entry->set_page_state(state);
+    frame_tree_->frame_entry->SetPageState(state);
     return;
   }
 
   // SetPageState should only be called before the NavigationEntry has been
   // loaded, such as for restore (when there are no subframe
   // FrameNavigationEntries yet).  However, some callers expect to call this
   // after a Clone but before loading the page.  Clone will copy over the
   // subframe entries, and we should reset them before setting the state again.
   //
   // TODO(creis): It would be good to verify that this NavigationEntry hasn't
   // been loaded yet in cases that SetPageState is called while subframe
   // entries exist, but there's currently no way to check that.
   if (!frame_tree_->children.empty())
     frame_tree_->children.clear();
 
   // If the PageState can't be parsed or has no children, just store it on the
   // main frame's FrameNavigationEntry without recursively creating subframe
   // entries.
   ExplodedPageState exploded_state;
   if (!DecodePageState(state.ToEncodedData(), &exploded_state) ||
       exploded_state.top.children.size() == 0U) {
-    frame_tree_->frame_entry->set_page_state(state);
+    frame_tree_->frame_entry->SetPageState(state);
     return;
   }
 
   RecursivelyGenerateFrameEntries(exploded_state.top, frame_tree_.get());
 }
 
 PageState NavigationEntryImpl::GetPageState() const {
   // Just return the main frame's PageState in default Chrome, or if there are
   // no subframe FrameNavigationEntries.
   if (!SiteIsolationPolicy::UseSubframeNavigationEntries() ||
@@ skipping 454 matching lines @@
     }
   }
 
   // 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->set_page_state(page_state);
+  frame_entry->SetPageState(page_state);
   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;
 }
 
@@ skipping 57 matching lines @@
       return node;
 
     // Enqueue any children and keep looking.
     for (auto* child : node->children)
       work_queue.push(child);
   }
   return nullptr;
 }
 
 }  // namespace content