Convert NavigationController unit and browser tests to use the new navigation callbacks.

content/browser/frame_host/navigation_controller_impl_browsertest.cc

 // Copyright 2014 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_controller_impl.h"
 
 #include <stdint.h>
 #include <algorithm>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/histogram_tester.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "content/browser/frame_host/frame_navigation_entry.h"
 #include "content/browser/frame_host/frame_tree.h"
 #include "content/browser/frame_host/navigation_entry_impl.h"
+#include "content/browser/frame_host/navigation_handle_impl.h"
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/common/frame_messages.h"
 #include "content/common/page_state_serialization.h"
 #include "content/common/site_isolation_policy.h"
 #include "content/public/browser/navigation_controller.h"
-#include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/resource_dispatcher_host.h"
 #include "content/public/browser/resource_dispatcher_host_delegate.h"
 #include "content/public/browser/resource_throttle.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/common/bindings_policy.h"
 #include "content/public/common/browser_side_navigation_policy.h"
 #include "content/public/common/renderer_preferences.h"
@@ skipping 529 matching lines @@
 
 namespace {
 
 class NoNavigationsObserver : public WebContentsObserver {
  public:
   // Observes navigation for the specified |web_contents|.
   explicit NoNavigationsObserver(WebContents* web_contents)
       : WebContentsObserver(web_contents) {}
 
  private:
-  void DidNavigateAnyFrame(RenderFrameHost* render_frame_host,
-                           const LoadCommittedDetails& details,
-                           const FrameNavigateParams& params) override {
+  void DidFinishNavigation(NavigationHandle* navigation_handle) override {
+    if (!navigation_handle->HasCommitted())
+      return;
     FAIL() << "No navigations should occur";
   }
 };
 
 class FrameNavigateParamsCapturer : public WebContentsObserver {
  public:
   // Observes navigation for the specified |node|.
   explicit FrameNavigateParamsCapturer(FrameTreeNode* node)
       : WebContentsObserver(
             node->current_frame_host()->delegate()->GetAsWebContents()),
         frame_tree_node_id_(node->frame_tree_node_id()),
         navigations_remaining_(1),
         wait_for_load_(true),
         message_loop_runner_(new MessageLoopRunner) {}
 
   void set_navigations_remaining(int count) {
     navigations_remaining_ = count;
   }
 
   void set_wait_for_load(bool ignore) {
     wait_for_load_ = ignore;
   }
 
   void Wait() {
     message_loop_runner_->Run();
   }
 
-  const FrameNavigateParams& params() const {
-    EXPECT_EQ(1U, params_.size());
-    return params_[0];
+  ui::PageTransition transition() {
+    EXPECT_EQ(1U, transitions_.size());
+    return transitions_[0];
   }
 
-  const std::vector<FrameNavigateParams>& all_params() const {
-    return params_;
+  NavigationType type() {
+    EXPECT_EQ(1U, types_.size());
+    return types_[0];
   }
 
-  const LoadCommittedDetails& details() const {
-    EXPECT_EQ(1U, details_.size());
-    return details_[0];
+  bool is_in_page() {
+    EXPECT_EQ(1U, is_in_pages_.size());
+    return is_in_pages_[0];
   }
 
-  const std::vector<LoadCommittedDetails>& all_details() const {
-    return details_;
-  }
+  const std::vector<ui::PageTransition>& transitions() { return transitions_; }
+  const std::vector<GURL>& urls() { return urls_; }
+  const std::vector<NavigationType>& types() { return types_; }
+  const std::vector<bool>& is_in_pages() { return is_in_pages_; }
 
  private:
-  void DidNavigateAnyFrame(RenderFrameHost* render_frame_host,
-                           const LoadCommittedDetails& details,
-                           const FrameNavigateParams& params) override {
-    RenderFrameHostImpl* rfh =
-        static_cast<RenderFrameHostImpl*>(render_frame_host);
-    if (rfh->frame_tree_node()->frame_tree_node_id() != frame_tree_node_id_)
+  void DidFinishNavigation(NavigationHandle* navigation_handle) override {
+    if (!navigation_handle->HasCommitted())
+      return;
+
+    if (navigation_handle->GetFrameTreeNodeId() != frame_tree_node_id_)
       return;
 
     --navigations_remaining_;
-    params_.push_back(params);
-    details_.push_back(details);
+    transitions_.push_back(navigation_handle->GetPageTransition());
+    urls_.push_back(navigation_handle->GetURL());
+    types_.push_back(static_cast<NavigationHandleImpl*>(navigation_handle)->
+        navigation_type());
+    is_in_pages_.push_back(navigation_handle->IsSamePage());
     if (!navigations_remaining_ &&
         (!web_contents()->IsLoading() || !wait_for_load_))
       message_loop_runner_->Quit();
   }
 
   void DidStopLoading() override {
     if (!navigations_remaining_)
       message_loop_runner_->Quit();
   }
 
   // The id of the FrameTreeNode whose navigations to observe.
   int frame_tree_node_id_;
 
   // How many navigations remain to capture.
   int navigations_remaining_;
 
   // Whether to also wait for the load to complete.
   bool wait_for_load_;
 
-  // The params of the navigations.
-  std::vector<FrameNavigateParams> params_;
-
-  // The details of the navigations.
-  std::vector<LoadCommittedDetails> details_;
+  std::vector<ui::PageTransition> transitions_;
+  std::vector<GURL> urls_;
+  std::vector<NavigationType> types_;

[nasko, 2017/02/09 00:29:11]

nit: navigation_types_

[jam, 2017/02/09 01:15:03]

Done.

+  std::vector<bool> is_in_pages_;
 
   // The MessageLoopRunner used to spin the message loop.
   scoped_refptr<MessageLoopRunner> message_loop_runner_;
 };
 
 class LoadCommittedCapturer : public WebContentsObserver {
  public:
   // Observes the load commit for the specified |node|.
   explicit LoadCommittedCapturer(FrameTreeNode* node)
       : WebContentsObserver(
@@ skipping 234 matching lines @@
   FrameTreeNode* root =
       static_cast<WebContentsImpl*>(shell()->web_contents())->
           GetFrameTree()->root();
 
   // Navigate to a page that fails to load. It must result in an error page, the
   // NEW_PAGE navigation type, and an addition to the history list.
   {
     FrameNavigateParamsCapturer capturer(root);
     NavigateFrameToURL(root, error_url);
     capturer.Wait();
-    EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, capturer.details().type);
+    EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, capturer.type());
     NavigationEntry* entry = controller.GetLastCommittedEntry();
     EXPECT_EQ(PAGE_TYPE_ERROR, entry->GetPageType());
     EXPECT_EQ(2, controller.GetEntryCount());
   }
 
   // Navigate again to the page that fails to load. It must result in an error
   // page, the EXISTING_PAGE navigation type, and no addition to the history
   // list. We do not use SAME_PAGE here; that case only differs in that it
   // clears the pending entry, and there is no pending entry after a load
   // failure.
   {
     FrameNavigateParamsCapturer capturer(root);
     NavigateFrameToURL(root, error_url);
     capturer.Wait();
-    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.details().type);
+    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.type());
     NavigationEntry* entry = controller.GetLastCommittedEntry();
     EXPECT_EQ(PAGE_TYPE_ERROR, entry->GetPageType());
     EXPECT_EQ(2, controller.GetEntryCount());
   }
 
   // Make a new entry ...
   EXPECT_TRUE(NavigateToURL(shell(), GURL(url::kAboutBlankURL)));
   EXPECT_EQ(3, controller.GetEntryCount());
 
   // ... and replace it with a failed load.
   // TODO(creis): Make this be NEW_PAGE along with the other location.replace
   // cases.  There isn't much impact to having this be EXISTING_PAGE for now.
   // See https://crbug.com/596707.
   {
     FrameNavigateParamsCapturer capturer(root);
     RendererLocationReplace(shell(), error_url);
     capturer.Wait();
-    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.details().type);
+    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.type());
     NavigationEntry* entry = controller.GetLastCommittedEntry();
     EXPECT_EQ(PAGE_TYPE_ERROR, entry->GetPageType());
     EXPECT_EQ(3, controller.GetEntryCount());
   }
 
   // Make a new web ui page to force a process swap ...
   GURL web_ui_page(std::string(kChromeUIScheme) + "://" +
                    std::string(kChromeUIGpuHost));
   EXPECT_TRUE(NavigateToURL(shell(), web_ui_page));
   EXPECT_EQ(4, controller.GetEntryCount());
 
   // ... and replace it with a failed load. (It is NEW_PAGE for the reason noted
   // above.)
   {
     FrameNavigateParamsCapturer capturer(root);
     RendererLocationReplace(shell(), error_url);
     capturer.Wait();
-    EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, capturer.details().type);
+    EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, capturer.type());
     NavigationEntry* entry = controller.GetLastCommittedEntry();
     EXPECT_EQ(PAGE_TYPE_ERROR, entry->GetPageType());
     EXPECT_EQ(4, controller.GetEntryCount());
   }
 }
 
 // Various tests for navigation type classifications. TODO(avi): It's rather
 // bogus that the same info is in two different enums; http://crbug.com/453555.
 
 // Verify that navigations for NAVIGATION_TYPE_NEW_PAGE are correctly
 // classified.
 IN_PROC_BROWSER_TEST_F(NavigationControllerBrowserTest,
                        NavigationTypeClassification_NewPage) {
   EXPECT_TRUE(NavigateToURL(shell(), GURL(url::kAboutBlankURL)));
 
   FrameTreeNode* root =
       static_cast<WebContentsImpl*>(shell()->web_contents())->
           GetFrameTree()->root();
 
   {
     // Simple load.
     FrameNavigateParamsCapturer capturer(root);
     GURL frame_url(embedded_test_server()->GetURL(
         "/navigation_controller/page_with_links.html"));
     NavigateFrameToURL(root, frame_url);
     capturer.Wait();
     // TODO(avi,creis): Why is this (and quite a few others below) a "link"
     // transition? Lots of these transitions should be cleaned up.
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition, ui::PAGE_TRANSITION_LINK));
-    EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, capturer.details().type);
-    EXPECT_FALSE(capturer.details().is_in_page);
+        capturer.transition(), ui::PAGE_TRANSITION_LINK));
+    EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, capturer.type());
+    EXPECT_FALSE(capturer.is_in_page());
   }
 
   {
     // Load via a fragment link click.
     FrameNavigateParamsCapturer capturer(root);
     std::string script = "document.getElementById('fraglink').click()";
     EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition, ui::PAGE_TRANSITION_LINK));
