| // Copyright 2021 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "content/browser/site_per_process_browsertest.h" |
| |
| #include "build/build_config.h" |
| #include "content/browser/renderer_host/cross_process_frame_connector.h" |
| #include "content/browser/renderer_host/frame_tree.h" |
| #include "content/browser/renderer_host/render_frame_proxy_host.h" |
| #include "content/common/features.h" |
| #include "content/public/test/browser_test.h" |
| #include "content/public/test/browser_test_utils.h" |
| #include "content/public/test/content_browser_test_utils.h" |
| #include "content/public/test/fenced_frame_test_util.h" |
| #include "content/shell/browser/shell.h" |
| #include "content/test/render_document_feature.h" |
| #include "content/test/render_widget_host_visibility_observer.h" |
| #include "testing/gmock/include/gmock/gmock.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| namespace content { |
| |
| namespace { |
| |
| // Helper class to wait for the next sad frame to be shown in a specific |
| // FrameTreeNode. This can be used to wait for sad frame visibility metrics to |
| // be logged. |
| class SadFrameShownObserver { |
| public: |
| explicit SadFrameShownObserver(FrameTreeNode* ftn) { |
| RenderFrameProxyHost* proxy_to_parent = |
| ftn->render_manager()->GetProxyToParent(); |
| proxy_to_parent->cross_process_frame_connector() |
| ->set_child_frame_crash_shown_closure_for_testing( |
| run_loop_.QuitClosure()); |
| } |
| |
| explicit SadFrameShownObserver(RenderFrameHostImpl* rfhi) { |
| RenderFrameProxyHost* proxy_to_parent = rfhi->GetProxyToOuterDelegate(); |
| proxy_to_parent->cross_process_frame_connector() |
| ->set_child_frame_crash_shown_closure_for_testing( |
| run_loop_.QuitClosure()); |
| } |
| |
| SadFrameShownObserver(const SadFrameShownObserver&) = delete; |
| SadFrameShownObserver& operator=(const SadFrameShownObserver&) = delete; |
| |
| void Wait() { run_loop_.Run(); } |
| |
| private: |
| base::RunLoop run_loop_; |
| }; |
| |
| } // namespace |
| |
| // Disable the feature to mark hidden tabs with sad frames for reload, for use |
| // in tests where this feature interferes with the behavior being tested. |
| class SitePerProcessBrowserTestWithoutSadFrameTabReload |
| : public SitePerProcessBrowserTest { |
| public: |
| SitePerProcessBrowserTestWithoutSadFrameTabReload() { |
| feature_list_.InitAndDisableFeature( |
| features::kReloadHiddenTabsWithCrashedSubframes); |
| } |
| |
| private: |
| base::test::ScopedFeatureList feature_list_; |
| }; |
| |
| // This test is flaky on all platforms. |
| // TODO(crbug.com/40749527): Deflake it and enable this test back. |
| IN_PROC_BROWSER_TEST_P( |
| SitePerProcessBrowserTestWithoutSadFrameTabReload, |
| DISABLED_ChildFrameCrashMetrics_KilledWhileHiddenThenShown) { |
| // Set-up a frame tree that helps verify what the metrics tracks: |
| // 1) frames (12 frames are affected if B process gets killed) or |
| // 2) widgets (10 b widgets and 1 c widget are affected if B is killed) or |
| // 3) crashes (1 crash if B process gets killed)? |
| GURL main_url(embedded_test_server()->GetURL( |
| "a.com", "/cross_site_iframe_factory.html?a(b(b,c),b,b,b,b,b,b,b,b,b)")); |
| EXPECT_TRUE(NavigateToURL(shell(), main_url)); |
| FrameTreeNode* root = web_contents()->GetPrimaryFrameTree().root(); |
| |
| // Hide the web contents (UpdateWebContentsVisibility is called twice to avoid |
| // hitting the |!did_first_set_visible_| case). Make sure all subframes are |
| // considered hidden at this point. |
| web_contents()->UpdateWebContentsVisibility(Visibility::VISIBLE); |
| web_contents()->UpdateWebContentsVisibility(Visibility::HIDDEN); |
| for (size_t i = 0U; i < root->child_count(); i++) { |
| RenderFrameProxyHost* proxy_to_parent = |
| root->child_at(i)->render_manager()->GetProxyToParent(); |
| CrossProcessFrameConnector* connector = |
| proxy_to_parent->cross_process_frame_connector(); |
| EXPECT_FALSE(connector->IsVisible()) |
| << " subframe " << i << " with URL " << root->child_at(i)->current_url() |
| << " is visible"; |
| } |
| |
| // Kill the subframe. |
| base::HistogramTester histograms; |
| RenderProcessHost* child_process = |
| root->child_at(0)->current_frame_host()->GetProcess(); |
| RenderProcessHostWatcher crash_observer( |
| child_process, RenderProcessHostWatcher::WATCH_FOR_PROCESS_EXIT); |
| child_process->Shutdown(0); |
| crash_observer.Wait(); |
| |
| // Verify that no child frame metrics got logged (yet - while WebContents are |
| // hidden). |
| histograms.ExpectTotalCount("Stability.ChildFrameCrash.Visibility", 0); |
| histograms.ExpectTotalCount( |
| "Stability.ChildFrameCrash.ShownAfterCrashingReason", 0); |
| |
| // Show the web contents, wait for each of the subframe FrameTreeNodes to |
| // show a sad frame, and verify that the expected metrics got logged. |
| std::vector<std::unique_ptr<SadFrameShownObserver>> observers; |
| for (size_t i = 0U; i < root->child_count(); i++) { |
| observers.push_back( |
| std::make_unique<SadFrameShownObserver>(root->child_at(i))); |
| } |
| |
| web_contents()->UpdateWebContentsVisibility(Visibility::VISIBLE); |
| |
| for (size_t i = 0U; i < root->child_count(); i++) { |
| SCOPED_TRACE(testing::Message() |
| << " Waiting for sad frame from subframe " << i |
| << " with URL:" << root->child_at(i)->current_url()); |
| observers[i]->Wait(); |
| } |
| |
| histograms.ExpectUniqueSample( |
| "Stability.ChildFrameCrash.Visibility", |
| CrossProcessFrameConnector::CrashVisibility::kShownAfterCrashing, 10); |
| histograms.ExpectUniqueSample( |
| "Stability.ChildFrameCrash.ShownAfterCrashingReason", |
| CrossProcessFrameConnector::ShownAfterCrashingReason::kTabWasShown, 10); |
| |
| // Hide and show the web contents again and verify that no more metrics got |
| // logged. |
| web_contents()->UpdateWebContentsVisibility(Visibility::HIDDEN); |
| web_contents()->UpdateWebContentsVisibility(Visibility::VISIBLE); |
| histograms.ExpectUniqueSample( |
| "Stability.ChildFrameCrash.Visibility", |
| CrossProcessFrameConnector::CrashVisibility::kShownAfterCrashing, 10); |
| histograms.ExpectUniqueSample( |
| "Stability.ChildFrameCrash.ShownAfterCrashingReason", |
| CrossProcessFrameConnector::ShownAfterCrashingReason::kTabWasShown, 10); |
| } |
| |
| IN_PROC_BROWSER_TEST_P(SitePerProcessBrowserTestWithoutSadFrameTabReload, |
| ChildFrameCrashMetrics_ScrolledIntoViewAfterTabIsShown) { |
| // Start on a page that has a single iframe, which is positioned out of |
| // view, and navigate that iframe cross-site. |
| GURL main_url( |
| embedded_test_server()->GetURL("a.com", "/iframe_out_of_view.html")); |
| EXPECT_TRUE(NavigateToURL(shell(), main_url)); |
| FrameTreeNode* root = web_contents()->GetPrimaryFrameTree().root(); |
| EXPECT_TRUE(NavigateToURLFromRenderer( |
| root->child_at(0), |
| embedded_test_server()->GetURL("b.com", "/title1.html"))); |
| |
| // Hide the web contents (UpdateWebContentsVisibility is called twice to avoid |
| // hitting the |!did_first_set_visible_| case). |
| web_contents()->UpdateWebContentsVisibility(Visibility::VISIBLE); |
| web_contents()->UpdateWebContentsVisibility(Visibility::HIDDEN); |
| |
| // Kill the child frame. |
| base::HistogramTester histograms; |
| RenderProcessHost* child_process = |
| root->child_at(0)->current_frame_host()->GetProcess(); |
| RenderProcessHostWatcher crash_observer( |
| child_process, RenderProcessHostWatcher::WATCH_FOR_PROCESS_EXIT); |
| child_process->Shutdown(0); |
| crash_observer.Wait(); |
| |
| // Verify that no child frame crash metrics got logged yet. |
| histograms.ExpectTotalCount("Stability.ChildFrameCrash.Visibility", 0); |
| histograms.ExpectTotalCount( |
| "Stability.ChildFrameCrash.ShownAfterCrashingReason", 0); |
| |
| // Show the web contents. The crash metrics still shouldn't be logged, since |
| // the crashed frame is out of view. |
| web_contents()->UpdateWebContentsVisibility(Visibility::VISIBLE); |
| histograms.ExpectTotalCount("Stability.ChildFrameCrash.Visibility", 0); |
| histograms.ExpectTotalCount( |
| "Stability.ChildFrameCrash.ShownAfterCrashingReason", 0); |
| |
| // Scroll the subframe into view and wait until the scrolled frame draws |
| // itself. |
| std::string scrolling_script = R"( |
| var frame = document.body.querySelector("iframe"); |
| frame.scrollIntoView(); |
| )"; |
| EXPECT_TRUE(ExecJs(root, scrolling_script)); |
| // This will ensure that browser has received the |
| // FrameHostMsg_UpdateViewportIntersection IPC message from the renderer main |
| // thread. |
| EXPECT_EQ(true, |
| EvalJsAfterLifecycleUpdate(root->current_frame_host(), "", "true")); |
| |
| // Verify that the expected metrics got logged. |
| histograms.ExpectUniqueSample( |
| "Stability.ChildFrameCrash.Visibility", |
| CrossProcessFrameConnector::CrashVisibility::kShownAfterCrashing, 1); |
| histograms.ExpectUniqueSample( |
| "Stability.ChildFrameCrash.ShownAfterCrashingReason", |
| CrossProcessFrameConnector::ShownAfterCrashingReason:: |
| kViewportIntersectionAfterTabWasShown, |
| 1); |
| |
| // Hide and show the web contents again and verify that no more metrics got |
| // logged. |
| web_contents()->UpdateWebContentsVisibility(Visibility::HIDDEN); |
| web_contents()->UpdateWebContentsVisibility(Visibility::VISIBLE); |
| histograms.ExpectUniqueSample( |
| "Stability.ChildFrameCrash.Visibility", |
| CrossProcessFrameConnector::CrashVisibility::kShownAfterCrashing, 1); |
| histograms.ExpectUniqueSample( |
| "Stability.ChildFrameCrash.ShownAfterCrashingReason", |
| CrossProcessFrameConnector::ShownAfterCrashingReason:: |
| kViewportIntersectionAfterTabWasShown, |
| 1); |
| } |
| |
| class SitePerProcessBrowserTestWithSadFrameTabReload |
| : public SitePerProcessBrowserTest { |
| public: |
| SitePerProcessBrowserTestWithSadFrameTabReload() { |
| // Disable the feature to mark hidden tabs with sad frames for reload, since |
| // it makes the scenario for which this test collects metrics impossible. |
| feature_list_.InitAndEnableFeature( |
| features::kReloadHiddenTabsWithCrashedSubframes); |
| } |
| |
| void CrashProcess(FrameTreeNode* ftn) { |
| RenderProcessHost* process = ftn->current_frame_host()->GetProcess(); |
| RenderProcessHostWatcher crash_observer( |
| process, RenderProcessHostWatcher::WATCH_FOR_PROCESS_EXIT); |
| process->Shutdown(0); |
| crash_observer.Wait(); |
| EXPECT_FALSE(ftn->current_frame_host()->IsRenderFrameLive()); |
| } |
| |
| void CrashRendererProcess(RenderFrameHostImpl* rfhi) { |
| RenderProcessHost* process = rfhi->GetProcess(); |
| RenderProcessHostWatcher crash_observer( |
| process, RenderProcessHostWatcher::WATCH_FOR_PROCESS_EXIT); |
| process->Shutdown(0); |
| crash_observer.Wait(); |
| EXPECT_FALSE(rfhi->IsRenderFrameLive()); |
| } |
| |
| WebContentsImpl* web_contents() { |
| return static_cast<WebContentsImpl*>(shell()->web_contents()); |
| } |
| |
| RenderFrameHostImpl* primary_main_frame_host() { |
| return web_contents()->GetPrimaryMainFrame(); |
| } |
| |
| content::test::FencedFrameTestHelper& fenced_frame_test_helper() { |
| return fenced_frame_helper_; |
| } |
| |
| private: |
| content::test::FencedFrameTestHelper fenced_frame_helper_; |
| base::test::ScopedFeatureList feature_list_; |
| }; |
| |
| // Verify the feature where hidden tabs with a visible crashed subframe are |
| // marked for reload. This avoids showing crashed subframes if a hidden tab is |
| // eventually shown. See https://crbug.com/841572. |
| IN_PROC_BROWSER_TEST_P(SitePerProcessBrowserTestWithSadFrameTabReload, |
| ReloadHiddenTabWithCrashedSubframeInViewport) { |
| GURL main_url(embedded_test_server()->GetURL( |
| "a.com", "/cross_site_iframe_factory.html?a(b)")); |
| EXPECT_TRUE(NavigateToURL(shell(), main_url)); |
| FrameTreeNode* root = web_contents()->GetPrimaryFrameTree().root(); |
| |
| // Hide the WebContents (UpdateWebContentsVisibility is called twice to avoid |
| // hitting the |!did_first_set_visible_| case). |
| web_contents()->UpdateWebContentsVisibility(Visibility::VISIBLE); |
| web_contents()->UpdateWebContentsVisibility(Visibility::HIDDEN); |
| EXPECT_EQ(Visibility::HIDDEN, web_contents()->GetVisibility()); |
| |
| // Kill the b.com subframe's process. This should mark the hidden |
| // WebContents for reload. |
| { |
| base::HistogramTester histograms; |
| CrashProcess(root->child_at(0)); |
| histograms.ExpectUniqueSample( |
| "Stability.ChildFrameCrash.TabMarkedForReload", true, 1); |
| histograms.ExpectUniqueSample( |
| "Stability.ChildFrameCrash.TabMarkedForReload.Visibility", |
| blink::mojom::FrameVisibility::kRenderedInViewport, 1); |
| } |
| |
| // Show the WebContents. This should trigger a reload of the main frame. |
| { |
| base::HistogramTester histograms; |
| web_contents()->UpdateWebContentsVisibility(Visibility::VISIBLE); |
| EXPECT_TRUE(WaitForLoadStop(web_contents())); |
| histograms.ExpectUniqueSample( |
| "Navigation.LoadIfNecessaryType", |
| NavigationControllerImpl::NeedsReloadType::kCrashedSubframe, 1); |
| } |
| |
| // Both frames should now have live renderer processes. |
| EXPECT_TRUE(root->current_frame_host()->IsRenderFrameLive()); |
| EXPECT_TRUE(root->child_at(0)->current_frame_host()->IsRenderFrameLive()); |
| } |
| |
| // Verify that when a tab is reloaded because it was previously marked for |
| // reload due to having a sad frame, we log the sad frame as shown during a tab |
| // reload, rather than being shown to the user directly, since the sad frame is |
| // expected to go away shortly. See https://crbug.com/1132938. |
| IN_PROC_BROWSER_TEST_P(SitePerProcessBrowserTestWithSadFrameTabReload, |
| CrashedSubframeVisibilityMetricsDuringTabReload) { |
| GURL main_url(embedded_test_server()->GetURL( |
| "a.com", "/cross_site_iframe_factory.html?a(b,c)")); |
| EXPECT_TRUE(NavigateToURL(shell(), main_url)); |
| FrameTreeNode* root = web_contents()->GetPrimaryFrameTree().root(); |
| |
| // Hide the WebContents (UpdateWebContentsVisibility is called twice to avoid |
| // hitting the |!did_first_set_visible_| case). |
| RenderWidgetHostVisibilityObserver hide_observer( |
| root->child_at(0)->current_frame_host()->GetRenderWidgetHost(), |
| false /* became_visible */); |
| web_contents()->UpdateWebContentsVisibility(Visibility::VISIBLE); |
| web_contents()->UpdateWebContentsVisibility(Visibility::HIDDEN); |
| EXPECT_EQ(Visibility::HIDDEN, web_contents()->GetVisibility()); |
| hide_observer.WaitUntilSatisfied(); |
| |
| // Kill the b.com subframe's process. This should mark the hidden |
| // WebContents for reload. |
| CrashProcess(root->child_at(0)); |
| auto& controller = static_cast<NavigationControllerImpl&>( |
| shell()->web_contents()->GetController()); |
| EXPECT_TRUE(controller.NeedsReload()); |
| EXPECT_EQ(1, controller.GetEntryCount()); |
| |
| // Show the WebContents. This should trigger a reload of the main frame. Sad |
| // frame visibility metrics should indicate that the sad frame is shown while |
| // the tab is being reloaded. Because the tab reload will wipe out the sad |
| // frame, this isn't as bad as kShownAfterCrashing. |
| { |
| base::HistogramTester histograms; |
| SadFrameShownObserver sad_frame_observer(root->child_at(0)); |
| TestNavigationManager manager(web_contents(), main_url); |
| web_contents()->UpdateWebContentsVisibility(Visibility::VISIBLE); |
| EXPECT_TRUE(manager.WaitForRequestStart()); |
| sad_frame_observer.Wait(); |
| |
| histograms.ExpectUniqueSample("Stability.ChildFrameCrash.Visibility", |
| CrashVisibility::kShownWhileAncestorIsLoading, |
| 1); |
| |
| // Ensure no new metrics are logged after the reload completes. |
| ASSERT_TRUE(manager.WaitForNavigationFinished()); |
| EXPECT_TRUE(manager.was_successful()); |
| EXPECT_FALSE(controller.NeedsReload()); |
| EXPECT_EQ(1, controller.GetEntryCount()); |
| histograms.ExpectUniqueSample("Stability.ChildFrameCrash.Visibility", |
| CrashVisibility::kShownWhileAncestorIsLoading, |
| 1); |
| } |
| } |
| |
| // Verify that a sad frame shown when its parent frame is loading is logged |
| // with appropriate metrics, namely as kShownWhileAncestorIsLoading rather than |
| // kShownAfterCrashing. See https://crbug.com/1132938. |
| IN_PROC_BROWSER_TEST_P(SitePerProcessBrowserTestWithSadFrameTabReload, |
| CrashedSubframeVisibilityMetricsDuringParentLoad) { |
| GURL main_url(embedded_test_server()->GetURL( |
| "a.com", "/cross_site_iframe_factory.html?a(b(c))")); |
| EXPECT_TRUE(NavigateToURL(shell(), main_url)); |
| FrameTreeNode* root = web_contents()->GetPrimaryFrameTree().root(); |
| FrameTreeNode* child = root->child_at(0); |
| FrameTreeNode* grandchild = child->child_at(0); |
| |
| // Hide the grandchild frame. |
| RenderWidgetHostVisibilityObserver hide_observer( |
| grandchild->current_frame_host()->GetRenderWidgetHost(), |
| false /* became_visible */); |
| EXPECT_TRUE( |
| ExecJs(child, "document.querySelector('iframe').style.display = 'none'")); |
| hide_observer.WaitUntilSatisfied(); |
| |
| // Kill the c.com grandchild process. |
| CrashProcess(grandchild); |
| |
| // Start a navigation in the b.com frame, but don't commit. |
| GURL url_d(embedded_test_server()->GetURL("d.com", "/title1.html")); |
| TestNavigationManager manager(web_contents(), url_d); |
| EXPECT_TRUE(ExecJs(child, JsReplace("location.href = $1", url_d))); |
| EXPECT_TRUE(manager.WaitForRequestStart()); |
| |
| // Make the grandchild iframe with the sad frame visible again. This should |
| // get logged as kShownWhileAncestorIsLoading, because its parent is |
| // currently loading. |
| { |
| base::HistogramTester histograms; |
| SadFrameShownObserver sad_frame_observer(grandchild); |
| EXPECT_TRUE(ExecJs( |
| child, "document.querySelector('iframe').style.display = 'block'")); |
| sad_frame_observer.Wait(); |
| |
| histograms.ExpectUniqueSample("Stability.ChildFrameCrash.Visibility", |
| CrashVisibility::kShownWhileAncestorIsLoading, |
| 1); |
| |
| // Ensure no new metrics are logged after the navigation completes. |
| ASSERT_TRUE(manager.WaitForNavigationFinished()); |
| EXPECT_TRUE(manager.was_successful()); |
| histograms.ExpectUniqueSample("Stability.ChildFrameCrash.Visibility", |
| CrashVisibility::kShownWhileAncestorIsLoading, |
| 1); |
| } |
| } |
| |
| // Verify that a sad frame shown when its parent frame is loading is logged |
| // with appropriate metrics, namely as kShownWhileAncestorIsLoading rather than |
| // kShownAfterCrashing. See https://crbug.com/1132938. |
| IN_PROC_BROWSER_TEST_P( |
| SitePerProcessBrowserTestWithSadFrameTabReload, |
| // TODO(crbug.com/40839850): Re-enable this test |
| DISABLED_CrashedFencedframeVisibilityMetricsDuringParentLoad) { |
| GURL primary_url(embedded_test_server()->GetURL("a.com", "/title1.html")); |
| GURL child_url( |
| embedded_test_server()->GetURL("b.com", "/fenced_frames/title1.html")); |
| GURL grandchild_url( |
| embedded_test_server()->GetURL("c.com", "/fenced_frames/title1.html")); |
| |
| EXPECT_TRUE(NavigateToURL(shell(), primary_url)); |
| RenderFrameHostImplWrapper primary_rfh(primary_main_frame_host()); |
| RenderFrameHostImplWrapper child_rfh( |
| fenced_frame_test_helper().CreateFencedFrame(primary_rfh.get(), |
| child_url)); |
| // Note that height and width follows the layout function in |
| // content/test/data/cross_site_iframe_factory.html. |
| EXPECT_TRUE(ExecJs(primary_rfh.get(), R"( |
| var ff = document.querySelector('fencedframe'); |
| // layoutX = gridSizeX * largestChildX + extraXPerLevel |
| ff.width = 1 * (110 + 30) + 50; |
| // layoutY = gridSizeY * largestChildY + extraYPerLevel |
| ff.height = 1 * (110 + 30) + 50 |
| )")); |
| RenderFrameHostImplWrapper grandchild_rfh( |
| fenced_frame_test_helper().CreateFencedFrame(child_rfh.get(), |
| grandchild_url)); |
| // Note that height and width follows the layout function in |
| // content/test/data/cross_site_iframe_factory.html. |
| EXPECT_TRUE(ExecJs(child_rfh.get(), R"( |
| var ff = document.querySelector('fencedframe'); |
| ff.width = 110; |
| ff.height = 110; |
| )")); |
| |
| // Hide the grandchild frame. |
| RenderWidgetHostVisibilityObserver hide_observer( |
| grandchild_rfh->GetRenderWidgetHost(), false /* became_visible */); |
| EXPECT_TRUE( |
| ExecJs(child_rfh.get(), |
| "document.querySelector('fencedframe').style.display = 'none'")); |
| hide_observer.WaitUntilSatisfied(); |
| |
| // Kill the grandchild process. |
| CrashRendererProcess(grandchild_rfh.get()); |
| |
| // Start a navigation in the child frame, but don't commit. |
| GURL url_d( |
| embedded_test_server()->GetURL("d.com", "/fenced_frames/title1.html")); |
| TestNavigationManager manager(web_contents(), url_d); |
| EXPECT_TRUE(ExecJs(child_rfh.get(), JsReplace("location.href = $1", url_d))); |
| EXPECT_TRUE(manager.WaitForRequestStart()); |
| |
| // Make the grandchild fencedframe with the sad frame visible again. |
| // This should get logged as kShownWhileAncestorIsLoading, because its parent |
| // is currently loading. |
| { |
| base::HistogramTester histograms; |
| SadFrameShownObserver sad_frame_observer(grandchild_rfh.get()); |
| EXPECT_TRUE(ExecJs( |
| child_rfh.get(), |
| "document.querySelector('fencedframe').style.display = 'block'")); |
| sad_frame_observer.Wait(); |
| |
| histograms.ExpectUniqueSample("Stability.ChildFrameCrash.Visibility", |
| CrashVisibility::kShownWhileAncestorIsLoading, |
| 1); |
| |
| // Ensure no new metrics are logged after the navigation completes. |
| ASSERT_TRUE(manager.WaitForNavigationFinished()); |
| EXPECT_TRUE(manager.was_successful()); |
| histograms.ExpectUniqueSample("Stability.ChildFrameCrash.Visibility", |
| CrashVisibility::kShownWhileAncestorIsLoading, |
| 1); |
| } |
| } |
| |
| // Verify the feature where hidden tabs with crashed subframes are marked for |
| // reload. This avoids showing crashed subframes if a hidden tab is eventually |
| // shown. Similar to the test above, except that the crashed subframe is |
| // scrolled out of view. |
| IN_PROC_BROWSER_TEST_P(SitePerProcessBrowserTestWithSadFrameTabReload, |
| // TODO(crbug.com/40870019): Re-enable this test |
| DISABLED_ReloadHiddenTabWithCrashedSubframeOutOfView) { |
| // Set WebContents to VISIBLE to avoid hitting the |!did_first_set_visible_| |
| // case when we hide it later. |
| web_contents()->UpdateWebContentsVisibility(Visibility::VISIBLE); |
| |
| // Navigate to a page with an OOPIF that's scrolled out of view. |
| GURL out_of_view_url( |
| embedded_test_server()->GetURL("a.com", "/iframe_out_of_view.html")); |
| EXPECT_TRUE(NavigateToURL(shell(), out_of_view_url)); |
| EXPECT_EQ("LOADED", EvalJs(shell(), "notifyWhenLoaded();")); |
| NavigateIframeToURL(web_contents(), "test_iframe", |
| embedded_test_server()->GetURL("b.com", "/title1.html")); |
| |
| // This will ensure that the layout has completed and visibility of the OOPIF |
| // has been updated in the browser process. |
| FrameTreeNode* root = web_contents()->GetPrimaryFrameTree().root(); |
| EXPECT_EQ(true, |
| EvalJsAfterLifecycleUpdate(root->current_frame_host(), "", "true")); |
| |
| // Verify the OOPIF isn't visible at the moment. |
| RenderFrameProxyHost* proxy_to_parent = |
| root->child_at(0)->render_manager()->GetProxyToParent(); |
| CrossProcessFrameConnector* connector = |
| proxy_to_parent->cross_process_frame_connector(); |
| EXPECT_FALSE(connector->IsVisible()); |
| EXPECT_EQ(blink::mojom::FrameVisibility::kRenderedOutOfViewport, |
| connector->visibility()); |
| |
| // Hide the WebContents and crash the OOPIF. |
| { |
| base::HistogramTester histograms; |
| web_contents()->UpdateWebContentsVisibility(Visibility::HIDDEN); |
| CrashProcess(root->child_at(0)); |
| histograms.ExpectUniqueSample( |
| "Stability.ChildFrameCrash.TabMarkedForReload", true, 1); |
| histograms.ExpectUniqueSample( |
| "Stability.ChildFrameCrash.TabMarkedForReload.Visibility", |
| blink::mojom::FrameVisibility::kRenderedOutOfViewport, 1); |
| } |
| |
| EXPECT_TRUE(root->current_frame_host()->IsRenderFrameLive()); |
| EXPECT_FALSE(root->child_at(0)->current_frame_host()->IsRenderFrameLive()); |
| |
| // Show the tab and ensure that it reloads. |
| { |
| base::HistogramTester histograms; |
| web_contents()->UpdateWebContentsVisibility(Visibility::VISIBLE); |
| EXPECT_TRUE(WaitForLoadStop(web_contents())); |
| histograms.ExpectUniqueSample( |
| "Navigation.LoadIfNecessaryType", |
| NavigationControllerImpl::NeedsReloadType::kCrashedSubframe, 1); |
| } |
| |
| EXPECT_TRUE(root->current_frame_host()->IsRenderFrameLive()); |
| EXPECT_TRUE(root->child_at(0)->current_frame_host()->IsRenderFrameLive()); |
| } |
| |
| // Verify that hidden tabs with a crashed subframe are not marked for reload |
| // when the crashed subframe is hidden with "display:none". |
| IN_PROC_BROWSER_TEST_P(SitePerProcessBrowserTestWithSadFrameTabReload, |
| DoNotReloadHiddenTabWithHiddenCrashedSubframe) { |
| // Set WebContents to VISIBLE to avoid hitting the |!did_first_set_visible_| |
| // case when we hide it later. |
| web_contents()->UpdateWebContentsVisibility(Visibility::VISIBLE); |
| |
| GURL hidden_iframe_url( |
| embedded_test_server()->GetURL("a.com", "/page_with_hidden_iframe.html")); |
| EXPECT_TRUE(NavigateToURL(shell(), hidden_iframe_url)); |
| NavigateIframeToURL(web_contents(), "test_iframe", |
| embedded_test_server()->GetURL("b.com", "/title1.html")); |
| |
| // Ensure that the parent frame has propagated the OOPIF's hidden visibility |
| // to the browser process by forcing requestAnimationFrame and |
| // waiting for layout to finish. |
| FrameTreeNode* root = web_contents()->GetPrimaryFrameTree().root(); |
| EXPECT_EQ(true, |
| EvalJsAfterLifecycleUpdate(root->current_frame_host(), "", "true")); |
| |
| // The OOPIF should be hidden at this point. |
| RenderFrameProxyHost* proxy_to_parent = |
| root->child_at(0)->render_manager()->GetProxyToParent(); |
| EXPECT_TRUE(proxy_to_parent->cross_process_frame_connector()->IsHidden()); |
| |
| // Crashing a hidden OOPIF shouldn't mark the tab for reload. |
| web_contents()->UpdateWebContentsVisibility(Visibility::HIDDEN); |
| base::HistogramTester histograms; |
| CrashProcess(root->child_at(0)); |
| histograms.ExpectUniqueSample("Stability.ChildFrameCrash.TabMarkedForReload", |
| false, 1); |
| |
| // Making the WebContents visible again should keep the sad frame and should |
| // not load anything new. |
| web_contents()->UpdateWebContentsVisibility(Visibility::VISIBLE); |
| EXPECT_TRUE(WaitForLoadStop(web_contents())); |
| EXPECT_TRUE(root->current_frame_host()->IsRenderFrameLive()); |
| EXPECT_FALSE(root->child_at(0)->current_frame_host()->IsRenderFrameLive()); |
| } |
| |
| // Ensure that the sad frame reload policy doesn't trigger for a visible tab, |
| // even if it becomes hidden and then visible again. |
| IN_PROC_BROWSER_TEST_P(SitePerProcessBrowserTestWithSadFrameTabReload, |
| DoNotReloadVisibleTabWithCrashedSubframe) { |
| // Set WebContents to VISIBLE to avoid hitting the |!did_first_set_visible_| |
| // case when we hide it later. |
| web_contents()->UpdateWebContentsVisibility(Visibility::VISIBLE); |
| EXPECT_EQ(Visibility::VISIBLE, web_contents()->GetVisibility()); |
| |
| GURL main_url(embedded_test_server()->GetURL( |
| "a.com", "/cross_site_iframe_factory.html?a(b)")); |
| EXPECT_TRUE(NavigateToURL(shell(), main_url)); |
| FrameTreeNode* root = web_contents()->GetPrimaryFrameTree().root(); |
| base::HistogramTester histograms; |
| CrashProcess(root->child_at(0)); |
| histograms.ExpectUniqueSample("Stability.ChildFrameCrash.TabMarkedForReload", |
| false, 1); |
| |
| EXPECT_EQ(Visibility::VISIBLE, web_contents()->GetVisibility()); |
| web_contents()->UpdateWebContentsVisibility(Visibility::HIDDEN); |
| web_contents()->UpdateWebContentsVisibility(Visibility::VISIBLE); |
| EXPECT_TRUE(WaitForLoadStop(web_contents())); |
| EXPECT_TRUE(root->current_frame_host()->IsRenderFrameLive()); |
| EXPECT_FALSE(root->child_at(0)->current_frame_host()->IsRenderFrameLive()); |
| histograms.ExpectUniqueSample("Stability.ChildFrameCrash.TabMarkedForReload", |
| false, 1); |
| } |
| |
| IN_PROC_BROWSER_TEST_P(SitePerProcessBrowserTest, |
| // TODO(crbug.com/40870019): Re-enable this test |
| DISABLED_ChildFrameCrashMetrics_KilledWhileVisible) { |
| // Set-up a frame tree that helps verify what the metrics tracks: |
| // 1) frames (12 frames are affected if B process gets killed) or |
| // 2) crashes (simply 1 crash if B process gets killed)? |
| // 3) widgets (10 b widgets and 1 c widget are affected if B is killed, |
| // but a sad frame will appear only in 9 widgets - this excludes |
| // widgets for the b,c(b) part of the frame tree) or |
| GURL main_url(embedded_test_server()->GetURL( |
| "a.com", "/cross_site_iframe_factory.html?a(b(b,c(b)),b,b,b,b,b,b,b,b)")); |
| EXPECT_TRUE(NavigateToURL(shell(), main_url)); |
| FrameTreeNode* root = web_contents()->GetPrimaryFrameTree().root(); |
| |
| std::vector<std::unique_ptr<SadFrameShownObserver>> observers; |
| for (size_t i = 0U; i < root->child_count(); i++) { |
| // At this point, all b.com subframes should be considered visible. |
| RenderFrameProxyHost* proxy_to_parent = |
| root->child_at(i)->render_manager()->GetProxyToParent(); |
| CrossProcessFrameConnector* connector = |
| proxy_to_parent->cross_process_frame_connector(); |
| EXPECT_TRUE(connector->IsVisible()) |
| << " subframe " << i << " with URL " << root->child_at(i)->current_url() |
| << " is hidden"; |
| observers.push_back( |
| std::make_unique<SadFrameShownObserver>(root->child_at(i))); |
| } |
| |
| // Kill the child frame and wait for each of the subframe FrameTreeNodes to |
| // show a sad frame. |
| base::HistogramTester histograms; |
| RenderProcessHost* child_process = |
| root->child_at(0)->current_frame_host()->GetProcess(); |
| RenderProcessHostWatcher crash_observer( |
| child_process, RenderProcessHostWatcher::WATCH_FOR_PROCESS_EXIT); |
| child_process->Shutdown(0); |
| crash_observer.Wait(); |
| for (size_t i = 0U; i < root->child_count(); i++) { |
| SCOPED_TRACE(testing::Message() |
| << " Waiting for sad frame from subframe " << i |
| << " with URL:" << root->child_at(i)->current_url()); |
| observers[i]->Wait(); |
| } |
| |
| // Verify that the expected metrics got logged. |
| histograms.ExpectUniqueSample( |
| "Stability.ChildFrameCrash.Visibility", |
| CrossProcessFrameConnector::CrashVisibility::kCrashedWhileVisible, 9); |
| |
| // Hide and show the web contents and verify that no more metrics got logged. |
| web_contents()->UpdateWebContentsVisibility(Visibility::HIDDEN); |
| web_contents()->UpdateWebContentsVisibility(Visibility::VISIBLE); |
| histograms.ExpectUniqueSample( |
| "Stability.ChildFrameCrash.Visibility", |
| CrossProcessFrameConnector::CrashVisibility::kCrashedWhileVisible, 9); |
| } |
| |
| INSTANTIATE_TEST_SUITE_P(All, |
| SitePerProcessBrowserTestWithoutSadFrameTabReload, |
| testing::ValuesIn(RenderDocumentFeatureLevelValues())); |
| INSTANTIATE_TEST_SUITE_P(All, |
| SitePerProcessBrowserTestWithSadFrameTabReload, |
| testing::ValuesIn(RenderDocumentFeatureLevelValues())); |
| |
| } // namespace content |
