Allow throttling in painting microbenchmark

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 "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/frame/FrameView.h"
 #include "core/html/HTMLIFrameElement.h"
 #include "core/page/FocusController.h"
 #include "core/page/Page.h"
 #include "core/paint/PaintLayer.h"
 #include "platform/testing/URLTestHelpers.h"
 #include "platform/testing/UnitTestHelpers.h"
+#include "public/platform/WebDisplayItemList.h"
 #include "public/platform/WebLayer.h"
 #include "public/web/WebHitTestResult.h"
 #include "public/web/WebSettings.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "web/WebLocalFrameImpl.h"
 #include "web/WebRemoteFrameImpl.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"
 
+using testing::_;
+
 namespace blink {
 
 using namespace HTMLNames;
 
 // NOTE: This test uses <iframe sandbox> to create cross origin iframes.
 
+namespace {
+
+class MockWebDisplayItemList : public WebDisplayItemList {
+public:
+    ~MockWebDisplayItemList() override {}
+
+    MOCK_METHOD2(appendDrawingItem, void(const WebRect&, sk_sp<const SkPicture>));
+};
+
+void paintRecursively(GraphicsLayer* layer, WebDisplayItemList* displayItems)
+{
+    if (layer->drawsContent()) {
+        layer->setNeedsDisplay();
+        layer->contentLayerDelegateForTesting()->paintContents(displayItems, ContentLayerDelegate::PaintDefaultBehaviorForTest);
+    }
+    for (const auto& child : layer->children())
+        paintRecursively(child, displayItems);
+}
+
+} // namespace
+
 class FrameThrottlingTest : public SimTest {
 protected:
     FrameThrottlingTest()
     {
         webView().resize(WebSize(640, 480));
     }
 
     SimDisplayItemList compositeFrame()
     {
         SimDisplayItemList displayItems = compositor().beginFrame();
@@ skipping 573 matching lines @@
     // The touch handler in the throttled frame should have been ignored.
     EXPECT_EQ(0u, touchHandlerRegionSize());
 
     // Unthrottling the frame makes the touch handler active again.
     frameElement->setAttribute(styleAttr, "transform: translateY(0px)");
     compositeFrame(); // Unthrottle the frame.
     compositeFrame(); // Update touch handler regions.
     EXPECT_EQ(1u, touchHandlerRegionSize());
 }
 
+TEST_F(FrameThrottlingTest, PaintingViaContentLayerDelegateIsThrottled)
+{
+    webView().settings()->setAcceleratedCompositingEnabled(true);
+    webView().settings()->setPreferCompositingToLCDTextEnabled(true);
+
+    // Create a hidden frame which is throttled.
+    SimRequest mainResource("https://example.com/", "text/html");
+    SimRequest frameResource("https://example.com/iframe.html", "text/html");
+
+    loadURL("https://example.com/");
+    mainResource.complete("<iframe id=frame sandbox src=iframe.html></iframe>");
+    frameResource.complete("throttled");
+    compositeFrame();
+
+    // Move the frame offscreen to throttle it and make sure it is backed by a
+    // graphics layer.
+    auto* frameElement = toHTMLIFrameElement(document().getElementById("frame"));
+    frameElement->setAttribute(styleAttr, "transform: translateY(480px) translateZ(0px)");
+    EXPECT_FALSE(frameElement->contentDocument()->view()->canThrottleRendering());
+    compositeFrame();
+    EXPECT_TRUE(frameElement->contentDocument()->view()->canThrottleRendering());
+
+    // If painting of the iframe is throttled, we should only receive two
+    // drawing items.
+    MockWebDisplayItemList displayItems;
+    EXPECT_CALL(displayItems, appendDrawingItem(_, _))
+        .Times(2);
+
+    GraphicsLayer* layer = webView().rootGraphicsLayer();
+    paintRecursively(layer, &displayItems);

[ojan, 2016/04/28 21:47:27]

Specifically, this is not a thing that can happen on the web, right? (painting
outside of a lifecycle update)

[Xianzhu, 2016/04/28 21:56:32]

Right.

However, I think this is why we call rasterize_and_record_micro a micro
benchmark: it provides several controlled modes to simulate extreme conditions
(e.g. no caching, no subsequence caching but have display item caching, no
painting, etc.) to expose micro aspects of painting performance.

For painting performance in real scenarios, we can use the UMA performance
measurements. We can also collect the UMA performance measurements in a
benchmark.

+}
+
 } // namespace blink