-    EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, capturer.details().type);
-    EXPECT_TRUE(capturer.details().is_in_page);
+        capturer.transition(), ui::PAGE_TRANSITION_LINK));
+    EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, capturer.type());
+    EXPECT_TRUE(capturer.is_in_page());
   }
 
   {
     // Load via link click.
     FrameNavigateParamsCapturer capturer(root);
     std::string script = "document.getElementById('thelink').click()";
     EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition, ui::PAGE_TRANSITION_LINK));
-    EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, capturer.details().type);
-    EXPECT_FALSE(capturer.details().is_in_page);
+        capturer.transition(), ui::PAGE_TRANSITION_LINK));
+    EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, capturer.type());
+    EXPECT_FALSE(capturer.is_in_page());
   }
 
   {
     // location.assign().
     FrameNavigateParamsCapturer capturer(root);
     GURL frame_url(embedded_test_server()->GetURL(
         "/navigation_controller/simple_page_2.html"));
     std::string script = "location.assign('" + frame_url.spec() + "')";
     EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition,
+        capturer.transition(),
         ui::PageTransitionFromInt(ui::PAGE_TRANSITION_LINK |
                                   ui::PAGE_TRANSITION_CLIENT_REDIRECT)));
-    EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, capturer.details().type);
-    EXPECT_FALSE(capturer.details().is_in_page);
+    EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, capturer.type());
+    EXPECT_FALSE(capturer.is_in_page());
   }
 
   {
     // history.pushState().
     FrameNavigateParamsCapturer capturer(root);
     std::string script =
         "history.pushState({}, 'page 1', 'simple_page_1.html')";
     EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition,
+        capturer.transition(),
         ui::PageTransitionFromInt(ui::PAGE_TRANSITION_LINK |
                                   ui::PAGE_TRANSITION_CLIENT_REDIRECT)));
-    EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, capturer.details().type);
-    EXPECT_TRUE(capturer.details().is_in_page);
+    EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, capturer.type());
+    EXPECT_TRUE(capturer.is_in_page());
   }
 
   if (AreAllSitesIsolatedForTesting()) {
     // Cross-process location.replace().
     FrameNavigateParamsCapturer capturer(root);
     GURL frame_url(embedded_test_server()->GetURL(
         "foo.com", "/navigation_controller/simple_page_1.html"));
     std::string script = "location.replace('" + frame_url.spec() + "')";
     EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition,
+        capturer.transition(),
         ui::PageTransitionFromInt(ui::PAGE_TRANSITION_LINK |
                                   ui::PAGE_TRANSITION_CLIENT_REDIRECT)));
-    EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, capturer.details().type);
-    EXPECT_FALSE(capturer.details().is_in_page);
+    EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, capturer.type());
+    EXPECT_FALSE(capturer.is_in_page());
   }
 }
 
 // Verify that navigations for NAVIGATION_TYPE_EXISTING_PAGE are correctly
 // classified.
 IN_PROC_BROWSER_TEST_F(NavigationControllerBrowserTest,
                        NavigationTypeClassification_ExistingPage) {
   GURL url1(embedded_test_server()->GetURL(
       "/navigation_controller/simple_page_1.html"));
   EXPECT_TRUE(NavigateToURL(shell(), url1));
   GURL url2(embedded_test_server()->GetURL(
       "/navigation_controller/simple_page_2.html"));
   EXPECT_TRUE(NavigateToURL(shell(), url2));
 
   FrameTreeNode* root =
       static_cast<WebContentsImpl*>(shell()->web_contents())->
           GetFrameTree()->root();
 
   {
     // Back from the browser side.
     FrameNavigateParamsCapturer capturer(root);
     shell()->web_contents()->GetController().GoBack();
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition,
+        capturer.transition(),
         ui::PageTransitionFromInt(ui::PAGE_TRANSITION_TYPED |
                                   ui::PAGE_TRANSITION_FORWARD_BACK |
                                   ui::PAGE_TRANSITION_FROM_ADDRESS_BAR)));
