Try to test a theoretical problem:

content/browser/web_contents/web_contents_impl_browsertest.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 "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "content/browser/frame_host/navigation_entry_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/browser/web_contents/web_contents_view.h"
 #include "content/common/frame_messages.h"
@@ skipping 466 matching lines @@
                             "a.click();"));
   WebContents* new_web_contents = new_web_contents_observer.GetWebContents();
   WaitForLoadStop(new_web_contents);
   EXPECT_TRUE(new_web_contents_observer.RenderViewCreatedCalled());
 }
 
 struct LoadProgressDelegateAndObserver : public WebContentsDelegate,
                                          public WebContentsObserver {
   LoadProgressDelegateAndObserver(Shell* shell)
       : WebContentsObserver(shell->web_contents()),
+        subframe_rfh(nullptr),
         did_start_loading(false),
         did_stop_loading(false) {
     web_contents()->SetDelegate(this);
   }
 
   // WebContentsDelegate:
   void LoadProgressChanged(WebContents* source, double progress) override {
+    DLOG(INFO) << "LoadProgressChanged";
     EXPECT_TRUE(did_start_loading);
     EXPECT_FALSE(did_stop_loading);
     progresses.push_back(progress);
   }
 
   // WebContentsObserver:
   void DidStartLoading(RenderViewHost* render_view_host) override {
+    DLOG(INFO) << "DidStartLoading for " << render_view_host->GetSiteInstance()->GetSiteURL();
     EXPECT_FALSE(did_start_loading);
     EXPECT_EQ(0U, progresses.size());
     EXPECT_FALSE(did_stop_loading);
     did_start_loading = true;
+
+    // TODO(creis): Replace with a callback with a setter function.
+    if (subframe_rfh) {
+      DLOG(INFO) << "Forcing a stale DidStartLoading for " << subframe_rfh->GetSiteInstance()->GetSiteURL();
+      // Before the new navigation has a chance to commit, simulate a
+      // DidStartLoading IPC from the old subframe RFH.
+      FrameHostMsg_DidStartLoading subframe_start_msg(
+          subframe_rfh->GetRoutingID(), true);
+      static_cast<WebContentsImpl*>(web_contents())->OnMessageReceived(
+          subframe_rfh, subframe_start_msg);
+
+      // Also simulate a DidChangeLoadProgress, but not a DidStopLoading.
+      FrameHostMsg_DidChangeLoadProgress progress_msg(
+          subframe_rfh->GetRoutingID(), 1.0);
+      static_cast<WebContentsImpl*>(web_contents())->OnMessageReceived(
+          subframe_rfh, progress_msg);
+
+      // Only do this once.
+      subframe_rfh = nullptr;
+    }
   }
 
   void DidStopLoading(RenderViewHost* render_view_host) override {
     EXPECT_TRUE(did_start_loading);
     EXPECT_GE(progresses.size(), 1U);
     EXPECT_FALSE(did_stop_loading);
     did_stop_loading = true;
   }
 
+  // TODO(creis): Replace with a Callback.
+  RenderFrameHost* subframe_rfh;
   bool did_start_loading;
   std::vector<double> progresses;
   bool did_stop_loading;
 };
 
 IN_PROC_BROWSER_TEST_F(WebContentsImplBrowserTest, LoadProgress) {
   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
   scoped_ptr<LoadProgressDelegateAndObserver> delegate(
       new LoadProgressDelegateAndObserver(shell()));
 
@@ skipping 69 matching lines @@
   TestNavigationObserver tab_observer(shell()->web_contents(), 1);
   GURL url(embedded_test_server()->GetURL("foo.com", "/title2.html"));
   shell()->LoadURL(url);
   tab_observer.Wait();
   EXPECT_EQ(url, shell()->web_contents()->GetLastCommittedURL());
 
   // We should have gotten to DidStopLoading.
   EXPECT_TRUE(delegate->did_stop_loading);
 }
 
+// Ensure that a new navigation that interrupts a pending one will still fire
+// a DidStopLoading.  See http://crbug.com/429399.
+IN_PROC_BROWSER_TEST_F(WebContentsImplBrowserTest,
+                       LoadProgressAfterStaleDidStart) {
+  host_resolver()->AddRule("*", "127.0.0.1");
+  ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
+
+  // Start at a real page with a subframe.
+  DLOG(INFO) << "First nav";
+  NavigateToURL(shell(), embedded_test_server()->GetURL(
+      "/frame_tree/page_with_one_frame.html"));
+  FrameTree* frame_tree =
+      static_cast<WebContentsImpl*>(shell()->web_contents())->GetFrameTree();
+  ASSERT_EQ(1U, frame_tree->root()->child_count());
+  RenderFrameHost* subframe_rfh =
+      frame_tree->root()->child_at(0)->current_frame_host();
+
+  scoped_ptr<LoadProgressDelegateAndObserver> delegate(
+      new LoadProgressDelegateAndObserver(shell()));
+
+  // Now start a new cross-process navigation.
+  TestNavigationObserver tab_observer(shell()->web_contents(), 1);
+  GURL url(embedded_test_server()->GetURL("foo.com", "/title2.html"));
+  DLOG(INFO) << "Second nav to " << url;
+  shell()->LoadURL(url);
+
+  // Do this after the fake DidStartLoading in RFH::Navigate, so that it runs
+  // when the real DidStartLoading arrives from the old renderer.
+  delegate->subframe_rfh = subframe_rfh;
+
+  // The fake subframe DidStartLoading should have incremented
+  // loading_frames_in_progress_...
+
+  // Now complete the new navigation.
+  tab_observer.Wait();
+  EXPECT_EQ(url, shell()->web_contents()->GetLastCommittedURL());
+
+  // We should have gotten to DidStopLoading.
+  EXPECT_TRUE(delegate->did_stop_loading);
+}
+
 struct FirstVisuallyNonEmptyPaintObserver : public WebContentsObserver {
   FirstVisuallyNonEmptyPaintObserver(Shell* shell)
       : WebContentsObserver(shell->web_contents()),
         did_fist_visually_non_empty_paint_(false) {}
 
   void DidFirstVisuallyNonEmptyPaint() override {
     did_fist_visually_non_empty_paint_ = true;
     on_did_first_visually_non_empty_paint_.Run();
   }
 
@@ skipping 23 matching lines @@
       new FirstVisuallyNonEmptyPaintObserver(shell()));
 
   NavigateToURL(shell(), embedded_test_server()->GetURL("/title1.html"));
 
   observer->WaitForDidFirstVisuallyNonEmptyPaint();
   ASSERT_TRUE(observer->did_fist_visually_non_empty_paint_);
 }
 
 }  // namespace content