Allow local root FrameView to be throttled

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

 // Copyright 2015 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 "config.h"
 
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/frame/FrameView.h"
 #include "core/html/HTMLIFrameElement.h"
+#include "platform/testing/URLTestHelpers.h"
 #include "platform/testing/UnitTestHelpers.h"
 #include "public/web/WebHitTestResult.h"
+#include "public/web/WebRemoteFrame.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "web/WebLocalFrameImpl.h"
 #include "web/tests/sim/SimCompositor.h"
 #include "web/tests/sim/SimDisplayItemList.h"
 #include "web/tests/sim/SimRequest.h"
 #include "web/tests/sim/SimTest.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
 // NOTE: This test uses <iframe sandbox> to create cross origin iframes.
@@ skipping 222 matching lines @@
 
     // Change the size of a div in the throttled frame.
     auto* divElement = frameElement->contentDocument()->getElementById("div");
     divElement->setAttribute(styleAttr, "width: 50px");
 
     // Querying the width of the div should do a synchronous layout update even
     // though the frame is being throttled.
     EXPECT_EQ(50, divElement->clientWidth());
 }
 
+TEST(RemoteFrameThrottlingTest, ThrottledLocalRoot)
+{
+    FrameTestHelpers::TestWebViewClient viewClient;
+    WebViewImpl* webView = WebViewImpl::create(&viewClient);
+    webView->resize(WebSize(640, 480));
+
+    // Create a remote root frame with a local child frame.
+    FrameTestHelpers::TestWebRemoteFrameClient remoteClient;
+    webView->setMainFrame(remoteClient.frame());
+    remoteClient.frame()->setReplicatedOrigin(WebSecurityOrigin::createUnique());
+
+    WebFrameOwnerProperties properties;
+    FrameTestHelpers::TestWebFrameClient localFrameClient;
+    WebRemoteFrame* rootFrame = webView->mainFrame()->toWebRemoteFrame();
+    WebLocalFrame* localFrame = rootFrame->createLocalChild(WebTreeScopeType::Document, "", WebSandboxFlags::None, &localFrameClient, nullptr, properties);
+
+    std::string baseURL("http://internal.test/");
+    URLTestHelpers::registerMockedURLFromBaseURL(WebString::fromUTF8(baseURL.c_str()), WebString::fromUTF8("simple_div.html"));
+    FrameTestHelpers::loadFrame(localFrame, baseURL + "simple_div.html");
+
+    FrameView* frameView = toWebLocalFrameImpl(localFrame)->frameView();
+    EXPECT_TRUE(frameView->frame().isLocalRoot());
+
+    // Enable throttling for the child frame.
+    frameView->setFrameRect(IntRect(0, 480, frameView->width(), frameView->height()));
+    frameView->frame().securityContext()->setSecurityOrigin(SecurityOrigin::createUnique());
+    frameView->updateAllLifecyclePhases();

[ojan, 2015/12/01 01:11:05]

Can this be tested via pumping a frame through the Sim framework instead of
hooking into frameView directly? I have a vision of limiting the APIs the Sim
framework has access to C++ bindings generated from the web IDL + some accessors
for reading internal state (e.g. the document lifecycle state). So, if we can, I
want to avoid cases where we modify internal state by hooking internals of the
code. My goal here is to not add too much test-specific dependencies to the code
and to make sure the tests keep testing things that can happen in the real
world. For example, this case can happen today, but not necessarily in the same
way in the future as the code that calls updateAllLifecyclePhases changes.

As to creating a remote root without poking at the internals, it would
definitely be ideal if we could find a way to enable the oopif flag and create
the frames without poking at internals. Maybe someone on the oopif (cc'ed) team
can help figure this out?

[Charlie Reis, 2015/12/01 23:24:46]

Daniel, can you check whether there's a better way to exercise RemoteFrames in
Blink tests, per Ojan's question?  The test looks similar to the
WebFrameSwapTests (e.g., the RemoteToLocal ones) to me, so I'm not sure if
there's something better to use.

[dcheng, 2015/12/02 22:42:28]

oopi isn't really controlled by any flags in Blink itself: it's something
controlled by the embedder. Unfortunately, that means a lot of hand-rolled code
today. I'm hoping to integrate it better into FrameTestHelpers::WebViewHelper:
the way I imagine it, tests would be able to supply a policy object, and
FrameTestHelpers would use it to create local/remote frames as appropriate.
Layout tests would probably have to interact with window.internals to get the
exact behavior they want though.

The main problem is we still need some abstractions in the test layer to
represent this: today, the notion of a local frame and its associated remote
frames is all maintained in //content, and nothing of that sort exists in
Blink... yet. I'm hoping to tackle this in January.

+    testing::runPendingTasks();
+    EXPECT_TRUE(frameView->shouldThrottleRendering());
+
+    Document* frameDocument = frameView->frame().document();
+    if (RuntimeEnabledFeatures::slimmingPaintSynchronizedPaintingEnabled())
+        EXPECT_EQ(DocumentLifecycle::PaintClean, frameDocument->lifecycle().state());
+    else
+        EXPECT_EQ(DocumentLifecycle::PaintInvalidationClean, frameDocument->lifecycle().state());
+
+    // Mutate the local child frame contents.
+    auto* divElement = frameDocument->getElementById("div");
+    divElement->setAttribute(styleAttr, "width: 50px");
+    EXPECT_EQ(DocumentLifecycle::VisualUpdatePending, frameDocument->lifecycle().state());
+
+    // Update the lifecycle again. The frame's lifecycle should not advance
+    // because of throttling even though it is the local root.
+    frameView->updateAllLifecyclePhases();
+    testing::runPendingTasks();
+    EXPECT_EQ(DocumentLifecycle::VisualUpdatePending, frameDocument->lifecycle().state());
+}
+
 } // namespace blink