-    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.details().type);
-    EXPECT_FALSE(capturer.details().is_in_page);
+    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.type());
+    EXPECT_FALSE(capturer.is_in_page());
   }
 
   {
     // Forward from the browser side.
     FrameNavigateParamsCapturer capturer(root);
     shell()->web_contents()->GetController().GoForward();
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition,
+        capturer.transition(),
         ui::PageTransitionFromInt(ui::PAGE_TRANSITION_TYPED |
                                   ui::PAGE_TRANSITION_FORWARD_BACK |
                                   ui::PAGE_TRANSITION_FROM_ADDRESS_BAR)));
-    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.details().type);
-    EXPECT_FALSE(capturer.details().is_in_page);
+    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.type());
+    EXPECT_FALSE(capturer.is_in_page());
   }
 
   {
     // Back from the renderer side.
     FrameNavigateParamsCapturer capturer(root);
     EXPECT_TRUE(ExecuteScript(root, "history.back()"));
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition,
+        capturer.transition(),
         ui::PageTransitionFromInt(ui::PAGE_TRANSITION_TYPED |
                                   ui::PAGE_TRANSITION_FORWARD_BACK |
                                   ui::PAGE_TRANSITION_FROM_ADDRESS_BAR)));
-    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.details().type);
-    EXPECT_FALSE(capturer.details().is_in_page);
+    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.type());
+    EXPECT_FALSE(capturer.is_in_page());
   }
 
   {
     // Forward from the renderer side.
     FrameNavigateParamsCapturer capturer(root);
     EXPECT_TRUE(ExecuteScript(root, "history.forward()"));
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition,
+        capturer.transition(),
         ui::PageTransitionFromInt(ui::PAGE_TRANSITION_TYPED |
                                   ui::PAGE_TRANSITION_FORWARD_BACK |
                                   ui::PAGE_TRANSITION_FROM_ADDRESS_BAR)));
-    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.details().type);
-    EXPECT_FALSE(capturer.details().is_in_page);
+    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.type());
+    EXPECT_FALSE(capturer.is_in_page());
   }
 
   {
     // Back from the renderer side via history.go().
     FrameNavigateParamsCapturer capturer(root);
     EXPECT_TRUE(ExecuteScript(root, "history.go(-1)"));
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition,
+        capturer.transition(),
         ui::PageTransitionFromInt(ui::PAGE_TRANSITION_TYPED |
                                   ui::PAGE_TRANSITION_FORWARD_BACK |
                                   ui::PAGE_TRANSITION_FROM_ADDRESS_BAR)));
-    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.details().type);
-    EXPECT_FALSE(capturer.details().is_in_page);
+    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.type());
+    EXPECT_FALSE(capturer.is_in_page());
   }
 
   {
     // Forward from the renderer side via history.go().
     FrameNavigateParamsCapturer capturer(root);
     EXPECT_TRUE(ExecuteScript(root, "history.go(1)"));
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition,
+        capturer.transition(),
         ui::PageTransitionFromInt(ui::PAGE_TRANSITION_TYPED |
                                   ui::PAGE_TRANSITION_FORWARD_BACK |
                                   ui::PAGE_TRANSITION_FROM_ADDRESS_BAR)));
-    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.details().type);
-    EXPECT_FALSE(capturer.details().is_in_page);
+    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.type());
+    EXPECT_FALSE(capturer.is_in_page());
   }
 
   {
     // Reload from the browser side.
     FrameNavigateParamsCapturer capturer(root);
     shell()->web_contents()->GetController().Reload(ReloadType::NORMAL, false);
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition, ui::PAGE_TRANSITION_RELOAD));
-    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.details().type);
-    EXPECT_FALSE(capturer.details().is_in_page);
+        capturer.transition(), ui::PAGE_TRANSITION_RELOAD));
+    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.type());
+    EXPECT_FALSE(capturer.is_in_page());
   }
 
   {
     // Reload from the renderer side.
     FrameNavigateParamsCapturer capturer(root);
     EXPECT_TRUE(ExecuteScript(root, "location.reload()"));
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition,
+        capturer.transition(),
         ui::PageTransitionFromInt(ui::PAGE_TRANSITION_LINK |
                                   ui::PAGE_TRANSITION_CLIENT_REDIRECT)));
-    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.details().type);
-    EXPECT_FALSE(capturer.details().is_in_page);
+    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.type());
+    EXPECT_FALSE(capturer.is_in_page());
   }
 
   {
     // location.replace().
     // TODO(creis): Change this to be NEW_PAGE with replacement in
     // https://crbug.com/596707.
     FrameNavigateParamsCapturer capturer(root);
     GURL frame_url(embedded_test_server()->GetURL(
         "/navigation_controller/simple_page_1.html"));
     std::string script = "location.replace('" + frame_url.spec() + "')";
     EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition,
+        capturer.transition(),
         ui::PageTransitionFromInt(ui::PAGE_TRANSITION_LINK |
                                   ui::PAGE_TRANSITION_CLIENT_REDIRECT)));
-    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.details().type);
-    EXPECT_FALSE(capturer.details().is_in_page);
+    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.type());
+    EXPECT_FALSE(capturer.is_in_page());
   }
 
   // Now, various in-page navigations.
 
   {
     // history.replaceState().
     FrameNavigateParamsCapturer capturer(root);
     std::string script =
         "history.replaceState({}, 'page 2', 'simple_page_2.html')";
     EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition,
+        capturer.transition(),
         ui::PageTransitionFromInt(ui::PAGE_TRANSITION_LINK |
                                   ui::PAGE_TRANSITION_CLIENT_REDIRECT)));
-    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.details().type);
-    EXPECT_TRUE(capturer.details().is_in_page);
+    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.type());
+    EXPECT_TRUE(capturer.is_in_page());
   }
 
   // Back and forward across a fragment navigation.
 
   GURL url_links(embedded_test_server()->GetURL(
       "/navigation_controller/page_with_links.html"));
   EXPECT_TRUE(NavigateToURL(shell(), url_links));
   std::string script = "document.getElementById('fraglink').click()";
   EXPECT_TRUE(ExecuteScript(root, script));
   EXPECT_TRUE(WaitForLoadStop(shell()->web_contents()));
 
   {
     // Back.
     FrameNavigateParamsCapturer capturer(root);
     shell()->web_contents()->GetController().GoBack();
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition,
+        capturer.transition(),
         ui::PageTransitionFromInt(ui::PAGE_TRANSITION_TYPED |
                                   ui::PAGE_TRANSITION_FORWARD_BACK |
                                   ui::PAGE_TRANSITION_FROM_ADDRESS_BAR)));
