Allow local root FrameView to be throttled

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

Index: third_party/WebKit/Source/web/tests/FrameThrottlingTest.cpp
diff --git a/third_party/WebKit/Source/web/tests/FrameThrottlingTest.cpp b/third_party/WebKit/Source/web/tests/FrameThrottlingTest.cpp
index 3cf525b4b3b4c1016fab1b12c33111700b20dba3..26d0c87787839786dbbf754d48f386e93416f6dd 100644
--- a/third_party/WebKit/Source/web/tests/FrameThrottlingTest.cpp
+++ b/third_party/WebKit/Source/web/tests/FrameThrottlingTest.cpp
@@ -8,9 +8,12 @@
 #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"
@@ -253,4 +256,52 @@ TEST_F(FrameThrottlingTest, SynchronousLayoutInThrottledFrame)
     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