Reland "Sync requestFullscreen() and exitFullscreen() algorithms with the spec"

third_party/WebKit/Source/web/tests/WebFrameTest.cpp

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 8044 matching lines @@
       base_url_ + "fullscreen_div.html", true, nullptr, &client, nullptr,
       ConfigureAndroid);
   web_view_helper.Resize(WebSize(viewport_width, viewport_height));
   web_view_impl->UpdateAllLifecyclePhases();
 
   Document* document =
       web_view_impl->MainFrameImpl()->GetFrame()->GetDocument();
   UserGestureIndicator gesture(UserGestureToken::Create(document));
   Element* div_fullscreen = document->getElementById("div1");
   Fullscreen::RequestFullscreen(*div_fullscreen);
-  EXPECT_EQ(nullptr, Fullscreen::CurrentFullScreenElementFrom(*document));
-  EXPECT_EQ(div_fullscreen, Fullscreen::FullscreenElementFrom(*document));
   web_view_impl->DidEnterFullscreen();
-  EXPECT_EQ(div_fullscreen,
-            Fullscreen::CurrentFullScreenElementFrom(*document));
+  EXPECT_EQ(nullptr, Fullscreen::FullscreenElementFrom(*document));
+  web_view_impl->BeginFrame(WTF::MonotonicallyIncreasingTime());
   EXPECT_EQ(div_fullscreen, Fullscreen::FullscreenElementFrom(*document));
   web_view_impl->UpdateAllLifecyclePhases();
-  EXPECT_EQ(div_fullscreen,
-            Fullscreen::CurrentFullScreenElementFrom(*document));
-  EXPECT_EQ(div_fullscreen, Fullscreen::FullscreenElementFrom(*document));
 
   // Verify that the element is sized to the viewport.
   LayoutFullScreen* fullscreen_layout_object =
       Fullscreen::From(*document).FullScreenLayoutObject();
   EXPECT_EQ(viewport_width, fullscreen_layout_object->LogicalWidth().ToInt());
   EXPECT_EQ(viewport_height, fullscreen_layout_object->LogicalHeight().ToInt());
 
   // Verify it's updated after a device rotation.
   client.screen_info_.rect.width = viewport_height;
   client.screen_info_.rect.height = viewport_width;
@@ skipping 13 matching lines @@
       base_url_ + "fullscreen_div.html", true, nullptr, &client, nullptr,
       ConfigureAndroid);
   web_view_helper.Resize(WebSize(viewport_width, viewport_height));
   web_view_impl->UpdateAllLifecyclePhases();
 
   Document* document =
       web_view_impl->MainFrameImpl()->GetFrame()->GetDocument();
   UserGestureIndicator gesture(UserGestureToken::Create(document));
   Element* div_fullscreen = document->getElementById("div1");
   Fullscreen::RequestFullscreen(*div_fullscreen);
-  EXPECT_EQ(nullptr, Fullscreen::CurrentFullScreenElementFrom(*document));
-  EXPECT_EQ(div_fullscreen, Fullscreen::FullscreenElementFrom(*document));
   web_view_impl->DidEnterFullscreen();
-  EXPECT_EQ(div_fullscreen,
-            Fullscreen::CurrentFullScreenElementFrom(*document));
+  EXPECT_EQ(nullptr, Fullscreen::FullscreenElementFrom(*document));
+  web_view_impl->BeginFrame(WTF::MonotonicallyIncreasingTime());
   EXPECT_EQ(div_fullscreen, Fullscreen::FullscreenElementFrom(*document));
   web_view_impl->UpdateAllLifecyclePhases();
-  EXPECT_EQ(div_fullscreen,
-            Fullscreen::CurrentFullScreenElementFrom(*document));
-  EXPECT_EQ(div_fullscreen, Fullscreen::FullscreenElementFrom(*document));
 
   // Verify that the viewports are nonscrollable.
   LocalFrameView* frame_view =
       web_view_helper.WebView()->MainFrameImpl()->GetFrameView();
   WebLayer* layout_viewport_scroll_layer =
       web_view_impl->Compositor()->ScrollLayer()->PlatformLayer();
   WebLayer* visual_viewport_scroll_layer =
       frame_view->GetPage()->GetVisualViewport().ScrollLayer()->PlatformLayer();
   ASSERT_FALSE(layout_viewport_scroll_layer->UserScrollableHorizontal());
   ASSERT_FALSE(layout_viewport_scroll_layer->UserScrollableVertical());
   ASSERT_FALSE(visual_viewport_scroll_layer->UserScrollableHorizontal());
   ASSERT_FALSE(visual_viewport_scroll_layer->UserScrollableVertical());
 
   // Verify that the viewports are scrollable upon exiting fullscreen.