-    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.details().type);
-    EXPECT_TRUE(capturer.details().is_in_page);
+    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.type());
+    EXPECT_TRUE(capturer.is_in_page());
   }
 
   {
     // Forward.
     FrameNavigateParamsCapturer capturer(root);
     shell()->web_contents()->GetController().GoForward();
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition,
+        capturer.transition(),
         ui::PageTransitionFromInt(ui::PAGE_TRANSITION_LINK |
                                   ui::PAGE_TRANSITION_FORWARD_BACK)));
-    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.details().type);
-    EXPECT_TRUE(capturer.details().is_in_page);
+    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.type());
+    EXPECT_TRUE(capturer.is_in_page());
   }
 
   // Back and forward across a pushState-created navigation.
 
   EXPECT_TRUE(NavigateToURL(shell(), url1));
   script = "history.pushState({}, 'page 2', 'simple_page_2.html')";
   EXPECT_TRUE(ExecuteScript(root, script));
   EXPECT_TRUE(WaitForLoadStop(shell()->web_contents()));
 
   {
     // Back.
     FrameNavigateParamsCapturer capturer(root);
     shell()->web_contents()->GetController().GoBack();
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition,
+        capturer.transition(),
         ui::PageTransitionFromInt(ui::PAGE_TRANSITION_TYPED |
                                   ui::PAGE_TRANSITION_FORWARD_BACK |
                                   ui::PAGE_TRANSITION_FROM_ADDRESS_BAR)));
-    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.details().type);
-    EXPECT_TRUE(capturer.details().is_in_page);
+    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.type());
+    EXPECT_TRUE(capturer.is_in_page());
   }
 
   {
     // Forward.
     FrameNavigateParamsCapturer capturer(root);
     shell()->web_contents()->GetController().GoForward();
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition,
+        capturer.transition(),
         ui::PageTransitionFromInt(ui::PAGE_TRANSITION_LINK |
                                   ui::PAGE_TRANSITION_FORWARD_BACK)));
