Fix ClassifyNavigation.

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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/strings/stringprintf.h"
 #include "content/browser/frame_host/frame_navigation_entry.h"
 #include "content/browser/frame_host/frame_tree.h"
 #include "content/browser/frame_host/navigation_controller_impl.h"
 #include "content/browser/frame_host/navigation_entry_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/public/browser/render_view_host.h"
+#include "content/public/browser/resource_controller.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_observer.h"
 #include "content/public/common/bindings_policy.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/content_browser_test.h"
 #include "content/public/test/content_browser_test_utils.h"
 #include "content/public/test/test_navigation_observer.h"
 #include "content/public/test/test_utils.h"
@@ skipping 218 matching lines @@
 namespace {
 
 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];
   }
 
   const std::vector<FrameNavigateParams>& all_params() const {
@@ skipping 14 matching lines @@
                            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_)
       return;
 
     --navigations_remaining_;
     params_.push_back(params);
     details_.push_back(details);
-    if (!web_contents()->IsLoading() && !navigations_remaining_)
+    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_;
 
   // The MessageLoopRunner used to spin the message loop.
   scoped_refptr<MessageLoopRunner> message_loop_runner_;
 };
 
@@ skipping 611 matching lines @@
     ASSERT_EQ(2U, params.size());
     ASSERT_EQ(2U, details.size());
     EXPECT_EQ(ui::PAGE_TRANSITION_LINK, params[0].transition);
     EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, details[0].type);
     EXPECT_EQ(ui::PAGE_TRANSITION_LINK | ui::PAGE_TRANSITION_CLIENT_REDIRECT,
               params[1].transition);
     EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, details[1].type);
   }
 }
 
-
 // Verify the tree of FrameNavigationEntries after NAVIGATION_TYPE_AUTO_SUBFRAME
 // commits.
 // TODO(creis): Test cross-site and nested iframes.
 // TODO(creis): Test updating entries for history auto subframe navigations.
 IN_PROC_BROWSER_TEST_F(NavigationControllerBrowserTest,
                        FrameNavigationEntry_AutoSubframe) {
   GURL main_url(embedded_test_server()->GetURL(
       "/navigation_controller/simple_page_1.html"));
   NavigateToURL(shell(), main_url);
   const NavigationControllerImpl& controller =
@@ skipping 30 matching lines @@
     ASSERT_EQ(1U, entry->root_node()->children.size());
     FrameNavigationEntry* frame_entry =
         entry->root_node()->children[0]->frame_entry.get();
     EXPECT_EQ(frame_url, frame_entry->url());
   } else {
     // There are no subframe FrameNavigationEntries by default.
     EXPECT_EQ(0U, entry->root_node()->children.size());
   }
 }
 
+namespace {
+
+class HttpThrottle : public ResourceThrottle {
+ public:
+  // ResourceThrottle
+  void WillStartRequest(bool* defer) override {
+    *defer = true;
+  }
+
+  const char* GetNameForLogging() const override {
+    return "HttpThrottle";
+  }
+};
+
+class StallDelegate : public ResourceDispatcherHostDelegate {

[Charlie Reis, 2015/04/15 17:43:08]

FYI for Nasko, since he was writing a more general version of this, but it
hasn't landed yet.  We can simplify this case once it lands.

+  // ResourceDispatcherHostDelegate
+  void RequestBeginning(
+      net::URLRequest* request,
+      content::ResourceContext* resource_context,
+      content::AppCacheService* appcache_service,
+      ResourceType resource_type,
+      ScopedVector<content::ResourceThrottle>* throttles) override {
+    DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+    throttles->push_back(new HttpThrottle);
+  }
+};
+
+}  // namespace
+
+IN_PROC_BROWSER_TEST_F(NavigationControllerBrowserTest,
+                       NavigationTypeClassification_InPageWhilePending) {
+  NavigationControllerImpl& controller =
+      static_cast<NavigationControllerImpl&>(
+          shell()->web_contents()->GetController());
+
+  FrameTreeNode* root =
+      static_cast<WebContentsImpl*>(shell()->web_contents())->
+          GetFrameTree()->root();
+
+  // Start with a normal page.
+  GURL url1(embedded_test_server()->GetURL(
+      "/navigation_controller/simple_page_1.html"));
+  EXPECT_TRUE(NavigateToURL(shell(), url1));
+
+  // Have the user decide to go to a different page which is very slow.
+  StallDelegate stall_delegate;
+  ResourceDispatcherHost::Get()->SetDelegate(&stall_delegate);
+  GURL url2(embedded_test_server()->GetURL(
+      "/navigation_controller/simple_page_2.html"));
+  controller.LoadURL(url2, Referrer(), ui::PAGE_TRANSITION_LINK, std::string());
+
+  // That should be the pending entry.
+  NavigationEntryImpl* entry = controller.GetPendingEntry();
+  ASSERT_NE(nullptr, entry);
+  EXPECT_EQ(url2, entry->GetURL());
+
+  {
+    // Now the existing page uses history.replaceState().
+    FrameNavigateParamsCapturer capturer(root);
+    capturer.set_wait_for_load(false);
+    EXPECT_TRUE(content::ExecuteScript(root->current_frame_host(),
+                                       "history.replaceState({}, '', 'x')"));
+    capturer.Wait();
+
+    // The fact that there was a pending entry shouldn't interfere with the
+    // classification.
+    EXPECT_EQ(NAVIGATION_TYPE_IN_PAGE, capturer.details().type);
+  }
+
+  ResourceDispatcherHost::Get()->SetDelegate(nullptr);
+}
+
 }  // namespace content