-  EXPECT_EQ(div_fullscreen,
-            Fullscreen::CurrentFullScreenElementFrom(*document));
+  web_view_impl->DidExitFullscreen();
   EXPECT_EQ(div_fullscreen, Fullscreen::FullscreenElementFrom(*document));
-  web_view_impl->DidExitFullscreen();
-  EXPECT_EQ(nullptr, Fullscreen::CurrentFullScreenElementFrom(*document));
+  web_view_impl->BeginFrame(WTF::MonotonicallyIncreasingTime());
   EXPECT_EQ(nullptr, Fullscreen::FullscreenElementFrom(*document));
   web_view_impl->UpdateAllLifecyclePhases();
-  EXPECT_EQ(nullptr, Fullscreen::CurrentFullScreenElementFrom(*document));
-  EXPECT_EQ(nullptr, Fullscreen::FullscreenElementFrom(*document));
   ASSERT_TRUE(layout_viewport_scroll_layer->UserScrollableHorizontal());
   ASSERT_TRUE(layout_viewport_scroll_layer->UserScrollableVertical());
   ASSERT_TRUE(visual_viewport_scroll_layer->UserScrollableHorizontal());
   ASSERT_TRUE(visual_viewport_scroll_layer->UserScrollableVertical());
 }
 
 TEST_P(ParameterizedWebFrameTest, FullscreenMainFrame) {
   FakeCompositingWebViewClient client;
   RegisterMockedHttpURLLoad("fullscreen_div.html");
   FrameTestHelpers::WebViewHelper web_view_helper;
@@ skipping 12 matching lines @@
                                    ->LayerForScrolling()
                                    ->PlatformLayer();
   ASSERT_TRUE(web_scroll_layer->Scrollable());
   ASSERT_TRUE(web_scroll_layer->UserScrollableHorizontal());
   ASSERT_TRUE(web_scroll_layer->UserScrollableVertical());
 
   Document* document =
       web_view_impl->MainFrameImpl()->GetFrame()->GetDocument();
   UserGestureIndicator gesture(UserGestureToken::Create(document));
   Fullscreen::RequestFullscreen(*document->documentElement());
-  EXPECT_EQ(nullptr, Fullscreen::CurrentFullScreenElementFrom(*document));
+  web_view_impl->DidEnterFullscreen();
+  EXPECT_EQ(nullptr, Fullscreen::FullscreenElementFrom(*document));
+  web_view_impl->BeginFrame(WTF::MonotonicallyIncreasingTime());
   EXPECT_EQ(document->documentElement(),
             Fullscreen::FullscreenElementFrom(*document));
-  web_view_impl->DidEnterFullscreen();
-  EXPECT_EQ(document->documentElement(),
-            Fullscreen::CurrentFullScreenElementFrom(*document));
-  EXPECT_EQ(document->documentElement(),
-            Fullscreen::FullscreenElementFrom(*document));
-
   web_view_impl->UpdateAllLifecyclePhases();
-  EXPECT_EQ(document->documentElement(),
-            Fullscreen::CurrentFullScreenElementFrom(*document));
-  EXPECT_EQ(document->documentElement(),
-            Fullscreen::FullscreenElementFrom(*document));
 
   // Verify that the main frame is still scrollable.
   web_scroll_layer = web_view_impl->MainFrameImpl()
                          ->GetFrame()
                          ->View()
                          ->LayoutViewportScrollableArea()
                          ->LayerForScrolling()
                          ->PlatformLayer();
   ASSERT_TRUE(web_scroll_layer->Scrollable());
   ASSERT_TRUE(web_scroll_layer->UserScrollableHorizontal());
@@ skipping 22 matching lines @@
   web_view_impl->UpdateAllLifecyclePhases();
 
   Document* document =
       ToWebLocalFrameBase(web_view_helper.WebView()->MainFrame()->FirstChild())
           ->GetFrame()
           ->GetDocument();
   UserGestureIndicator gesture(UserGestureToken::Create(document));
   Element* div_fullscreen = document->getElementById("div1");
   Fullscreen::RequestFullscreen(*div_fullscreen);
   web_view_impl->DidEnterFullscreen();
+  web_view_impl->BeginFrame(WTF::MonotonicallyIncreasingTime());
   web_view_impl->UpdateAllLifecyclePhases();
 
   // Verify that the element is sized to the viewport.
   LayoutFullScreen* fullscreen_layout_object =
       Fullscreen::From(*document).FullScreenLayoutObject();
   EXPECT_EQ(viewport_width, fullscreen_layout_object->LogicalWidth().ToInt());
   EXPECT_EQ(viewport_height, fullscreen_layout_object->LogicalHeight().ToInt());
 
   // Verify it's updated after a device rotation.
   client.screen_info_.rect.width = viewport_height;
@@ skipping 21 matching lines @@
   HTMLIFrameElement* iframe =
       toHTMLIFrameElement(top_doc->QuerySelector("iframe"));
   Document* iframe_doc = iframe->contentDocument();
   Element* iframe_body = iframe_doc->body();
 
   {
     UserGestureIndicator gesture(UserGestureToken::Create(top_doc));
     Fullscreen::RequestFullscreen(*top_body);
   }
   web_view_impl->DidEnterFullscreen();
+  EXPECT_EQ(nullptr, Fullscreen::FullscreenElementFrom(*top_doc));
+  EXPECT_EQ(nullptr, Fullscreen::FullscreenElementFrom(*iframe_doc));
+  web_view_impl->BeginFrame(WTF::MonotonicallyIncreasingTime());
+  EXPECT_EQ(top_body, Fullscreen::FullscreenElementFrom(*top_doc));
+  EXPECT_EQ(nullptr, Fullscreen::FullscreenElementFrom(*iframe_doc));
   web_view_impl->UpdateAllLifecyclePhases();
 
   {
     UserGestureIndicator gesture(UserGestureToken::Create(iframe_doc));
     Fullscreen::RequestFullscreen(*iframe_body);
   }
   web_view_impl->DidEnterFullscreen();
+  EXPECT_EQ(top_body, Fullscreen::FullscreenElementFrom(*top_doc));
+  EXPECT_EQ(nullptr, Fullscreen::FullscreenElementFrom(*iframe_doc));
+  web_view_impl->BeginFrame(WTF::MonotonicallyIncreasingTime());
+  EXPECT_EQ(iframe, Fullscreen::FullscreenElementFrom(*top_doc));
+  EXPECT_EQ(iframe_body, Fullscreen::FullscreenElementFrom(*iframe_doc));
   web_view_impl->UpdateAllLifecyclePhases();
 
   // We are now in nested fullscreen, with both documents having a non-empty
   // fullscreen element stack.
-  EXPECT_EQ(top_body, Fullscreen::CurrentFullScreenElementFrom(*top_doc));
-  EXPECT_EQ(iframe, Fullscreen::FullscreenElementFrom(*top_doc));
-  EXPECT_EQ(iframe_body, Fullscreen::CurrentFullScreenElementFrom(*iframe_doc));
-  EXPECT_EQ(iframe_body, Fullscreen::FullscreenElementFrom(*iframe_doc));
 
   web_view_impl->DidExitFullscreen();
+  EXPECT_EQ(iframe, Fullscreen::FullscreenElementFrom(*top_doc));
+  EXPECT_EQ(iframe_body, Fullscreen::FullscreenElementFrom(*iframe_doc));
+  web_view_impl->BeginFrame(WTF::MonotonicallyIncreasingTime());
+  EXPECT_EQ(nullptr, Fullscreen::FullscreenElementFrom(*top_doc));
+  EXPECT_EQ(nullptr, Fullscreen::FullscreenElementFrom(*iframe_doc));
   web_view_impl->UpdateAllLifecyclePhases();
 
-  // We should now have fully exited fullscreen.
-  EXPECT_EQ(nullptr, Fullscreen::CurrentFullScreenElementFrom(*top_doc));
-  EXPECT_EQ(nullptr, Fullscreen::FullscreenElementFrom(*top_doc));
-  EXPECT_EQ(nullptr, Fullscreen::CurrentFullScreenElementFrom(*iframe_doc));
-  EXPECT_EQ(nullptr, Fullscreen::FullscreenElementFrom(*iframe_doc));
+  // We have now fully exited fullscreen.
 }
 
 TEST_P(ParameterizedWebFrameTest, FullscreenWithTinyViewport) {
   FakeCompositingWebViewClient client;
   RegisterMockedHttpURLLoad("viewport-tiny.html");
   FrameTestHelpers::WebViewHelper web_view_helper;
   WebViewBase* web_view_impl = web_view_helper.InitializeAndLoad(
       base_url_ + "viewport-tiny.html", true, nullptr, &client, nullptr,
       ConfigureAndroid);
   int viewport_width = 384;
@@ skipping 11 matching lines @@
   EXPECT_EQ(533, layout_view_item.LogicalHeight().Floor());
   EXPECT_FLOAT_EQ(1.2, web_view_impl->PageScaleFactor());
   EXPECT_FLOAT_EQ(1.2, web_view_impl->MinimumPageScaleFactor());
   EXPECT_FLOAT_EQ(5.0, web_view_impl->MaximumPageScaleFactor());
 
   Document* document =
       web_view_impl->MainFrameImpl()->GetFrame()->GetDocument();
   UserGestureIndicator gesture(UserGestureToken::Create(document));
   Fullscreen::RequestFullscreen(*document->documentElement());
   web_view_impl->DidEnterFullscreen();
+  web_view_impl->BeginFrame(WTF::MonotonicallyIncreasingTime());
   web_view_impl->UpdateAllLifecyclePhases();
   EXPECT_EQ(384, layout_view_item.LogicalWidth().Floor());
   EXPECT_EQ(640, layout_view_item.LogicalHeight().Floor());
   EXPECT_FLOAT_EQ(1.0, web_view_impl->PageScaleFactor());
   EXPECT_FLOAT_EQ(1.0, web_view_impl->MinimumPageScaleFactor());
   EXPECT_FLOAT_EQ(1.0, web_view_impl->MaximumPageScaleFactor());
 
   web_view_impl->DidExitFullscreen();
+  web_view_impl->BeginFrame(WTF::MonotonicallyIncreasingTime());
   web_view_impl->UpdateAllLifecyclePhases();
   EXPECT_EQ(320, layout_view_item.LogicalWidth().Floor());
   EXPECT_EQ(533, layout_view_item.LogicalHeight().Floor());
   EXPECT_FLOAT_EQ(1.2, web_view_impl->PageScaleFactor());
   EXPECT_FLOAT_EQ(1.2, web_view_impl->MinimumPageScaleFactor());
   EXPECT_FLOAT_EQ(5.0, web_view_impl->MaximumPageScaleFactor());
 }
 
 TEST_P(ParameterizedWebFrameTest, FullscreenResizeWithTinyViewport) {
   FakeCompositingWebViewClient client;
@@ skipping 11 matching lines @@
 
   LayoutViewItem layout_view_item = web_view_helper.WebView()
                                         ->MainFrameImpl()
                                         ->GetFrameView()
                                         ->GetLayoutViewItem();
   Document* document =
       web_view_impl->MainFrameImpl()->GetFrame()->GetDocument();
   UserGestureIndicator gesture(UserGestureToken::Create(document));
   Fullscreen::RequestFullscreen(*document->documentElement());
   web_view_impl->DidEnterFullscreen();
+  web_view_impl->BeginFrame(WTF::MonotonicallyIncreasingTime());
   web_view_impl->UpdateAllLifecyclePhases();
   EXPECT_EQ(384, layout_view_item.LogicalWidth().Floor());
   EXPECT_EQ(640, layout_view_item.LogicalHeight().Floor());
   EXPECT_FLOAT_EQ(1.0, web_view_impl->PageScaleFactor());
   EXPECT_FLOAT_EQ(1.0, web_view_impl->MinimumPageScaleFactor());
   EXPECT_FLOAT_EQ(1.0, web_view_impl->MaximumPageScaleFactor());
 
   viewport_width = 640;
   viewport_height = 384;
   client.screen_info_.rect.width = viewport_width;
   client.screen_info_.rect.height = viewport_height;
   web_view_helper.Resize(WebSize(viewport_width, viewport_height));
   web_view_impl->UpdateAllLifecyclePhases();
   EXPECT_EQ(640, layout_view_item.LogicalWidth().Floor());
   EXPECT_EQ(384, layout_view_item.LogicalHeight().Floor());
   EXPECT_FLOAT_EQ(1.0, web_view_impl->PageScaleFactor());
   EXPECT_FLOAT_EQ(1.0, web_view_impl->MinimumPageScaleFactor());
   EXPECT_FLOAT_EQ(1.0, web_view_impl->MaximumPageScaleFactor());
 
   web_view_impl->DidExitFullscreen();
+  web_view_impl->BeginFrame(WTF::MonotonicallyIncreasingTime());
   web_view_impl->UpdateAllLifecyclePhases();
   EXPECT_EQ(320, layout_view_item.LogicalWidth().Floor());
   EXPECT_EQ(192, layout_view_item.LogicalHeight().Floor());
   EXPECT_FLOAT_EQ(2, web_view_impl->PageScaleFactor());
   EXPECT_FLOAT_EQ(2, web_view_impl->MinimumPageScaleFactor());
   EXPECT_FLOAT_EQ(5.0, web_view_impl->MaximumPageScaleFactor());
 }
 
 TEST_P(ParameterizedWebFrameTest, FullscreenRestoreScaleFactorUponExiting) {
   // The purpose of this test is to more precisely simulate the sequence of
@@ skipping 28 matching lines @@
   EXPECT_FLOAT_EQ(5.0, web_view_impl->MaximumPageScaleFactor());
 
   {
     Document* document =
         web_view_impl->MainFrameImpl()->GetFrame()->GetDocument();
     UserGestureIndicator gesture(UserGestureToken::Create(document));
     Fullscreen::RequestFullscreen(*document->body());
   }
 
   web_view_impl->DidEnterFullscreen();
+  web_view_impl->BeginFrame(WTF::MonotonicallyIncreasingTime());
   web_view_impl->UpdateAllLifecyclePhases();
   client.screen_info_.rect.width = screen_size_minus_status_bars.width;
   client.screen_info_.rect.height = screen_size_minus_status_bars.height;
   web_view_helper.Resize(screen_size_minus_status_bars);
   client.screen_info_.rect.width = screen_size.width;
   client.screen_info_.rect.height = screen_size.height;
   web_view_helper.Resize(screen_size);
   EXPECT_EQ(screen_size.width, layout_view_item.LogicalWidth().Floor());
   EXPECT_EQ(screen_size.height, layout_view_item.LogicalHeight().Floor());
   EXPECT_FLOAT_EQ(1.0, web_view_impl->PageScaleFactor());
   EXPECT_FLOAT_EQ(1.0, web_view_impl->MinimumPageScaleFactor());
   EXPECT_FLOAT_EQ(1.0, web_view_impl->MaximumPageScaleFactor());
 
   web_view_impl->DidExitFullscreen();
+  web_view_impl->BeginFrame(WTF::MonotonicallyIncreasingTime());
   web_view_impl->UpdateAllLifecyclePhases();
   client.screen_info_.rect.width = screen_size_minus_status_bars.width;
   client.screen_info_.rect.height = screen_size_minus_status_bars.height;
   web_view_helper.Resize(screen_size_minus_status_bars);
   client.screen_info_.rect.width =
       screen_size_minus_status_bars_minus_url_bar.width;
   client.screen_info_.rect.height =
       screen_size_minus_status_bars_minus_url_bar.height;
   web_view_helper.Resize(screen_size_minus_status_bars_minus_url_bar);
   EXPECT_EQ(screen_size_minus_status_bars_minus_url_bar.width,
@@ skipping 28 matching lines @@
   EXPECT_FLOAT_EQ(0.3125, web_view_impl->PageScaleFactor());
   EXPECT_FLOAT_EQ(0.3125, web_view_impl->MinimumPageScaleFactor());
   EXPECT_FLOAT_EQ(5.0, web_view_impl->MaximumPageScaleFactor());
 
   Document* document =
       web_view_impl->MainFrameImpl()->GetFrame()->GetDocument();
   UserGestureIndicator gesture(
       UserGestureToken::Create(document, UserGestureToken::kNewGesture));
   Fullscreen::RequestFullscreen(*document->documentElement());
   web_view_impl->DidEnterFullscreen();
+  web_view_impl->BeginFrame(WTF::MonotonicallyIncreasingTime());
   web_view_impl->UpdateAllLifecyclePhases();
 
   // Entering fullscreen causes layout size and page scale limits to be
   // overridden.
   EXPECT_EQ(100, layout_view_item.LogicalWidth().Floor());
   EXPECT_EQ(200, layout_view_item.LogicalHeight().Floor());
   EXPECT_FLOAT_EQ(1.0, web_view_impl->PageScaleFactor());
   EXPECT_FLOAT_EQ(1.0, web_view_impl->MinimumPageScaleFactor());
   EXPECT_FLOAT_EQ(1.0, web_view_impl->MaximumPageScaleFactor());
 
   const char kSource[] = "<meta name=\"viewport\" content=\"width=200\">";
 
   // Load a new page before exiting fullscreen.
   KURL test_url = ToKURL("about:blank");
   WebFrame* frame = web_view_helper.WebView()->MainFrame();
   FrameTestHelpers::LoadHTMLString(frame, kSource, test_url);
   web_view_impl->DidExitFullscreen();
+  web_view_impl->BeginFrame(WTF::MonotonicallyIncreasingTime());
   web_view_impl->UpdateAllLifecyclePhases();
 
   // Make sure the new page's layout size and scale factor limits aren't
   // overridden.
   layout_view_item =
       web_view_impl->MainFrameImpl()->GetFrameView()->GetLayoutViewItem();
   EXPECT_EQ(200, layout_view_item.LogicalWidth().Floor());
   EXPECT_EQ(400, layout_view_item.LogicalHeight().Floor());
   EXPECT_FLOAT_EQ(0.5, web_view_impl->MinimumPageScaleFactor());
   EXPECT_FLOAT_EQ(5.0, web_view_impl->MaximumPageScaleFactor());
@@ skipping 29 matching lines @@
 
   const TestFullscreenWebLayerTreeView& layer_tree_view =
       web_view_client.test_fullscreen_layer_tree_view;
 
   Document* document =
       web_view_impl->MainFrameImpl()->GetFrame()->GetDocument();
   UserGestureIndicator gesture(UserGestureToken::Create(document));
   HTMLVideoElement* video =
       toHTMLVideoElement(document->getElementById("video"));
   EXPECT_TRUE(video->UsesOverlayFullscreenVideo());
-  EXPECT_FALSE(video->IsFullscreen());
-  EXPECT_FALSE(layer_tree_view.has_transparent_background);
 
   video->webkitEnterFullscreen();
   web_view_impl->DidEnterFullscreen();
-  web_view_impl->UpdateAllLifecyclePhases();
+  EXPECT_FALSE(video->IsFullscreen());
+  EXPECT_FALSE(layer_tree_view.has_transparent_background);
+  web_view_impl->BeginFrame(WTF::MonotonicallyIncreasingTime());
   EXPECT_TRUE(video->IsFullscreen());
   EXPECT_TRUE(layer_tree_view.has_transparent_background);
+  web_view_impl->UpdateAllLifecyclePhases();
 
   web_view_impl->DidExitFullscreen();
-  web_view_impl->UpdateAllLifecyclePhases();
+  EXPECT_TRUE(video->IsFullscreen());
+  EXPECT_TRUE(layer_tree_view.has_transparent_background);
+  web_view_impl->BeginFrame(WTF::MonotonicallyIncreasingTime());
   EXPECT_FALSE(video->IsFullscreen());
   EXPECT_FALSE(layer_tree_view.has_transparent_background);
+  web_view_impl->UpdateAllLifecyclePhases();
 }
 
 TEST_P(ParameterizedWebFrameTest, LayoutBlockPercentHeightDescendants) {
   RegisterMockedHttpURLLoad("percent-height-descendants.html");
   FrameTestHelpers::WebViewHelper web_view_helper;
   web_view_helper.InitializeAndLoad(base_url_ +
                                     "percent-height-descendants.html");
 
   WebViewBase* web_view = web_view_helper.WebView();
   web_view_helper.Resize(WebSize(800, 800));
@@ skipping 3603 matching lines @@
     if (obj->IsText()) {
       LayoutText* layout_text = ToLayoutText(obj);
       text = layout_text->GetText();
       break;
     }
   }
   EXPECT_EQ("foo alt", text.Utf8());
 }
 
 }  // namespace blink