-    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.details().type);
-    EXPECT_TRUE(capturer.details().is_in_page);
+    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.type());
+    EXPECT_TRUE(capturer.is_in_page());
   }
 }
 
 // Verify that navigations for NAVIGATION_TYPE_SAME_PAGE are correctly
 // classified.
 IN_PROC_BROWSER_TEST_F(NavigationControllerBrowserTest,
                        NavigationTypeClassification_SamePage) {
   GURL url1(embedded_test_server()->GetURL(
       "/navigation_controller/simple_page_1.html"));
   EXPECT_TRUE(NavigateToURL(shell(), url1));
 
   FrameTreeNode* root =
       static_cast<WebContentsImpl*>(shell()->web_contents())->
           GetFrameTree()->root();
 
   {
     // Simple load.
     FrameNavigateParamsCapturer capturer(root);
     GURL frame_url(embedded_test_server()->GetURL(
         "/navigation_controller/simple_page_1.html"));
     NavigateFrameToURL(root, frame_url);
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition, ui::PAGE_TRANSITION_LINK));
-    EXPECT_EQ(NAVIGATION_TYPE_SAME_PAGE, capturer.details().type);
+        capturer.transition(), ui::PAGE_TRANSITION_LINK));
+    EXPECT_EQ(NAVIGATION_TYPE_SAME_PAGE, capturer.type());
   }
 }
 
 // Verify that reloading a page with url anchor scrolls to correct position.
 // Disabled due to flakiness: https://crbug.com/672545.
 IN_PROC_BROWSER_TEST_F(NavigationControllerBrowserTest,
                        DISABLED_ReloadWithUrlAnchor) {
   GURL url1(embedded_test_server()->GetURL(
       "/navigation_controller/reload-with-url-anchor.html#d2"));
   EXPECT_TRUE(NavigateToURL(shell(), url1));
@@ skipping 23 matching lines @@
       static_cast<WebContentsImpl*>(shell()->web_contents())->
           GetFrameTree()->root();
 
   {
     // Load an (invalid) empty GURL.  Blink will treat this as an inert commit,
     // but we don't want it to show up as SAME_PAGE.
     FrameNavigateParamsCapturer capturer(root);
     NavigateFrameToURL(root, GURL());
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition, ui::PAGE_TRANSITION_LINK));
-    EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, capturer.details().type);
+        capturer.transition(), ui::PAGE_TRANSITION_LINK));
+    EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, capturer.type());
   }
 }
 
 // Verify that navigations for NAVIGATION_TYPE_NEW_SUBFRAME and
 // NAVIGATION_TYPE_AUTO_SUBFRAME are properly classified.
 IN_PROC_BROWSER_TEST_F(NavigationControllerBrowserTest,
                        NavigationTypeClassification_NewAndAutoSubframe) {
   GURL main_url(embedded_test_server()->GetURL(
       "/navigation_controller/page_with_iframe.html"));
   EXPECT_TRUE(NavigateToURL(shell(), main_url));
@@ skipping 18 matching lines @@
   }
 
   {
     // Simple load.
     FrameNavigateParamsCapturer capturer(root->child_at(0));
     GURL frame_url(embedded_test_server()->GetURL(
         "/navigation_controller/simple_page_2.html"));
     NavigateFrameToURL(root->child_at(0), frame_url);
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition, ui::PAGE_TRANSITION_MANUAL_SUBFRAME));
-    EXPECT_EQ(NAVIGATION_TYPE_NEW_SUBFRAME, capturer.details().type);
+        capturer.transition(), ui::PAGE_TRANSITION_MANUAL_SUBFRAME));
+    EXPECT_EQ(NAVIGATION_TYPE_NEW_SUBFRAME, capturer.type());
   }
 
   {
     // Back.
     FrameNavigateParamsCapturer capturer(root->child_at(0));
     shell()->web_contents()->GetController().GoBack();
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition, ui::PAGE_TRANSITION_AUTO_SUBFRAME));
-    EXPECT_EQ(NAVIGATION_TYPE_AUTO_SUBFRAME, capturer.details().type);
+        capturer.transition(), ui::PAGE_TRANSITION_AUTO_SUBFRAME));
+    EXPECT_EQ(NAVIGATION_TYPE_AUTO_SUBFRAME, capturer.type());
   }
 
   {
     // Forward.
     FrameNavigateParamsCapturer capturer(root->child_at(0));
     shell()->web_contents()->GetController().GoForward();
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition, ui::PAGE_TRANSITION_AUTO_SUBFRAME));
-    EXPECT_EQ(NAVIGATION_TYPE_AUTO_SUBFRAME, capturer.details().type);
+        capturer.transition(), ui::PAGE_TRANSITION_AUTO_SUBFRAME));
+    EXPECT_EQ(NAVIGATION_TYPE_AUTO_SUBFRAME, capturer.type());
   }
 
   {
     // Simple load.
     FrameNavigateParamsCapturer capturer(root->child_at(0));
     GURL frame_url(embedded_test_server()->GetURL(
         "/navigation_controller/page_with_links.html"));
     NavigateFrameToURL(root->child_at(0), frame_url);
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition, ui::PAGE_TRANSITION_MANUAL_SUBFRAME));
-    EXPECT_EQ(NAVIGATION_TYPE_NEW_SUBFRAME, capturer.details().type);
+        capturer.transition(), ui::PAGE_TRANSITION_MANUAL_SUBFRAME));
+    EXPECT_EQ(NAVIGATION_TYPE_NEW_SUBFRAME, capturer.type());
   }
 
   {
     // Load via a fragment link click.
     FrameNavigateParamsCapturer capturer(root->child_at(0));
     std::string script = "document.getElementById('fraglink').click()";
     EXPECT_TRUE(ExecuteScript(root->child_at(0), script));
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition, ui::PAGE_TRANSITION_MANUAL_SUBFRAME));
-    EXPECT_EQ(NAVIGATION_TYPE_NEW_SUBFRAME, capturer.details().type);
+        capturer.transition(), ui::PAGE_TRANSITION_MANUAL_SUBFRAME));
+    EXPECT_EQ(NAVIGATION_TYPE_NEW_SUBFRAME, capturer.type());
   }
 
   {
     // location.assign().
     FrameNavigateParamsCapturer capturer(root->child_at(0));
     GURL frame_url(embedded_test_server()->GetURL(
         "/navigation_controller/simple_page_1.html"));
     std::string script = "location.assign('" + frame_url.spec() + "')";
     EXPECT_TRUE(ExecuteScript(root->child_at(0), script));
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition, ui::PAGE_TRANSITION_MANUAL_SUBFRAME));
-    EXPECT_EQ(NAVIGATION_TYPE_NEW_SUBFRAME, capturer.details().type);
+        capturer.transition(), ui::PAGE_TRANSITION_MANUAL_SUBFRAME));
+    EXPECT_EQ(NAVIGATION_TYPE_NEW_SUBFRAME, capturer.type());
   }
 
   {
     // location.replace().
     LoadCommittedCapturer capturer(root->child_at(0));
     GURL frame_url(embedded_test_server()->GetURL(
         "/navigation_controller/simple_page_2.html"));
     std::string script = "location.replace('" + frame_url.spec() + "')";
     EXPECT_TRUE(ExecuteScript(root->child_at(0), script));
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
         capturer.transition_type(), ui::PAGE_TRANSITION_AUTO_SUBFRAME));
   }
 
   {
     // history.pushState().
     FrameNavigateParamsCapturer capturer(root->child_at(0));
     std::string script =
         "history.pushState({}, 'page 1', 'simple_page_1.html')";
     EXPECT_TRUE(ExecuteScript(root->child_at(0), script));
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition, ui::PAGE_TRANSITION_MANUAL_SUBFRAME));
-    EXPECT_EQ(NAVIGATION_TYPE_NEW_SUBFRAME, capturer.details().type);
+        capturer.transition(), ui::PAGE_TRANSITION_MANUAL_SUBFRAME));
+    EXPECT_EQ(NAVIGATION_TYPE_NEW_SUBFRAME, capturer.type());
   }
 
   {
     // history.replaceState().
     LoadCommittedCapturer capturer(root->child_at(0));
     std::string script =
         "history.replaceState({}, 'page 2', 'simple_page_2.html')";
     EXPECT_TRUE(ExecuteScript(root->child_at(0), script));
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
@@ skipping 37 matching lines @@
 
   {
     // Load the redirecting page.
     FrameNavigateParamsCapturer capturer(root);
     capturer.set_navigations_remaining(2);
     GURL frame_url(embedded_test_server()->GetURL(
         "/navigation_controller/client_redirect.html"));
     NavigateFrameToURL(root, frame_url);
     capturer.Wait();
 
-    std::vector<FrameNavigateParams> params = capturer.all_params();
-    std::vector<LoadCommittedDetails> details = capturer.all_details();
-    ASSERT_EQ(2U, params.size());
-    ASSERT_EQ(2U, details.size());
+    ASSERT_EQ(2U, capturer.transitions().size());
+    ASSERT_EQ(2U, capturer.types().size());
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        params[0].transition, ui::PAGE_TRANSITION_LINK));
-    EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, details[0].type);
+        capturer.transitions()[0], ui::PAGE_TRANSITION_LINK));
+    EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, capturer.types()[0]);
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        params[1].transition,
+        capturer.transitions()[1],
         ui::PageTransitionFromInt(ui::PAGE_TRANSITION_LINK |
                                   ui::PAGE_TRANSITION_CLIENT_REDIRECT)));
-    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, details[1].type);
+    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.types()[1]);
   }
 }
 
 // Verify that the LoadCommittedDetails::is_in_page value is properly set for
 // non-IN_PAGE navigations. (It's tested for IN_PAGE navigations with the
 // NavigationTypeClassification_InPage test.)
 IN_PROC_BROWSER_TEST_F(NavigationControllerBrowserTest,
                        LoadCommittedDetails_IsInPage) {
   GURL links_url(embedded_test_server()->GetURL(
       "/navigation_controller/page_with_links.html"));
   EXPECT_TRUE(NavigateToURL(shell(), links_url));
   EXPECT_TRUE(WaitForLoadStop(shell()->web_contents()));
 
   FrameTreeNode* root =
       static_cast<WebContentsImpl*>(shell()->web_contents())->
           GetFrameTree()->root();
 
   {
     // Do a fragment link click.
     FrameNavigateParamsCapturer capturer(root);
     std::string script = "document.getElementById('fraglink').click()";
     EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition, ui::PAGE_TRANSITION_LINK));
-    EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, capturer.details().type);
-    EXPECT_TRUE(capturer.details().is_in_page);
+        capturer.transition(), ui::PAGE_TRANSITION_LINK));
+    EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, capturer.type());
+    EXPECT_TRUE(capturer.is_in_page());
   }
 
   {
     // Do a non-fragment link click.
     FrameNavigateParamsCapturer capturer(root);
     std::string script = "document.getElementById('thelink').click()";
     EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition, ui::PAGE_TRANSITION_LINK));
