WebContentsObserver::RenderFrameCreated should be called for every RenderFrameHost.

content/browser/frame_host/render_frame_host_manager_unittest.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/files/file_path.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/frame_host/cross_site_transferring_request.h"
 #include "content/browser/frame_host/navigation_controller_impl.h"
 #include "content/browser/frame_host/navigation_entry_impl.h"
 #include "content/browser/frame_host/navigator.h"
@@ skipping 106 matching lines @@
   }
 
  private:
   int process_id_;
   int routing_id_;
   bool deleted_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderViewHostDeletedObserver);
 };
 
-
-// This observer keeps track of the last deleted RenderViewHost to avoid
+// This observer keeps track of the last deleted RenderFrameHost to avoid
 // accessing it and causing use-after-free condition.
 class RenderFrameHostDeletedObserver : public WebContentsObserver {
  public:
   RenderFrameHostDeletedObserver(RenderFrameHost* rfh)
       : WebContentsObserver(WebContents::FromRenderFrameHost(rfh)),
         process_id_(rfh->GetProcess()->GetID()),
         routing_id_(rfh->GetRoutingID()),
         deleted_(false) {
   }
 
@@ skipping 47 matching lines @@
     return favicon_received_;
   }
 
  private:
   bool plugin_crashed_;
   bool favicon_received_;
 
   DISALLOW_COPY_AND_ASSIGN(PluginFaviconMessageObserver);
 };
 
+// Ensures that RenderFrameDeleted and RenderFrameCreated are called in a
+// consistent manner.
+class FrameLifetimeConsistencyChecker : public WebContentsObserver {
+ public:
+  explicit FrameLifetimeConsistencyChecker(WebContentsImpl* web_contents)
+      : WebContentsObserver(web_contents) {
+    RenderViewCreated(web_contents->GetRenderViewHost());
+    RenderFrameCreated(web_contents->GetMainFrame());
+  }
+
+  virtual void RenderFrameCreated(RenderFrameHost* render_frame_host) OVERRIDE {
+    std::pair<int, int> routing_pair =
+        std::make_pair(render_frame_host->GetProcess()->GetID(),
+                       render_frame_host->GetRoutingID());
+    bool was_live_already = !live_routes_.insert(routing_pair).second;
+    bool was_used_before = deleted_routes_.count(routing_pair) != 0;
+
+    if (was_live_already) {
+      FAIL() << "RenderFrameCreated called more than once for routing pair: "
+             << Format(render_frame_host);
+    } else if (was_used_before) {
+      FAIL() << "RenderFrameCreated called for routing pair "
+             << Format(render_frame_host) << " that was previously deleted.";
+    }
+  }
+
+  virtual void RenderFrameDeleted(RenderFrameHost* render_frame_host) OVERRIDE {
+    std::pair<int, int> routing_pair =
+        std::make_pair(render_frame_host->GetProcess()->GetID(),
+                       render_frame_host->GetRoutingID());
+    bool was_live = live_routes_.erase(routing_pair);
+    bool was_dead_already = !deleted_routes_.insert(routing_pair).second;
+
+    if (was_dead_already) {
+      FAIL() << "RenderFrameDeleted called more than once for routing pair "
+             << Format(render_frame_host);
+    } else if (!was_live) {
+      FAIL() << "RenderFrameDeleted called for routing pair "
+             << Format(render_frame_host)
+             << " for which RenderFrameCreated was never called";
+    }
+  }
+
+ private:
+  std::string Format(RenderFrameHost* render_frame_host) {
+    return base::StringPrintf(
+        "(%d, %d -> %s )",
+        render_frame_host->GetProcess()->GetID(),
+        render_frame_host->GetRoutingID(),
+        render_frame_host->GetSiteInstance()->GetSiteURL().spec().c_str());
+  }
+  std::set<std::pair<int, int> > live_routes_;
+  std::set<std::pair<int, int> > deleted_routes_;
+};
 
 }  // namespace
 
 class RenderFrameHostManagerTest
     : public RenderViewHostImplTestHarness {
  public:
   virtual void SetUp() OVERRIDE {
     RenderViewHostImplTestHarness::SetUp();
     WebUIControllerFactory::RegisterFactory(&factory_);
+    lifetime_checker_.reset(new FrameLifetimeConsistencyChecker(contents()));
   }
 
   virtual void TearDown() OVERRIDE {
+    lifetime_checker_.reset();
     RenderViewHostImplTestHarness::TearDown();
     WebUIControllerFactory::UnregisterFactoryForTesting(&factory_);
   }
 
   void set_should_create_webui(bool should_create_webui) {
     factory_.set_should_create_webui(should_create_webui);
   }
 
   void StartCrossSiteTransition(TestWebContents* contents) {
     std::vector<GURL> url_chain;
@@ skipping 85 matching lines @@
 
     dest_rvh->SendNavigate(101, kDestUrl);
     ntp_rvh->OnSwappedOut(false);
 
     EXPECT_TRUE(ntp_rvh->IsSwappedOut());
     return ntp_rvh;
   }
 
  private:
   RenderFrameHostManagerTestWebUIControllerFactory factory_;
+  scoped_ptr<FrameLifetimeConsistencyChecker> lifetime_checker_;
 };
 
 // Tests that when you navigate from a chrome:// url to another page, and
 // then do that same thing in another tab, that the two resulting pages have
 // different SiteInstances, BrowsingInstances, and RenderProcessHosts. This is
 // a regression test for bug 9364.
 TEST_F(RenderFrameHostManagerTest, NewTabPageProcesses) {
   set_should_create_webui(true);
   const GURL kChromeUrl("chrome://foo");
   const GURL kDestUrl("http://www.google.com/");
@@ skipping 1459 matching lines @@
         pending_rfh->GetSiteInstance())->increment_active_view_count();
 
     main_test_rfh()->OnMessageReceived(
         FrameHostMsg_BeforeUnload_ACK(0, false, now, now));
     EXPECT_FALSE(contents()->cross_navigation_pending());
     EXPECT_FALSE(rvh_deleted_observer.deleted());
   }
 }
 
 }  // namespace content