-    EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, capturer.details().type);
-    EXPECT_FALSE(capturer.details().is_in_page);
+        capturer.transition(), ui::PAGE_TRANSITION_LINK));
+    EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, capturer.type());
+    EXPECT_FALSE(capturer.is_in_page());
   }
 
   // Second verse, same as the first. (But in a subframe.)
 
   GURL iframe_url(embedded_test_server()->GetURL(
       "/navigation_controller/page_with_iframe.html"));
   EXPECT_TRUE(NavigateToURL(shell(), iframe_url));
 
   root = static_cast<WebContentsImpl*>(shell()->web_contents())->
       GetFrameTree()->root();
 
   ASSERT_EQ(1U, root->child_count());
   ASSERT_NE(nullptr, root->child_at(0));
 
   NavigateFrameToURL(root->child_at(0), links_url);
   EXPECT_TRUE(WaitForLoadStop(shell()->web_contents()));
 
   {
     // Do a fragment link click.
     FrameNavigateParamsCapturer capturer(root->child_at(0));
     std::string script = "document.getElementById('fraglink').click()";
     EXPECT_TRUE(ExecuteScript(root->child_at(0), script));
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition, ui::PAGE_TRANSITION_MANUAL_SUBFRAME));
-    EXPECT_EQ(NAVIGATION_TYPE_NEW_SUBFRAME, capturer.details().type);
-    EXPECT_TRUE(capturer.details().is_in_page);
+        capturer.transition(), ui::PAGE_TRANSITION_MANUAL_SUBFRAME));
+    EXPECT_EQ(NAVIGATION_TYPE_NEW_SUBFRAME, capturer.type());
+    EXPECT_TRUE(capturer.is_in_page());
   }
 
   {
     // Do a non-fragment link click.
     FrameNavigateParamsCapturer capturer(root->child_at(0));
     std::string script = "document.getElementById('thelink').click()";
     EXPECT_TRUE(ExecuteScript(root->child_at(0), script));
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition, ui::PAGE_TRANSITION_MANUAL_SUBFRAME));
-    EXPECT_EQ(NAVIGATION_TYPE_NEW_SUBFRAME, capturer.details().type);
-    EXPECT_FALSE(capturer.details().is_in_page);
+        capturer.transition(), ui::PAGE_TRANSITION_MANUAL_SUBFRAME));
+    EXPECT_EQ(NAVIGATION_TYPE_NEW_SUBFRAME, capturer.type());
+    EXPECT_FALSE(capturer.is_in_page());
   }
 }
 
 // Verify the tree of FrameNavigationEntries after initial about:blank commits
 // in subframes, which should not count as real committed loads.
 IN_PROC_BROWSER_TEST_F(NavigationControllerBrowserTest,
                        FrameNavigationEntry_BlankAutoSubframe) {
   GURL about_blank_url(url::kAboutBlankURL);
   GURL main_url(embedded_test_server()->GetURL(
       "/navigation_controller/simple_page_1.html"));
@@ skipping 262 matching lines @@
   FrameTreeNode* root = static_cast<WebContentsImpl*>(shell()->web_contents())
                             ->GetFrameTree()
                             ->root();
 
   // 1. Navigate in-page.
   {
     FrameNavigateParamsCapturer capturer(root);
     std::string script = "history.pushState({}, 'foo', 'foo')";
     EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
-    EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, capturer.details().type);
-    EXPECT_TRUE(capturer.details().is_in_page);
+    EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, capturer.type());
+    EXPECT_TRUE(capturer.is_in_page());
   }
 
   // 2. Create an iframe.
   GURL child_url(embedded_test_server()->GetURL(
       "/navigation_controller/simple_page_2.html"));
   {
     LoadCommittedCapturer capturer(shell()->web_contents());
     std::string script = "var iframe = document.createElement('iframe');"
                          "iframe.src = '" + child_url.spec() + "';"
                          "document.body.appendChild(iframe);";
@@ skipping 270 matching lines @@
   NavigationEntryImpl* entry = controller.GetLastCommittedEntry();
 
   // 2. Navigate in the subframe same-site.
   GURL frame_url2(embedded_test_server()->GetURL(
       "/navigation_controller/page_with_links.html"));
   {
     FrameNavigateParamsCapturer capturer(root->child_at(0));
     NavigateFrameToURL(root->child_at(0), frame_url2);
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition, ui::PAGE_TRANSITION_MANUAL_SUBFRAME));
-    EXPECT_EQ(NAVIGATION_TYPE_NEW_SUBFRAME, capturer.details().type);
+        capturer.transition(), ui::PAGE_TRANSITION_MANUAL_SUBFRAME));
+    EXPECT_EQ(NAVIGATION_TYPE_NEW_SUBFRAME, capturer.type());
   }
 
   // We should have created a new NavigationEntry with the same main frame URL.
   EXPECT_EQ(2, controller.GetEntryCount());
   EXPECT_EQ(1, controller.GetLastCommittedEntryIndex());
   NavigationEntryImpl* entry2 = controller.GetLastCommittedEntry();
   EXPECT_NE(entry, entry2);
   EXPECT_EQ(main_url, entry2->GetURL());
   FrameNavigationEntry* root_entry2 = entry2->root_node()->frame_entry.get();
   EXPECT_EQ(main_url, root_entry2->url());
@@ skipping 29 matching lines @@
   {
     FrameNavigateParamsCapturer capturer(root->child_at(1)->child_at(0));
     RenderFrameDeletedObserver deleted_observer(
         root->child_at(1)->child_at(0)->current_frame_host());
     NavigateFrameToURL(root->child_at(1)->child_at(0), bar_url);
     // Wait for the RenderFrame to go away, if this will be cross-process.
     if (AreAllSitesIsolatedForTesting())
       deleted_observer.WaitUntilDeleted();
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition, ui::PAGE_TRANSITION_MANUAL_SUBFRAME));
-    EXPECT_EQ(NAVIGATION_TYPE_NEW_SUBFRAME, capturer.details().type);
+        capturer.transition(), ui::PAGE_TRANSITION_MANUAL_SUBFRAME));
+    EXPECT_EQ(NAVIGATION_TYPE_NEW_SUBFRAME, capturer.type());
   }
 
   // We should have created a new NavigationEntry with the same main frame URL.
   EXPECT_EQ(3, controller.GetEntryCount());
   EXPECT_EQ(2, controller.GetLastCommittedEntryIndex());
   NavigationEntryImpl* entry3 = controller.GetLastCommittedEntry();
   EXPECT_NE(entry, entry3);
   EXPECT_EQ(main_url, entry3->GetURL());
   FrameNavigationEntry* root_entry3 = entry3->root_node()->frame_entry.get();
   EXPECT_EQ(main_url, root_entry3->url());
@@ skipping 14 matching lines @@
     RenderFrameDeletedObserver deleted_observer(
         root->child_at(1)->current_frame_host());
     std::string script = "var frames = document.getElementsByTagName('iframe');"
                          "frames[1].src = '" + baz_url.spec() + "';";
     EXPECT_TRUE(ExecuteScript(root, script));
     // Wait for the RenderFrame to go away, if this will be cross-process.
     if (AreAllSitesIsolatedForTesting())
       deleted_observer.WaitUntilDeleted();
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition, ui::PAGE_TRANSITION_MANUAL_SUBFRAME));
-    EXPECT_EQ(NAVIGATION_TYPE_NEW_SUBFRAME, capturer.details().type);
+        capturer.transition(), ui::PAGE_TRANSITION_MANUAL_SUBFRAME));
+    EXPECT_EQ(NAVIGATION_TYPE_NEW_SUBFRAME, capturer.type());
   }
 
   // We should have created a new NavigationEntry with the same main frame URL.
   EXPECT_EQ(4, controller.GetEntryCount());
   EXPECT_EQ(3, controller.GetLastCommittedEntryIndex());
   NavigationEntryImpl* entry4 = controller.GetLastCommittedEntry();
   EXPECT_NE(entry, entry4);
   EXPECT_EQ(main_url, entry4->GetURL());
   FrameNavigationEntry* root_entry4 = entry4->root_node()->frame_entry.get();
   EXPECT_EQ(main_url, root_entry4->url());
@@ skipping 128 matching lines @@
   EXPECT_EQ(3, controller.GetEntryCount());
   EXPECT_EQ(2, controller.GetLastCommittedEntryIndex());
   NavigationEntryImpl* entry3 = controller.GetLastCommittedEntry();
 
   // 4. Go back in the subframe.
   {
     FrameNavigateParamsCapturer capturer(root->child_at(0));
     shell()->web_contents()->GetController().GoBack();
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition, ui::PAGE_TRANSITION_AUTO_SUBFRAME));
-    EXPECT_EQ(NAVIGATION_TYPE_AUTO_SUBFRAME, capturer.details().type);
+        capturer.transition(), ui::PAGE_TRANSITION_AUTO_SUBFRAME));
+    EXPECT_EQ(NAVIGATION_TYPE_AUTO_SUBFRAME, capturer.type());
   }
   EXPECT_EQ(3, controller.GetEntryCount());
   EXPECT_EQ(1, controller.GetLastCommittedEntryIndex());
   EXPECT_EQ(entry2, controller.GetLastCommittedEntry());
 
   // The entry should have a FrameNavigationEntry for the subframe.
   ASSERT_EQ(1U, entry2->root_node()->children.size());
   EXPECT_EQ(frame_url2, entry2->root_node()->children[0]->frame_entry->url());
 
   // 5. Go back in the subframe again to the parent page's site.
   {
     FrameNavigateParamsCapturer capturer(root->child_at(0));
     shell()->web_contents()->GetController().GoBack();
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition, ui::PAGE_TRANSITION_AUTO_SUBFRAME));
-    EXPECT_EQ(NAVIGATION_TYPE_AUTO_SUBFRAME, capturer.details().type);
+        capturer.transition(), ui::PAGE_TRANSITION_AUTO_SUBFRAME));
+    EXPECT_EQ(NAVIGATION_TYPE_AUTO_SUBFRAME, capturer.type());
   }
   EXPECT_EQ(3, controller.GetEntryCount());
   EXPECT_EQ(0, controller.GetLastCommittedEntryIndex());
   EXPECT_EQ(entry1, controller.GetLastCommittedEntry());
 
   // The entry should have a FrameNavigationEntry for the subframe.
   ASSERT_EQ(1U, entry1->root_node()->children.size());
   EXPECT_EQ(frame_url, entry1->root_node()->children[0]->frame_entry->url());
 
   // 6. Go forward in the subframe cross-site.
   {
     FrameNavigateParamsCapturer capturer(root->child_at(0));
     shell()->web_contents()->GetController().GoForward();
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition, ui::PAGE_TRANSITION_AUTO_SUBFRAME));
-    EXPECT_EQ(NAVIGATION_TYPE_AUTO_SUBFRAME, capturer.details().type);
+        capturer.transition(), ui::PAGE_TRANSITION_AUTO_SUBFRAME));
+    EXPECT_EQ(NAVIGATION_TYPE_AUTO_SUBFRAME, capturer.type());
   }
   EXPECT_EQ(3, controller.GetEntryCount());
   EXPECT_EQ(1, controller.GetLastCommittedEntryIndex());
   EXPECT_EQ(entry2, controller.GetLastCommittedEntry());
 
   // The entry should have a FrameNavigationEntry for the subframe.
   ASSERT_EQ(1U, entry2->root_node()->children.size());
   EXPECT_EQ(frame_url2, entry2->root_node()->children[0]->frame_entry->url());
 
   // 7. Go forward in the subframe again, cross-site.
   {
     FrameNavigateParamsCapturer capturer(root->child_at(0));
     shell()->web_contents()->GetController().GoForward();
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition, ui::PAGE_TRANSITION_AUTO_SUBFRAME));
-    EXPECT_EQ(NAVIGATION_TYPE_AUTO_SUBFRAME, capturer.details().type);
+        capturer.transition(), ui::PAGE_TRANSITION_AUTO_SUBFRAME));
+    EXPECT_EQ(NAVIGATION_TYPE_AUTO_SUBFRAME, capturer.type());
   }
   EXPECT_EQ(3, controller.GetEntryCount());
   EXPECT_EQ(2, controller.GetLastCommittedEntryIndex());
   EXPECT_EQ(entry3, controller.GetLastCommittedEntry());
 
   // The entry should have a FrameNavigationEntry for the subframe.
   ASSERT_EQ(1U, entry3->root_node()->children.size());
   EXPECT_EQ(frame_url3, entry3->root_node()->children[0]->frame_entry->url());
 }
 
@@ skipping 1535 matching lines @@
   FrameNavigationEntry* subframe_entry =
       controller.GetLastCommittedEntry()->GetFrameEntry(subframe);
   EXPECT_EQ(frame_url, subframe_entry->url());
 
   // 3. Reload the main frame.
   {
     FrameNavigateParamsCapturer capturer(root);
     controller.Reload(ReloadType::NORMAL, false);
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition, ui::PAGE_TRANSITION_RELOAD));
-    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.details().type);
-    EXPECT_FALSE(capturer.details().is_in_page);
+        capturer.transition(), ui::PAGE_TRANSITION_RELOAD));
+    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.type());
+    EXPECT_FALSE(capturer.is_in_page());
   }
 
   // 4. Add the iframe again.
   {
     LoadCommittedCapturer capturer(shell()->web_contents());
     EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
         capturer.transition_type(), ui::PAGE_TRANSITION_AUTO_SUBFRAME));
   }
@@ skipping 303 matching lines @@
     // Now the existing page uses history.replaceState().
     FrameNavigateParamsCapturer capturer(root);
     capturer.set_wait_for_load(false);
     std::string script =
         "history.replaceState({}, '', '" + replace_state_filename + "')";
     EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
 
     // The fact that there was a pending entry shouldn't interfere with the
     // classification.
-    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.details().type);
-    EXPECT_TRUE(capturer.details().is_in_page);
+    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.type());
+    EXPECT_TRUE(capturer.is_in_page());
   }
 
   ResourceDispatcherHost::Get()->SetDelegate(nullptr);
 }
 
 }  // namespace
 
 IN_PROC_BROWSER_TEST_F(
     NavigationControllerBrowserTest,
     NavigationTypeClassification_On1InPageToXWhile2Pending) {
@@ skipping 64 matching lines @@
   EXPECT_EQ(entry_count, controller.GetEntryCount());
 
   {
     // Now the existing page uses history.pushState() while the pending entry
     // for the other navigation still exists.
     FrameNavigateParamsCapturer capturer(root);
     capturer.set_wait_for_load(false);
     std::string script = "history.pushState({}, '', 'pushed')";
     EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
-    EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, capturer.details().type);
-    EXPECT_TRUE(capturer.details().is_in_page);
+    EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, capturer.type());
+    EXPECT_TRUE(capturer.is_in_page());
   }
 
   // The in-page navigation should not have replaced the previous entry.
   GURL push_state_url(
       embedded_test_server()->GetURL("/navigation_controller/pushed"));
   EXPECT_EQ(entry_count + 1, controller.GetEntryCount());
   EXPECT_EQ(push_state_url, controller.GetLastCommittedEntry()->GetURL());
   EXPECT_EQ(start_url, controller.GetEntryAtIndex(0)->GetURL());
 
   ResourceDispatcherHost::Get()->SetDelegate(nullptr);
@@ skipping 59 matching lines @@
   ASSERT_EQ(1U, root->child_count());
   ASSERT_NE(nullptr, root->child_at(0));
 
   {
     // Navigate in the iframe.
     FrameNavigateParamsCapturer capturer(root->child_at(0));
     GURL frame_url(embedded_test_server()->GetURL(
         "/navigation_controller/simple_page_2.html"));
     NavigateFrameToURL(root->child_at(0), frame_url);
     capturer.Wait();
-    EXPECT_EQ(NAVIGATION_TYPE_NEW_SUBFRAME, capturer.details().type);
+    EXPECT_EQ(NAVIGATION_TYPE_NEW_SUBFRAME, capturer.type());
   }
 
   {
     // Go back in the iframe.
     TestNavigationObserver back_load_observer(shell()->web_contents());
     shell()->web_contents()->GetController().GoBack();
     back_load_observer.Wait();
   }
 
   {
@@ skipping 76 matching lines @@
   ASSERT_EQ(1U, root->child_count());
   ASSERT_NE(nullptr, root->child_at(0));
 
   {
     // Navigate in the iframe.
     FrameNavigateParamsCapturer capturer(root->child_at(0));
     GURL frame_url(embedded_test_server()->GetURL(
         "/navigation_controller/simple_page_2.html"));
     NavigateFrameToURL(root->child_at(0), frame_url);
     capturer.Wait();
-    EXPECT_EQ(NAVIGATION_TYPE_NEW_SUBFRAME, capturer.details().type);
+    EXPECT_EQ(NAVIGATION_TYPE_NEW_SUBFRAME, capturer.type());
   }
 
   {
     // history.replaceState().
     FrameNavigateParamsCapturer capturer(root);
     std::string script =
         "history.replaceState({}, 'replaced', 'replaced')";
     EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
   }
@@ skipping 134 matching lines @@
 
   // Redirect so that we can use Reload with ReloadType::ORIGINAL_REQUEST_URL.
   GURL redirect_url(embedded_test_server()->GetURL(
       "foo.com", "/navigation_controller/simple_page_1.html"));
   {
     std::string script = "location.replace('" + redirect_url.spec() + "');";
     FrameNavigateParamsCapturer capturer(root);
     EXPECT_TRUE(ExecuteScript(shell(), script));
     capturer.Wait();
     EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
-        capturer.params().transition,
+        capturer.transition(),
         ui::PageTransitionFromInt(ui::PAGE_TRANSITION_LINK |
                                   ui::PAGE_TRANSITION_CLIENT_REDIRECT)));
-    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.details().type);
+    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.type());
   }
 
   // Modify an entry in the session history and reload the original request.
   {
     // We first send a replaceState() to the renderer, which will cause the
     // renderer to send back a DidCommitProvisionalLoad. Immediately after,
     // we send a Reload request with ReloadType::ORIGINAL_REQUEST_URL (which in
     // this case is a different origin) and will also cause the renderer to
     // commit the frame. In the end we verify that both navigations committed
     // and that the URLs are correct.
     std::string script = "history.replaceState({}, '', 'foo');";
     root->render_manager()
         ->current_frame_host()
         ->ExecuteJavaScriptWithUserGestureForTests(base::UTF8ToUTF16(script));
     EXPECT_FALSE(shell()->web_contents()->IsLoading());
     shell()->web_contents()->GetController().Reload(
         ReloadType::ORIGINAL_REQUEST_URL, false);
     EXPECT_TRUE(shell()->web_contents()->IsLoading());
     EXPECT_EQ(redirect_url, shell()->web_contents()->GetLastCommittedURL());
 
     // Wait until there's no more navigations.
     GURL modified_url(embedded_test_server()->GetURL(
         "foo.com", "/navigation_controller/foo"));
     FrameNavigateParamsCapturer capturer(root);
     capturer.set_wait_for_load(false);
     capturer.set_navigations_remaining(2);
     capturer.Wait();
-    EXPECT_EQ(2U, capturer.all_details().size());
-    EXPECT_EQ(modified_url, capturer.all_params()[0].url);
-    EXPECT_EQ(original_url, capturer.all_params()[1].url);
+    EXPECT_EQ(2U, capturer.urls().size());
+    EXPECT_EQ(modified_url, capturer.urls()[0]);
+    EXPECT_EQ(original_url, capturer.urls()[1]);
     EXPECT_EQ(original_url, shell()->web_contents()->GetLastCommittedURL());
   }
 
   // Make sure the renderer is still alive.
   EXPECT_TRUE(ExecuteScript(shell(), "console.log('Success');"));
 }
 
 // This test shows that the initial "about:blank" URL is elided from the
 // navigation history of a subframe when it is loaded.
 //
@@ skipping 1424 matching lines @@
   // OnMessageReceived function; this is the simplest way to disambiguate.
   class : public WebContentsObserver {
    public:
     using Callback = base::Callback<bool()>;
 
     using WebContentsObserver::Observe;
 
     void SetCallback(Callback callback) { callback_ = callback; }
 
    private:
-    void DidNavigateAnyFrame(RenderFrameHost* render_frame_host,
-                             const LoadCommittedDetails& details,
-                             const FrameNavigateParams& params) override {
+    void DidFinishNavigation(NavigationHandle* navigation_handle) override {
       DCHECK_CURRENTLY_ON(BrowserThread::UI);
+      if (!navigation_handle->HasCommitted())
+        return;
 
       // Resume the message.
       callback_.Run();
     }
 
     Callback callback_;
   } web_contents_observer_;
 
   RenderFrameHost* render_frame_host_;
 
@@ skipping 401 matching lines @@
   NavigationHandleCommitObserver handle_observer(shell()->web_contents(),
                                                  kFragmentURL);
   EXPECT_TRUE(NavigateToURL(shell(), kFragmentURL));
 
   EXPECT_TRUE(handle_observer.has_committed());
   EXPECT_TRUE(handle_observer.was_same_page());
   EXPECT_FALSE(handle_observer.was_renderer_initiated());
 }
 
 }  // namespace content