// 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 "third_party/blink/renderer/core/paint/paint_layer_painter.h"

#include "testing/gmock/include/gmock/gmock.h"
#include "third_party/blink/renderer/core/layout/layout_box_model_object.h"
#include "third_party/blink/renderer/core/paint/compositing/composited_layer_mapping.h"
#include "third_party/blink/renderer/core/paint/paint_controller_paint_test.h"
#include "third_party/blink/renderer/platform/graphics/graphics_context.h"
#include "third_party/blink/renderer/platform/testing/paint_property_test_helpers.h"
#include "third_party/blink/renderer/platform/testing/runtime_enabled_features_test_helpers.h"

using testing::Contains;
using testing::ElementsAre;
using testing::UnorderedElementsAre;

namespace blink {

class PaintLayerPainterTest : public PaintControllerPaintTest {
  USING_FAST_MALLOC(PaintLayerPainterTest);

 public:
  void ExpectPaintedOutputInvisibleAndPaintsWithTransparency(
      const char* element_name,
      bool expected_invisible,
      bool expected_paints_with_transparency) {
    // The optimization to skip painting for effectively-invisible content is
    // limited to pre-CAP.
    if (RuntimeEnabledFeatures::CompositeAfterPaintEnabled())
      return;

    PaintLayer* target_layer = GetPaintLayerByElementId(element_name);
    bool invisible = PaintLayerPainter::PaintedOutputInvisible(
        target_layer->GetLayoutObject().StyleRef());
    EXPECT_EQ(expected_invisible, invisible);
    EXPECT_EQ(expected_paints_with_transparency,
              target_layer->PaintsWithTransparency(kGlobalPaintNormalPhase));
  }

  PaintController& MainGraphicsLayerPaintController() {
    return GetLayoutView()
        .Layer()
        ->GraphicsLayerBacking(&GetLayoutView())
        ->GetPaintController();
  }

  CullRect GetCullRect(const PaintLayer& layer) {
    if (RuntimeEnabledFeatures::CullRectUpdateEnabled())
      return layer.GetLayoutObject().FirstFragment().GetCullRect();
    return layer.PreviousCullRect();
  }
};

INSTANTIATE_PAINT_TEST_SUITE_P(PaintLayerPainterTest);

TEST_P(PaintLayerPainterTest, CachedSubsequenceAndChunksWithBackgrounds) {
  SetBodyInnerHTML(R"HTML(
    <style>body { margin: 0 }</style>
    <div id='container1' style='position: relative; z-index: 1;
        width: 200px; height: 200px; background-color: blue'>
      <div id='content1' style='position: absolute; width: 100px;
          height: 100px; background-color: red'></div>
    </div>
    <div id='filler1' style='position: relative; z-index: 2;
        width: 20px; height: 20px; background-color: gray'></div>
    <div id='container2' style='position: relative; z-index: 3;
        width: 200px; height: 200px; background-color: blue'>
      <div id='content2' style='position: absolute; width: 100px;
          height: 100px; background-color: green;'></div>
    </div>
    <div id='filler2' style='position: relative; z-index: 4;
        width: 20px; height: 20px; background-color: gray'></div>
  )HTML");

  auto* container1 = GetLayoutObjectByElementId("container1");
  auto* content1 = GetLayoutObjectByElementId("content1");
  auto* filler1 = GetLayoutObjectByElementId("filler1");
  auto* container2 = GetLayoutObjectByElementId("container2");
  auto* content2 = GetLayoutObjectByElementId("content2");
  auto* filler2 = GetLayoutObjectByElementId("filler2");

  auto* container1_layer = To<LayoutBoxModelObject>(container1)->Layer();
  auto* filler1_layer = To<LayoutBoxModelObject>(filler1)->Layer();
  auto* container2_layer = To<LayoutBoxModelObject>(container2)->Layer();
  auto* filler2_layer = To<LayoutBoxModelObject>(filler2)->Layer();
  auto chunk_state = GetLayoutView().FirstFragment().ContentsProperties();

  auto check_results = [&]() {
    EXPECT_THAT(
        ContentDisplayItems(),
        ElementsAre(VIEW_SCROLLING_BACKGROUND_DISPLAY_ITEM,
                    IsSameId(GetDisplayItemClientFromLayoutObject(container1),
                             kBackgroundType),
                    IsSameId(GetDisplayItemClientFromLayoutObject(content1),
                             kBackgroundType),
                    IsSameId(GetDisplayItemClientFromLayoutObject(filler1),
                             kBackgroundType),
                    IsSameId(GetDisplayItemClientFromLayoutObject(container2),
                             kBackgroundType),
                    IsSameId(GetDisplayItemClientFromLayoutObject(content2),
                             kBackgroundType),
                    IsSameId(GetDisplayItemClientFromLayoutObject(filler2),
                             kBackgroundType)));

    // Check that new paint chunks were forced for the layers.
    auto chunks = ContentPaintChunks();
    EXPECT_SUBSEQUENCE_FROM_CHUNK(*container1_layer, chunks.begin() + 1, 1);
    EXPECT_SUBSEQUENCE_FROM_CHUNK(*filler1_layer, chunks.begin() + 2, 1);
    EXPECT_SUBSEQUENCE_FROM_CHUNK(*container2_layer, chunks.begin() + 3, 1);
    EXPECT_SUBSEQUENCE_FROM_CHUNK(*filler2_layer, chunks.begin() + 4, 1);

    EXPECT_THAT(
        chunks,
        ElementsAre(
            VIEW_SCROLLING_BACKGROUND_CHUNK_COMMON,
            IsPaintChunk(
                1, 3,
                PaintChunk::Id(*container1_layer, DisplayItem::kLayerChunk),
                chunk_state, nullptr, IntRect(0, 0, 200, 200)),
            IsPaintChunk(
                3, 4, PaintChunk::Id(*filler1_layer, DisplayItem::kLayerChunk),
                chunk_state, nullptr, IntRect(0, 200, 20, 20)),
            IsPaintChunk(
                4, 6,
                PaintChunk::Id(*container2_layer, DisplayItem::kLayerChunk),
                chunk_state, nullptr, IntRect(0, 220, 200, 200)),
            IsPaintChunk(
                6, 7, PaintChunk::Id(*filler2_layer, DisplayItem::kLayerChunk),
                chunk_state, nullptr, IntRect(0, 420, 20, 20))));
  };

  check_results();

  To<HTMLElement>(content1->GetNode())
      ->setAttribute(html_names::kStyleAttr,
                     "position: absolute; width: 100px; height: 100px; "
                     "background-color: green");
  CachedItemAndSubsequenceCounter counter;
  UpdateAllLifecyclePhasesForTest();
  EXPECT_EQ(6u, counter.NumNewCachedItems());
  EXPECT_EQ(3u, counter.NumNewCachedSubsequences());

  // We should still have the paint chunks forced by the cached subsequences.
  check_results();
}

TEST_P(PaintLayerPainterTest, CachedSubsequenceAndChunksWithoutBackgrounds) {
  if (!RuntimeEnabledFeatures::CompositeAfterPaintEnabled())
    return;

  SetBodyInnerHTML(R"HTML(
    <style>
      body { margin: 0 }
      ::-webkit-scrollbar { display: none }
    </style>
    <div id='container' style='position: relative; z-index: 0;
        width: 150px; height: 150px; overflow: scroll'>
      <div id='content' style='position: relative; z-index: 1;
          width: 200px; height: 100px'>
        <div id='inner-content'
             style='position: absolute; width: 100px; height: 100px'></div>
      </div>
      <div id='filler' style='position: relative; z-index: 2;
          width: 300px; height: 300px'></div>
    </div>
  )HTML");

  auto* container = GetLayoutObjectByElementId("container");
  auto* content = GetLayoutObjectByElementId("content");
  auto* inner_content = GetLayoutObjectByElementId("inner-content");
  auto* filler = GetLayoutObjectByElementId("filler");

  EXPECT_THAT(ContentDisplayItems(),
              ElementsAre(VIEW_SCROLLING_BACKGROUND_DISPLAY_ITEM));

  auto* container_layer = To<LayoutBoxModelObject>(container)->Layer();
  auto* content_layer = To<LayoutBoxModelObject>(content)->Layer();
  auto* inner_content_layer = To<LayoutBoxModelObject>(inner_content)->Layer();
  auto* filler_layer = To<LayoutBoxModelObject>(filler)->Layer();

  auto chunks = ContentPaintChunks();
  EXPECT_SUBSEQUENCE_FROM_CHUNK(*container_layer, chunks.begin() + 1, 4);
  EXPECT_SUBSEQUENCE_FROM_CHUNK(*content_layer, chunks.begin() + 3, 1);
  EXPECT_SUBSEQUENCE_FROM_CHUNK(*filler_layer, chunks.begin() + 4, 1);

  auto container_properties =
      container->FirstFragment().LocalBorderBoxProperties();
  auto content_properties = container->FirstFragment().ContentsProperties();
  HitTestData scroll_hit_test;
  scroll_hit_test.scroll_translation =
      container->FirstFragment().PaintProperties()->ScrollTranslation();
  scroll_hit_test.scroll_hit_test_rect = IntRect(0, 0, 150, 150);

  EXPECT_THAT(
      chunks,
      ElementsAre(
          VIEW_SCROLLING_BACKGROUND_CHUNK_COMMON,
          IsPaintChunk(
              1, 1, PaintChunk::Id(*container_layer, DisplayItem::kLayerChunk),
              container_properties, nullptr, IntRect(0, 0, 150, 150)),
          IsPaintChunk(
              1, 1, PaintChunk::Id(*container, DisplayItem::kScrollHitTest),
              container_properties, &scroll_hit_test, IntRect(0, 0, 150, 150)),
          IsPaintChunk(1, 1,
                       PaintChunk::Id(*content_layer, DisplayItem::kLayerChunk),
                       content_properties, nullptr, IntRect(0, 0, 200, 100)),
          IsPaintChunk(
              1, 1, PaintChunk::Id(*filler_layer, DisplayItem::kLayerChunk),
              content_properties, nullptr, IntRect(0, 100, 300, 300))));

  To<HTMLElement>(inner_content->GetNode())
      ->setAttribute(html_names::kStyleAttr,
                     "position: absolute; width: 100px; height: 100px; "
                     "top: 100px; background-color: green");
  UpdateAllLifecyclePhasesForTest();

  EXPECT_THAT(
      ContentDisplayItems(),
      ElementsAre(VIEW_SCROLLING_BACKGROUND_DISPLAY_ITEM,
                  IsSameId(GetDisplayItemClientFromLayoutObject(inner_content),
                           kBackgroundType)));

  chunks = ContentPaintChunks();
  EXPECT_SUBSEQUENCE_FROM_CHUNK(*container_layer, chunks.begin() + 1, 5);
  EXPECT_SUBSEQUENCE_FROM_CHUNK(*content_layer, chunks.begin() + 3, 2);
  EXPECT_SUBSEQUENCE_FROM_CHUNK(*filler_layer, chunks.begin() + 5, 1);

  EXPECT_THAT(
      ContentPaintChunks(),
      ElementsAre(
          VIEW_SCROLLING_BACKGROUND_CHUNK_COMMON,
          IsPaintChunk(
              1, 1, PaintChunk::Id(*container_layer, DisplayItem::kLayerChunk),
              container_properties, nullptr, IntRect(0, 0, 150, 150)),
          IsPaintChunk(
              1, 1, PaintChunk::Id(*container, DisplayItem::kScrollHitTest),
              container_properties, &scroll_hit_test, IntRect(0, 0, 150, 150)),
          IsPaintChunk(1, 1,
                       PaintChunk::Id(*content_layer, DisplayItem::kLayerChunk),
                       content_properties, nullptr, IntRect(0, 0, 200, 100)),
          IsPaintChunk(
              1, 2,
              PaintChunk::Id(*inner_content_layer, DisplayItem::kLayerChunk),
              content_properties, nullptr, IntRect(0, 100, 100, 100)),
          IsPaintChunk(
              2, 2, PaintChunk::Id(*filler_layer, DisplayItem::kLayerChunk),
              content_properties, nullptr, IntRect(0, 100, 300, 300))));
}

TEST_P(PaintLayerPainterTest, CachedSubsequenceOnCullRectChange) {
  // This test doesn't work in CompositeAfterPaint mode because we always paint
  // from the local root frame view, and we always expand cull rect for
  // scrolling.
  if (RuntimeEnabledFeatures::CompositeAfterPaintEnabled())
    return;

  SetBodyInnerHTML(R"HTML(
    <div id='container1' style='position: relative; z-index: 1;
       width: 200px; height: 200px; background-color: blue'>
      <div id='content1' style='position: absolute; width: 100px;
          height: 100px; background-color: green'></div>
    </div>
    <div id='container2' style='position: relative; z-index: 1;
        width: 200px; height: 200px; background-color: blue'>
      <div id='content2a' style='position: absolute; width: 100px;
          height: 100px; background-color: green'></div>
      <div id='content2b' style='position: absolute; top: 200px;
          width: 100px; height: 100px; background-color: green'></div>
    </div>
    <div id='container3' style='position: absolute; z-index: 2;
        left: 300px; top: 0; width: 200px; height: 200px;
        background-color: blue'>
      <div id='content3' style='position: absolute; width: 200px;
          height: 200px; background-color: green'></div>
    </div>
  )HTML");
  InvalidateAll();

  const DisplayItemClient& container1 =
      *GetDisplayItemClientFromElementId("container1");
  const DisplayItemClient& content1 =
      *GetDisplayItemClientFromElementId("content1");
  const DisplayItemClient& container2 =
      *GetDisplayItemClientFromElementId("container2");
  const DisplayItemClient& content2a =
      *GetDisplayItemClientFromElementId("content2a");
  const DisplayItemClient& content2b =
      *GetDisplayItemClientFromElementId("content2b");
  const DisplayItemClient& container3 =
      *GetDisplayItemClientFromElementId("container3");
  const DisplayItemClient& content3 =
      *GetDisplayItemClientFromElementId("content3");

  UpdateAllLifecyclePhasesExceptPaint();
  PaintContents(IntRect(0, 0, 400, 300));

  // Container1 is fully in the interest rect;
  // Container2 is partly (including its stacking chidren) in the interest rect;
  // Content2b is out of the interest rect and output nothing;
  // Container3 is partly in the interest rect.
  EXPECT_THAT(ContentDisplayItems(),
              ElementsAre(VIEW_SCROLLING_BACKGROUND_DISPLAY_ITEM,
                          IsSameId(&container1, kBackgroundType),
                          IsSameId(&content1, kBackgroundType),
                          IsSameId(&container2, kBackgroundType),
                          IsSameId(&content2a, kBackgroundType),
                          IsSameId(&container3, kBackgroundType),
                          IsSameId(&content3, kBackgroundType)));

  UpdateAllLifecyclePhasesExceptPaint();
  CachedItemAndSubsequenceCounter counter;
  PaintContents(IntRect(0, 100, 300, 1000));
  // Container1 becomes partly in the interest rect, but uses cached subsequence
  // because it was fully painted before;
  // Container2's intersection with the interest rect changes;
  // Content2b is out of the interest rect and outputs nothing;
  // Container3 becomes out of the interest rect and outputs nothing.
  EXPECT_EQ(5u, counter.NumNewCachedItems());
  EXPECT_EQ(1u, counter.NumNewCachedSubsequences());

  EXPECT_THAT(ContentDisplayItems(),
              ElementsAre(VIEW_SCROLLING_BACKGROUND_DISPLAY_ITEM,
                          IsSameId(&container1, kBackgroundType),
                          IsSameId(&content1, kBackgroundType),
                          IsSameId(&container2, kBackgroundType),
                          IsSameId(&content2a, kBackgroundType),
                          IsSameId(&content2b, kBackgroundType)));
}

TEST_P(PaintLayerPainterTest,
       CachedSubsequenceOnCullRectChangeUnderInvalidationChecking) {
  ScopedPaintUnderInvalidationCheckingForTest under_invalidation_checking(true);

  SetBodyInnerHTML(R"HTML(
    <style>p { width: 200px; height: 50px; background: green }</style>
    <div id='target' style='position: relative; z-index: 1'>
      <p></p><p></p><p></p><p></p>
    </div>
  )HTML");
  InvalidateAll();

  // |target| will be fully painted.
  UpdateAllLifecyclePhasesExceptPaint();
  PaintContents(IntRect(0, 0, 400, 300));

  // |target| will be partially painted. Should not trigger under-invalidation
  // checking DCHECKs.
  UpdateAllLifecyclePhasesExceptPaint();
  PaintContents(IntRect(0, 100, 300, 1000));
}

TEST_P(PaintLayerPainterTest,
       CachedSubsequenceOnStyleChangeWithCullRectClipping) {
  SetBodyInnerHTML(R"HTML(
    <div id='container1' style='position: relative; z-index: 1;
        width: 200px; height: 200px; background-color: blue'>
      <div id='content1' style='position: absolute; width: 100px;
          height: 100px; background-color: red'></div>
    </div>
    <div id='container2' style='position: relative; z-index: 1;
        width: 200px; height: 200px; background-color: blue'>
      <div id='content2' style='position: absolute; width: 100px;
          height: 100px; background-color: green'></div>
    </div>
  )HTML");
  UpdateAllLifecyclePhasesExceptPaint();
  // PaintResult of all subsequences will be MayBeClippedByCullRect.
  PaintContents(IntRect(0, 0, 50, 300));

  const DisplayItemClient& container1 =
      *GetDisplayItemClientFromElementId("container1");
  const DisplayItemClient& content1 =
      *GetDisplayItemClientFromElementId("content1");
  const DisplayItemClient& container2 =
      *GetDisplayItemClientFromElementId("container2");
  const DisplayItemClient& content2 =
      *GetDisplayItemClientFromElementId("content2");

  EXPECT_THAT(ContentDisplayItems(),
              ElementsAre(VIEW_SCROLLING_BACKGROUND_DISPLAY_ITEM,
                          IsSameId(&container1, kBackgroundType),
                          IsSameId(&content1, kBackgroundType),
                          IsSameId(&container2, kBackgroundType),
                          IsSameId(&content2, kBackgroundType)));

  To<HTMLElement>(GetElementById("content1"))
      ->setAttribute(html_names::kStyleAttr,
                     "position: absolute; width: 100px; height: 100px; "
                     "background-color: green");
  UpdateAllLifecyclePhasesExceptPaint();
  CachedItemAndSubsequenceCounter counter;
  PaintContents(IntRect(0, 0, 50, 300));
  EXPECT_EQ(4u, counter.NumNewCachedItems());
  EXPECT_EQ(1u, counter.NumNewCachedSubsequences());

  EXPECT_THAT(ContentDisplayItems(),
              ElementsAre(VIEW_SCROLLING_BACKGROUND_DISPLAY_ITEM,
                          IsSameId(&container1, kBackgroundType),
                          IsSameId(&content1, kBackgroundType),
                          IsSameId(&container2, kBackgroundType),
                          IsSameId(&content2, kBackgroundType)));
}

TEST_P(PaintLayerPainterTest, CachedSubsequenceRetainsPreviousPaintResult) {
  SetBodyInnerHTML(R"HTML(
    <style>
      html, body { height: 100%; margin: 0 }
      ::-webkit-scrollbar { display:none }
    </style>
    <div id="target" style="height: 8000px; contain: paint">
      <div id="content1" style="height: 100px; background: blue"></div>
      <div style="height: 6000px"></div>
      <div id="content2" style="height: 100px; background: blue"></div>
    </div>
    <div id="change" style="display: none"></div>
  )HTML");

  const auto* target = GetLayoutBoxByElementId("target");
  const auto* target_layer = target->Layer();
  const auto* content1 = GetLayoutObjectByElementId("content1");
  const auto* content2 = GetLayoutObjectByElementId("content2");
  // |target| is partially painted.
  EXPECT_EQ(kMayBeClippedByCullRect, target_layer->PreviousPaintResult());
  // |content2| is out of the cull rect.
  EXPECT_THAT(ContentDisplayItems(),
              ElementsAre(VIEW_SCROLLING_BACKGROUND_DISPLAY_ITEM,
                          IsSameId(content1, kBackgroundType)));
  EXPECT_EQ(IntRect(0, 0, 800, 4600), GetCullRect(*target_layer).Rect());
  auto chunks = ContentPaintChunks();
  if (RuntimeEnabledFeatures::CompositeAfterPaintEnabled()) {
    // |target| still created subsequence (cached).
    EXPECT_SUBSEQUENCE_FROM_CHUNK(*target_layer, chunks.begin() + 1, 2);
    EXPECT_THAT(chunks, ElementsAre(VIEW_SCROLLING_BACKGROUND_CHUNK_COMMON,
                                    IsPaintChunk(1, 1), IsPaintChunk(1, 2)));
  } else {
    EXPECT_THAT(ContentDisplayItems(),
                ElementsAre(VIEW_SCROLLING_BACKGROUND_DISPLAY_ITEM,
                            IsSameId(content1, kBackgroundType)));
    // |target| still created subsequence (cached).
    EXPECT_SUBSEQUENCE_FROM_CHUNK(*target_layer, chunks.begin() + 1, 1);
    EXPECT_THAT(chunks, ElementsAre(VIEW_SCROLLING_BACKGROUND_CHUNK_COMMON,
                                    IsPaintChunk(1, 2)));
  }

  // Change something that triggers a repaint but |target| should use cached
  // subsequence.
  GetDocument().getElementById("change")->setAttribute(html_names::kStyleAttr,
                                                       "display: block");
  UpdateAllLifecyclePhasesExceptPaint();
  EXPECT_FALSE(target_layer->SelfNeedsRepaint());
  CachedItemAndSubsequenceCounter counter;
  UpdateAllLifecyclePhasesForTest();
  EXPECT_EQ(2u, counter.NumNewCachedItems());
  EXPECT_EQ(1u, counter.NumNewCachedSubsequences());

  // |target| is still partially painted.
  EXPECT_EQ(kMayBeClippedByCullRect, target_layer->PreviousPaintResult());
  EXPECT_THAT(ContentDisplayItems(),
              ElementsAre(VIEW_SCROLLING_BACKGROUND_DISPLAY_ITEM,
                          IsSameId(content1, kBackgroundType)));
  EXPECT_EQ(IntRect(0, 0, 800, 4600), GetCullRect(*target_layer).Rect());
  chunks = ContentPaintChunks();
  EXPECT_EQ(CullRect(IntRect(0, 0, 800, 4600)), GetCullRect(*target_layer));
  if (RuntimeEnabledFeatures::CompositeAfterPaintEnabled()) {
    EXPECT_THAT(ContentDisplayItems(),
                ElementsAre(VIEW_SCROLLING_BACKGROUND_DISPLAY_ITEM,
                            IsSameId(content1, kBackgroundType)));
    // |target| still created subsequence (cached).
    EXPECT_SUBSEQUENCE_FROM_CHUNK(*target_layer, chunks.begin() + 1, 2);
    EXPECT_THAT(chunks, ElementsAre(VIEW_SCROLLING_BACKGROUND_CHUNK_COMMON,
                                    IsPaintChunk(1, 1), IsPaintChunk(1, 2)));
  } else {
    // |target| still created subsequence (cached).
    EXPECT_SUBSEQUENCE_FROM_CHUNK(*target_layer, chunks.begin() + 1, 1);
    EXPECT_THAT(chunks, ElementsAre(VIEW_SCROLLING_BACKGROUND_CHUNK_COMMON,
                                    IsPaintChunk(1, 2)));
  }

  // Scroll the view so that both |content1| and |content2| are in the interest
  // rect.
  GetLayoutView().GetScrollableArea()->SetScrollOffset(
      ScrollOffset(0, 3000), mojom::blink::ScrollType::kProgrammatic);
  UpdateAllLifecyclePhasesExceptPaint();
  if (RuntimeEnabledFeatures::CullRectUpdateEnabled()) {
    // The layer needs repaint when its contents cull rect changes.
    EXPECT_TRUE(target_layer->SelfNeedsRepaint());
  } else {
    // Scrolling doesn't set SelfNeedsRepaint flag. Change of paint dirty rect
    // of a partially painted layer will trigger repaint.
    EXPECT_FALSE(target_layer->SelfNeedsRepaint());
  }

  counter.Reset();
  UpdateAllLifecyclePhasesForTest();
  EXPECT_EQ(2u, counter.NumNewCachedItems());
  EXPECT_EQ(0u, counter.NumNewCachedSubsequences());

  // |target| is still partially painted.
  EXPECT_EQ(kMayBeClippedByCullRect, target_layer->PreviousPaintResult());
  // Painted result should include both |content1| and |content2|.
  EXPECT_THAT(ContentDisplayItems(),
              ElementsAre(VIEW_SCROLLING_BACKGROUND_DISPLAY_ITEM,
                          IsSameId(content1, kBackgroundType),
                          IsSameId(content2, kBackgroundType)));
  EXPECT_EQ(IntRect(0, 0, 800, 7600), GetCullRect(*target_layer).Rect());
  chunks = ContentPaintChunks();
  EXPECT_EQ(CullRect(IntRect(0, 0, 800, 7600)), GetCullRect(*target_layer));
  if (RuntimeEnabledFeatures::CompositeAfterPaintEnabled()) {
    // |target| still created subsequence (repainted).
    EXPECT_SUBSEQUENCE_FROM_CHUNK(*target_layer, chunks.begin() + 1, 2);
    EXPECT_THAT(chunks, ElementsAre(VIEW_SCROLLING_BACKGROUND_CHUNK_COMMON,
                                    IsPaintChunk(1, 1), IsPaintChunk(1, 3)));
  } else {
    // |target| still created subsequence (repainted).
    EXPECT_SUBSEQUENCE_FROM_CHUNK(*target_layer, chunks.begin() + 1, 1);
    EXPECT_THAT(chunks, ElementsAre(VIEW_SCROLLING_BACKGROUND_CHUNK_COMMON,
                                    IsPaintChunk(1, 3)));
  }
}

TEST_P(PaintLayerPainterTest, HintedPaintChunksWithBackgrounds) {
  SetBodyInnerHTML(R"HTML(
    <style>
      body { margin: 0 }
      div { background: blue }
    </style>
    <div id='container1' style='position: relative; height: 150px; z-index: 1'>
      <div id='content1a' style='position: relative; height: 100px'></div>
      <div id='content1b' style='position: relative; height: 100px'></div>
    </div>
    <div id='container2' style='position: relative; z-index: 1'>
      <div id='content2a' style='position: relative; height: 100px'></div>
      <div id='content2b' style='position: relative; z-index: -1; height: 100px'></div>
    </div>
  )HTML");

  auto* container1 = GetLayoutBoxByElementId("container1");
  auto* content1a = GetLayoutBoxByElementId("content1a");
  auto* content1b = GetLayoutBoxByElementId("content1b");
  auto* container2 = GetLayoutBoxByElementId("container2");
  auto* content2a = GetLayoutBoxByElementId("content2a");
  auto* content2b = GetLayoutBoxByElementId("content2b");
  auto chunk_state = GetLayoutView().FirstFragment().ContentsProperties();

  EXPECT_THAT(ContentDisplayItems(),
              ElementsAre(VIEW_SCROLLING_BACKGROUND_DISPLAY_ITEM,
                          IsSameId(container1, kBackgroundType),
                          IsSameId(content1a, kBackgroundType),
                          IsSameId(content1b, kBackgroundType),
                          IsSameId(container2, kBackgroundType),
                          IsSameId(content2b, kBackgroundType),
                          IsSameId(content2a, kBackgroundType)));

  EXPECT_THAT(
      ContentPaintChunks(),
      ElementsAre(
          VIEW_SCROLLING_BACKGROUND_CHUNK_COMMON,
          // Includes |container1| and |content1a|.
          IsPaintChunk(
              1, 3,
              PaintChunk::Id(*container1->Layer(), DisplayItem::kLayerChunk),
              chunk_state, nullptr, IntRect(0, 0, 800, 150)),
          // Includes |content1b| which overflows |container1|.
          IsPaintChunk(
              3, 4,
              PaintChunk::Id(*content1b->Layer(), DisplayItem::kLayerChunk),
              chunk_state, nullptr, IntRect(0, 100, 800, 100)),
          IsPaintChunk(
              4, 5,
              PaintChunk::Id(*container2->Layer(), DisplayItem::kLayerChunk),
              chunk_state, nullptr, IntRect(0, 150, 800, 200)),
          IsPaintChunk(
              5, 6,
              PaintChunk::Id(*content2b->Layer(), DisplayItem::kLayerChunk),
              chunk_state, nullptr, IntRect(0, 250, 800, 100)),
          IsPaintChunk(
              6, 7,
              PaintChunk::Id(*content2a->Layer(), DisplayItem::kLayerChunk),
              chunk_state, nullptr, IntRect(0, 150, 800, 100))));
}

TEST_P(PaintLayerPainterTest, HintedPaintChunksWithoutBackgrounds) {
  if (!RuntimeEnabledFeatures::CompositeAfterPaintEnabled())
    return;

  SetBodyInnerHTML(R"HTML(
    <style>body { margin: 0 }</style>
    <div id='container1' style='position: relative; height: 150px; z-index: 1'>
      <div id='content1a' style='position: relative; height: 100px'></div>
      <div id='content1b' style='position: relative; height: 100px'></div>
    </div>
    <div id='container2' style='position: relative; z-index: 1'>
      <div id='content2a' style='position: relative; height: 100px'></div>
      <div id='content2b'
           style='position: relative; z-index: -1; height: 100px'></div>
    </div>
  )HTML");

  auto* container1 = GetLayoutBoxByElementId("container1");
  auto* content1b = GetLayoutBoxByElementId("content1b");
  auto* container2 = GetLayoutBoxByElementId("container2");
  auto* content2a = GetLayoutBoxByElementId("content2a");
  auto* content2b = GetLayoutBoxByElementId("content2b");
  auto chunk_state = GetLayoutView().FirstFragment().ContentsProperties();

  EXPECT_THAT(ContentDisplayItems(),
              ElementsAre(VIEW_SCROLLING_BACKGROUND_DISPLAY_ITEM));

  EXPECT_THAT(
      ContentPaintChunks(),
      ElementsAre(
          VIEW_SCROLLING_BACKGROUND_CHUNK_COMMON,
          IsPaintChunk(
              1, 1,
              PaintChunk::Id(*container1->Layer(), DisplayItem::kLayerChunk),
              chunk_state, nullptr, IntRect(0, 0, 800, 150)),
          IsPaintChunk(
              1, 1,
              PaintChunk::Id(*content1b->Layer(), DisplayItem::kLayerChunk),
              chunk_state, nullptr, IntRect(0, 100, 800, 100)),
          IsPaintChunk(
              1, 1,
              PaintChunk::Id(*container2->Layer(), DisplayItem::kLayerChunk),
              chunk_state, nullptr, IntRect(0, 150, 800, 200)),
          IsPaintChunk(
              1, 1,
              PaintChunk::Id(*content2b->Layer(), DisplayItem::kLayerChunk),
              chunk_state, nullptr, IntRect(0, 250, 800, 100)),
          IsPaintChunk(
              1, 1,
              PaintChunk::Id(*content2a->Layer(), DisplayItem::kLayerChunk),
              chunk_state, nullptr, IntRect(0, 150, 800, 100))));
}

TEST_P(PaintLayerPainterTest, PaintPhaseOutline) {
  AtomicString style_without_outline =
      "width: 50px; height: 50px; background-color: green";
  AtomicString style_with_outline =
      "outline: 1px solid blue; " + style_without_outline;
  SetBodyInnerHTML(R"HTML(
    <div id='self-painting-layer' style='position: absolute'>
      <div id='non-self-painting-layer' style='overflow: hidden'>
        <div>
          <div id='outline'></div>
        </div>
      </div>
    </div>
  )HTML");
  LayoutObject& outline_div =
      *GetDocument().getElementById("outline")->GetLayoutObject();
  To<HTMLElement>(outline_div.GetNode())
      ->setAttribute(html_names::kStyleAttr, style_without_outline);
  UpdateAllLifecyclePhasesForTest();

  auto& self_painting_layer_object = *To<LayoutBoxModelObject>(
      GetDocument().getElementById("self-painting-layer")->GetLayoutObject());
  PaintLayer& self_painting_layer = *self_painting_layer_object.Layer();
  ASSERT_TRUE(self_painting_layer.IsSelfPaintingLayer());
  auto& non_self_painting_layer =
      *GetPaintLayerByElementId("non-self-painting-layer");
  ASSERT_FALSE(non_self_painting_layer.IsSelfPaintingLayer());
  ASSERT_TRUE(&non_self_painting_layer == outline_div.EnclosingLayer());

  EXPECT_FALSE(self_painting_layer.NeedsPaintPhaseDescendantOutlines());
  EXPECT_FALSE(non_self_painting_layer.NeedsPaintPhaseDescendantOutlines());

  // Outline on the self-painting-layer node itself doesn't affect
  // PaintPhaseDescendantOutlines.
  To<HTMLElement>(self_painting_layer_object.GetNode())
      ->setAttribute(html_names::kStyleAttr,
                     "position: absolute; outline: 1px solid green");
  UpdateAllLifecyclePhasesForTest();
  EXPECT_FALSE(self_painting_layer.NeedsPaintPhaseDescendantOutlines());
  EXPECT_FALSE(non_self_painting_layer.NeedsPaintPhaseDescendantOutlines());
  EXPECT_THAT(ContentDisplayItems(),
              Contains(IsSameId(&self_painting_layer_object,
                                DisplayItem::PaintPhaseToDrawingType(
                                    PaintPhase::kSelfOutlineOnly))));

  // needsPaintPhaseDescendantOutlines should be set when any descendant on the
  // same layer has outline.
  To<HTMLElement>(outline_div.GetNode())
      ->setAttribute(html_names::kStyleAttr, style_with_outline);
  UpdateAllLifecyclePhasesExceptPaint();
  EXPECT_TRUE(self_painting_layer.NeedsPaintPhaseDescendantOutlines());
  EXPECT_FALSE(non_self_painting_layer.NeedsPaintPhaseDescendantOutlines());
  UpdateAllLifecyclePhasesForTest();
  EXPECT_THAT(
      ContentDisplayItems(),
      Contains(IsSameId(&outline_div, DisplayItem::PaintPhaseToDrawingType(
                                          PaintPhase::kSelfOutlineOnly))));

  // needsPaintPhaseDescendantOutlines should be reset when no outline is
  // actually painted.
  To<HTMLElement>(outline_div.GetNode())
      ->setAttribute(html_names::kStyleAttr, style_without_outline);
  UpdateAllLifecyclePhasesForTest();
  EXPECT_TRUE(self_painting_layer.NeedsPaintPhaseDescendantOutlines());
}

TEST_P(PaintLayerPainterTest, PaintPhaseFloat) {
  AtomicString style_without_float =
      "width: 50px; height: 50px; background-color: green";
  AtomicString style_with_float = "float: left; " + style_without_float;
  SetBodyInnerHTML(R"HTML(
    <div id='self-painting-layer' style='position: absolute'>
      <div id='non-self-painting-layer' style='overflow: hidden'>
        <div>
          <div id='float' style='width: 10px; height: 10px;
              background-color: blue'></div>
        </div>
      </div>
    </div>
  )HTML");
  LayoutObject& float_div =
      *GetDocument().getElementById("float")->GetLayoutObject();
  To<HTMLElement>(float_div.GetNode())
      ->setAttribute(html_names::kStyleAttr, style_without_float);
  UpdateAllLifecyclePhasesForTest();

  auto& self_painting_layer_object = *To<LayoutBoxModelObject>(
      GetDocument().getElementById("self-painting-layer")->GetLayoutObject());
  PaintLayer& self_painting_layer = *self_painting_layer_object.Layer();
  ASSERT_TRUE(self_painting_layer.IsSelfPaintingLayer());
  auto& non_self_painting_layer =
      *GetPaintLayerByElementId("non-self-painting-layer");
  ASSERT_FALSE(non_self_painting_layer.IsSelfPaintingLayer());
  ASSERT_TRUE(&non_self_painting_layer == float_div.EnclosingLayer());

  EXPECT_FALSE(self_painting_layer.NeedsPaintPhaseFloat());
  EXPECT_FALSE(non_self_painting_layer.NeedsPaintPhaseFloat());

  // needsPaintPhaseFloat should be set when any descendant on the same layer
  // has float.
  To<HTMLElement>(float_div.GetNode())
      ->setAttribute(html_names::kStyleAttr, style_with_float);
  UpdateAllLifecyclePhasesExceptPaint();
  EXPECT_TRUE(self_painting_layer.NeedsPaintPhaseFloat());
  EXPECT_FALSE(non_self_painting_layer.NeedsPaintPhaseFloat());
  UpdateAllLifecyclePhasesForTest();
  EXPECT_THAT(
      ContentDisplayItems(),
      Contains(IsSameId(&float_div, DisplayItem::kBoxDecorationBackground)));

  // needsPaintPhaseFloat should be reset when there is no float actually
  // painted.
  To<HTMLElement>(float_div.GetNode())
      ->setAttribute(html_names::kStyleAttr, style_without_float);
  UpdateAllLifecyclePhasesForTest();
  EXPECT_TRUE(self_painting_layer.NeedsPaintPhaseFloat());
}

TEST_P(PaintLayerPainterTest, PaintPhaseFloatUnderInlineLayer) {
  SetBodyInnerHTML(R"HTML(
    <div id='self-painting-layer' style='position: absolute'>
      <div id='non-self-painting-layer' style='overflow: hidden'>
        <span id='span' style='position: relative'>
          <div id='float' style='width: 10px; height: 10px;
              background-color: blue; float: left'></div>
        </span>
      </div>
    </div>
  )HTML");
  UpdateAllLifecyclePhasesForTest();

  LayoutObject& float_div =
      *GetDocument().getElementById("float")->GetLayoutObject();
  PaintLayer& span_layer = *GetPaintLayerByElementId("span");
  ASSERT_TRUE(&span_layer == float_div.EnclosingLayer());
  if (RuntimeEnabledFeatures::LayoutNGEnabled()) {
    ASSERT_TRUE(span_layer.NeedsPaintPhaseFloat());
  } else {
    ASSERT_FALSE(span_layer.NeedsPaintPhaseFloat());
  }
  auto& self_painting_layer = *GetPaintLayerByElementId("self-painting-layer");
  ASSERT_TRUE(self_painting_layer.IsSelfPaintingLayer());
  auto& non_self_painting_layer =
      *GetPaintLayerByElementId("non-self-painting-layer");
  ASSERT_FALSE(non_self_painting_layer.IsSelfPaintingLayer());

  if (RuntimeEnabledFeatures::LayoutNGEnabled()) {
    EXPECT_FALSE(self_painting_layer.NeedsPaintPhaseFloat());
    EXPECT_TRUE(span_layer.NeedsPaintPhaseFloat());
  } else {
    EXPECT_TRUE(self_painting_layer.NeedsPaintPhaseFloat());
    EXPECT_FALSE(span_layer.NeedsPaintPhaseFloat());
  }
  EXPECT_FALSE(non_self_painting_layer.NeedsPaintPhaseFloat());
  EXPECT_THAT(
      ContentDisplayItems(),
      Contains(IsSameId(&float_div, DisplayItem::kBoxDecorationBackground)));
}

TEST_P(PaintLayerPainterTest, PaintPhasesUpdateOnLayerAddition) {
  SetBodyInnerHTML(R"HTML(
    <div id='will-be-layer'>
      <div style='height: 100px'>
        <div style='height: 20px; outline: 1px solid red;
            background-color: green'>outline and background</div>
        <div style='float: left'>float</div>
      </div>
    </div>
  )HTML");

  auto& layer_div = *To<LayoutBoxModelObject>(
      GetDocument().getElementById("will-be-layer")->GetLayoutObject());
  EXPECT_FALSE(layer_div.HasLayer());

  PaintLayer& html_layer =
      *To<LayoutBoxModelObject>(
           GetDocument().documentElement()->GetLayoutObject())
           ->Layer();
  EXPECT_TRUE(html_layer.NeedsPaintPhaseDescendantOutlines());
  EXPECT_TRUE(html_layer.NeedsPaintPhaseFloat());

  To<HTMLElement>(layer_div.GetNode())
      ->setAttribute(html_names::kStyleAttr, "position: relative");
  UpdateAllLifecyclePhasesForTest();
  ASSERT_TRUE(layer_div.HasLayer());
  PaintLayer& layer = *layer_div.Layer();
  ASSERT_TRUE(layer.IsSelfPaintingLayer());
  EXPECT_TRUE(layer.NeedsPaintPhaseDescendantOutlines());
  EXPECT_TRUE(layer.NeedsPaintPhaseFloat());
}

TEST_P(PaintLayerPainterTest, PaintPhasesUpdateOnBecomingSelfPainting) {
  SetBodyInnerHTML(R"HTML(
    <div id='will-be-self-painting' style='width: 100px; height: 100px;
    overflow: hidden'>
      <div>
        <div style='outline: 1px solid red; background-color: green'>
          outline and background
        </div>
      </div>
    </div>
  )HTML");

  auto& layer_div = *To<LayoutBoxModelObject>(
      GetLayoutObjectByElementId("will-be-self-painting"));
  ASSERT_TRUE(layer_div.HasLayer());
  EXPECT_FALSE(layer_div.Layer()->IsSelfPaintingLayer());

  PaintLayer& html_layer =
      *To<LayoutBoxModelObject>(
           GetDocument().documentElement()->GetLayoutObject())
           ->Layer();
  EXPECT_TRUE(html_layer.NeedsPaintPhaseDescendantOutlines());

  To<HTMLElement>(layer_div.GetNode())
      ->setAttribute(
          html_names::kStyleAttr,
          "width: 100px; height: 100px; overflow: hidden; position: relative");
  UpdateAllLifecyclePhasesForTest();
  PaintLayer& layer = *layer_div.Layer();
  ASSERT_TRUE(layer.IsSelfPaintingLayer());
  EXPECT_TRUE(layer.NeedsPaintPhaseDescendantOutlines());
}

TEST_P(PaintLayerPainterTest, PaintPhasesUpdateOnBecomingNonSelfPainting) {
  SetBodyInnerHTML(R"HTML(
    <div id='will-be-non-self-painting' style='width: 100px; height: 100px;
    overflow: hidden; position: relative'>
      <div>
        <div style='outline: 1px solid red; background-color: green'>
          outline and background
        </div>
      </div>
    </div>
  )HTML");

  auto& layer_div = *To<LayoutBoxModelObject>(
      GetLayoutObjectByElementId("will-be-non-self-painting"));
  ASSERT_TRUE(layer_div.HasLayer());
  PaintLayer& layer = *layer_div.Layer();
  EXPECT_TRUE(layer.IsSelfPaintingLayer());
  EXPECT_TRUE(layer.NeedsPaintPhaseDescendantOutlines());

  PaintLayer& html_layer =
      *To<LayoutBoxModelObject>(
           GetDocument().documentElement()->GetLayoutObject())
           ->Layer();
  EXPECT_FALSE(html_layer.NeedsPaintPhaseDescendantOutlines());

  To<HTMLElement>(layer_div.GetNode())
      ->setAttribute(html_names::kStyleAttr,
                     "width: 100px; height: 100px; overflow: hidden");
  UpdateAllLifecyclePhasesForTest();
  EXPECT_FALSE(layer.IsSelfPaintingLayer());
  EXPECT_TRUE(html_layer.NeedsPaintPhaseDescendantOutlines());
}

TEST_P(PaintLayerPainterTest, DontPaintWithTinyOpacity) {
  SetBodyInnerHTML(
      "<div id='target' style='background: blue; opacity: 0.0001'></div>");
  ExpectPaintedOutputInvisibleAndPaintsWithTransparency("target", true, true);
}

TEST_P(PaintLayerPainterTest, DoPaintWithTinyOpacityAndWillChangeOpacity) {
  SetBodyInnerHTML(
      "<div id='target' style='background: blue; opacity: 0.0001; "
      "    will-change: opacity'></div>");
  ExpectPaintedOutputInvisibleAndPaintsWithTransparency("target", false, false);
}

TEST_P(PaintLayerPainterTest, DoPaintWithTinyOpacityAndBackdropFilter) {
  SetBodyInnerHTML(
      "<div id='target' style='background: blue; opacity: 0.0001;"
      "    backdrop-filter: blur(2px);'></div>");
  ExpectPaintedOutputInvisibleAndPaintsWithTransparency("target", false, false);
}

TEST_P(PaintLayerPainterTest,
       DoPaintWithTinyOpacityAndBackdropFilterAndWillChangeOpacity) {
  SetBodyInnerHTML(
      "<div id='target' style='background: blue; opacity: 0.0001;"
      "    backdrop-filter: blur(2px); will-change: opacity'></div>");
  ExpectPaintedOutputInvisibleAndPaintsWithTransparency("target", false, false);
}

TEST_P(PaintLayerPainterTest, DoPaintWithCompositedTinyOpacity) {
  SetBodyInnerHTML(
      "<div id='target' style='background: blue; opacity: 0.0001;"
      "    will-change: transform'></div>");
  ExpectPaintedOutputInvisibleAndPaintsWithTransparency("target", true, false);
}

TEST_P(PaintLayerPainterTest, DoPaintWithNonTinyOpacity) {
  SetBodyInnerHTML(
      "<div id='target' style='background: blue; opacity: 0.1'></div>");
  ExpectPaintedOutputInvisibleAndPaintsWithTransparency("target", false, true);
}

TEST_P(PaintLayerPainterTest, DoPaintWithEffectAnimationZeroOpacity) {
  SetBodyInnerHTML(R"HTML(
    <style>
    div {
      width: 100px;
      height: 100px;
      animation-name: example;
      animation-duration: 4s;
    }
    @keyframes example {
      from { opacity: 0.0;}
      to { opacity: 1.0;}
    }
    </style>
    <div id='target'></div>
  )HTML");
  ExpectPaintedOutputInvisibleAndPaintsWithTransparency("target", true, false);
}

TEST_P(PaintLayerPainterTest, DoPaintWithTransformAnimationZeroOpacity) {
  SetBodyInnerHTML(R"HTML(
    <style>
    div#target {
      animation-name: example;
      animation-duration: 4s;
      opacity: 0.0;
    }
    @keyframes example {
      from { transform: translate(0px, 0px); }
      to { transform: translate(3em, 0px); }
    }
    </style>
    <div id='target'>x</div></div>
  )HTML");
  ExpectPaintedOutputInvisibleAndPaintsWithTransparency("target", true, false);
}

TEST_P(PaintLayerPainterTest,
       DoPaintWithTransformAnimationZeroOpacityWillChangeOpacity) {
  SetBodyInnerHTML(R"HTML(
    <style>
    div#target {
      animation-name: example;
      animation-duration: 4s;
      opacity: 0.0;
      will-change: opacity;
    }
    @keyframes example {
      from { transform: translate(0px, 0px); }
      to { transform: translate(3em, 0px); }
    }
    </style>
    <div id='target'>x</div></div>
  )HTML");
  ExpectPaintedOutputInvisibleAndPaintsWithTransparency("target", false, false);
}

TEST_P(PaintLayerPainterTest, DoPaintWithWillChangeOpacity) {
  SetBodyInnerHTML(R"HTML(
    <style>
    div {
      width: 100px;
      height: 100px;
      will-change: opacity;
    }
    </style>
    <div id='target'></div>
  )HTML");
  ExpectPaintedOutputInvisibleAndPaintsWithTransparency("target", false, false);
}

TEST_P(PaintLayerPainterTest, DoPaintWithZeroOpacityAndWillChangeOpacity) {
  SetBodyInnerHTML(R"HTML(
    <style>
    div {
      width: 100px;
      height: 100px;
      opacity: 0;
      will-change: opacity;
    }
    </style>
    <div id='target'></div>
  )HTML");
  ExpectPaintedOutputInvisibleAndPaintsWithTransparency("target", false, false);
}

TEST_P(PaintLayerPainterTest,
       DoPaintWithNoContentAndZeroOpacityAndWillChangeOpacity) {
  SetBodyInnerHTML(R"HTML(
    <style>
    div {
      width: 100px;
      height: 100px;
      opacity: 0;
      will-change: opacity;
    }
    </style>
    <div id='target'></div>
  )HTML");
  ExpectPaintedOutputInvisibleAndPaintsWithTransparency("target", false, false);
}

using PaintLayerPainterTestCAP = PaintLayerPainterTest;

INSTANTIATE_CAP_TEST_SUITE_P(PaintLayerPainterTestCAP);

TEST_P(PaintLayerPainterTestCAP, SimpleCullRect) {
  SetBodyInnerHTML(R"HTML(
    <div id='target'
         style='width: 200px; height: 200px; position: relative'>
    </div>
  )HTML");

  EXPECT_EQ(IntRect(0, 0, 800, 600),
            GetCullRect(*GetPaintLayerByElementId("target")).Rect());
}

TEST_P(PaintLayerPainterTestCAP, TallLayerCullRect) {
  SetBodyInnerHTML(R"HTML(
    <div id='target'
         style='width: 200px; height: 10000px; position: relative'>
    </div>
  )HTML");

  // Viewport rect (0, 0, 800, 600) expanded by 4000 for scrolling then clipped
  // by the contents rect.
  EXPECT_EQ(IntRect(0, 0, 800, 4600),
            GetCullRect(*GetPaintLayerByElementId("target")).Rect());
}

TEST_P(PaintLayerPainterTestCAP, WideLayerCullRect) {
  SetBodyInnerHTML(R"HTML(
    <div id='target'
         style='width: 10000px; height: 200px; position: relative'>
    </div>
  )HTML");

  // Same as TallLayerCullRect.
  EXPECT_EQ(IntRect(0, 0, 4800, 600),
            GetCullRect(*GetPaintLayerByElementId("target")).Rect());
}

TEST_P(PaintLayerPainterTestCAP, TallScrolledLayerCullRect) {
  SetBodyInnerHTML(R"HTML(
    <div id='target' style='width: 200px; height: 12000px; position: relative'>
    </div>
  )HTML");

  // Viewport rect (0, 0, 800, 600) expanded by 4000 for scrolling then clipped
  // by the contents rect.
  EXPECT_EQ(IntRect(0, 0, 800, 4600),
            GetCullRect(*GetPaintLayerByElementId("target")).Rect());

  GetDocument().View()->LayoutViewport()->SetScrollOffset(
      ScrollOffset(0, 4000), mojom::blink::ScrollType::kProgrammatic);
  UpdateAllLifecyclePhasesForTest();
  EXPECT_EQ(IntRect(0, 0, 800, 8600),
            GetCullRect(*GetPaintLayerByElementId("target")).Rect());

  GetDocument().View()->LayoutViewport()->SetScrollOffset(
      ScrollOffset(0, 4500), mojom::blink::ScrollType::kProgrammatic);
  UpdateAllLifecyclePhasesForTest();
  // Used the previous cull rect because the scroll amount is small.
  EXPECT_EQ(IntRect(0, 0, 800, 8600),
            GetCullRect(*GetPaintLayerByElementId("target")).Rect());

  GetDocument().View()->LayoutViewport()->SetScrollOffset(
      ScrollOffset(0, 4600), mojom::blink::ScrollType::kProgrammatic);
  UpdateAllLifecyclePhasesForTest();
  // Used new cull rect.
  EXPECT_EQ(IntRect(0, 600, 800, 8600),
            GetCullRect(*GetPaintLayerByElementId("target")).Rect());
}

TEST_P(PaintLayerPainterTestCAP, WholeDocumentCullRect) {
  GetDocument().GetSettings()->SetPreferCompositingToLCDTextEnabled(true);
  GetDocument().GetSettings()->SetMainFrameClipsContent(false);
  SetBodyInnerHTML(R"HTML(
    <style>
      div { background: blue; }
      ::-webkit-scrollbar { display: none; }
    </style>
    <div id='relative'
         style='width: 200px; height: 10000px; position: relative'>
    </div>
    <div id='fixed' style='width: 200px; height: 200px; position: fixed'>
    </div>
    <div id='scroll' style='width: 200px; height: 200px; overflow: scroll'>
      <div id='below-scroll' style='height: 5000px; position: relative'></div>
      <div style='height: 200px'>Should not paint</div>
    </div>
    <div id='normal' style='width: 200px; height: 200px'></div>
  )HTML");

  // Viewport clipping is disabled.
  EXPECT_TRUE(GetCullRect(*GetLayoutView().Layer()).IsInfinite());
  EXPECT_TRUE(GetCullRect(*GetPaintLayerByElementId("relative")).IsInfinite());
  EXPECT_TRUE(GetCullRect(*GetPaintLayerByElementId("fixed")).IsInfinite());
  EXPECT_TRUE(GetCullRect(*GetPaintLayerByElementId("scroll")).IsInfinite());

  // Cull rect is normal for contents below scroll other than the viewport.
  EXPECT_EQ(IntRect(0, 0, 200, 4200),
            GetCullRect(*GetPaintLayerByElementId("below-scroll")).Rect());

  EXPECT_THAT(ContentDisplayItems(),
              UnorderedElementsAre(
                  VIEW_SCROLLING_BACKGROUND_DISPLAY_ITEM,
                  IsSameId(GetDisplayItemClientFromElementId("relative"),
                           kBackgroundType),
                  IsSameId(GetDisplayItemClientFromElementId("normal"),
                           kBackgroundType),
                  IsSameId(GetDisplayItemClientFromElementId("scroll"),
                           kBackgroundType),
                  IsSameId(&GetLayoutBoxByElementId("scroll")
                                ->GetScrollableArea()
                                ->GetScrollingBackgroundDisplayItemClient(),
                           kBackgroundType),
                  IsSameId(GetDisplayItemClientFromElementId("below-scroll"),
                           kBackgroundType),
                  IsSameId(GetDisplayItemClientFromElementId("fixed"),
                           kBackgroundType)));
}

TEST_P(PaintLayerPainterTestCAP, VerticalRightLeftWritingModeDocument) {
  SetBodyInnerHTML(R"HTML(
    <style>
      html { writing-mode: vertical-rl; }
      body { margin: 0; }
    </style>
    <div id='target' style='width: 10000px; height: 200px; position: relative'>
    </div>
  )HTML");

  GetDocument().View()->LayoutViewport()->SetScrollOffset(
      ScrollOffset(-5000, 0), mojom::blink::ScrollType::kProgrammatic);
  UpdateAllLifecyclePhasesForTest();

  // A scroll by -5000px is equivalent to a scroll by (10000 - 5000 - 800)px =
  // 4200px in non-RTL mode. Expanding the resulting rect by 4000px in each
  // direction and clipping by the contents rect yields this result.
  EXPECT_EQ(IntRect(200, 0, 8800, 600),
            GetCullRect(*GetPaintLayerByElementId("target")).Rect());
}

// TODO(wangxianzhu): These tests should correspond to the tests in
// CompositedLayerMapping testing interest rects. However, for now because in
// CompositeAfterPaint we expand cull rect for composited scrollers only, so
// the tests are modified to use composited scrolling. Will change these back to
// their original version when we support expansion for all composited layers.
// Will be done in CullRectUpdate.
TEST_P(PaintLayerPainterTestCAP, ScaledCullRect) {
  GetDocument().GetSettings()->SetPreferCompositingToLCDTextEnabled(true);
  SetBodyInnerHTML(R"HTML(
    <div style='width: 200px; height: 300px; overflow: scroll;
                transform: scaleX(2) scaleY(0.5)'>
      <div id='target' style='height: 400px; position: relative'></div>
      <div style='width: 10000px; height: 10000px'></div>
    </div>
  )HTML");

  // The scale doesn't affect the cull rect.
  // TODO(wangxianzhu): actually it should.
  EXPECT_EQ(IntRect(0, 0, 4200, 4300),
            GetCullRect(*GetPaintLayerByElementId("target")).Rect());
}

TEST_P(PaintLayerPainterTestCAP, ScaledAndRotatedCullRect) {
  GetDocument().GetSettings()->SetPreferCompositingToLCDTextEnabled(true);
  SetBodyInnerHTML(R"HTML(
    <div style='width: 200px; height: 300px; overflow: scroll;
                transform: scaleX(2) scaleY(0.5) rotateZ(45deg)'>
      <div id='target' style='height: 400px; position: relative;
               will-change: transform'></div>
      <div style='width: 10000px; height: 10000px'></div>
    </div>
  )HTML");

  // The scale and the rotation don't affect the cull rect.
  // TODO(wangxianzhu): actually they should.
  EXPECT_EQ(IntRect(0, 0, 4200, 4300),
            GetCullRect(*GetPaintLayerByElementId("target")).Rect());
}

TEST_P(PaintLayerPainterTestCAP, 3DRotated90DegreesCullRect) {
  GetDocument().GetSettings()->SetPreferCompositingToLCDTextEnabled(true);
  SetBodyInnerHTML(R"HTML(
    <div style='width: 200px; height: 300px; overflow: scroll;
                transform: rotateY(90deg)'>
      <div id='target' style='height: 400px; position: relative'></div>
      <div style='width: 10000px; height: 10000px'></div>
    </div>
  )HTML");

  // It's rotated 90 degrees about the X axis, which means its visual content
  // rect is empty, we fall back to the 4000px cull rect padding amount.
  EXPECT_EQ(IntRect(0, 0, 4200, 4300),
            GetCullRect(*GetPaintLayerByElementId("target")).Rect());
}

TEST_P(PaintLayerPainterTestCAP, 3DRotatedNear90DegreesCullRect) {
  GetDocument().GetSettings()->SetPreferCompositingToLCDTextEnabled(true);
  SetBodyInnerHTML(R"HTML(
    <div style='width: 200px; height: 300px; overflow: scroll;
                transform: rotateY(89.9999deg)'>
      <div id='target' style='height: 400px; position: relative'></div>
      <div style='width: 10000px; height: 10000px'></div>
    </div>
  )HTML");

  // Because the layer is rotated to almost 90 degrees, floating-point error
  // leads to a reverse-projected rect that is much much larger than the
  // original layer size in certain dimensions. In such cases, we often fall
  // back to the 4000px cull rect padding amount.
  EXPECT_EQ(IntRect(0, 0, 4200, 4300),
            GetCullRect(*GetPaintLayerByElementId("target")).Rect());
}

TEST_P(PaintLayerPainterTestCAP, PerspectiveCullRect) {
  SetBodyInnerHTML(R"HTML(
    <div id='target'
         style='width: 100px; height: 100px; transform: perspective(1000px)'>
    </div>
  )HTML");

  // Use infinite cull rect with perspective.
  EXPECT_TRUE(GetCullRect(*GetPaintLayerByElementId("target")).IsInfinite());
}

TEST_P(PaintLayerPainterTestCAP, 3D45DegRotatedTallCullRect) {
  SetBodyInnerHTML(R"HTML(
    <div id='target'
         style='width: 200px; height: 10000px; transform: rotateY(45deg)'>
    </div>
  )HTML");

  // Use infinite cull rect with 3d transform.
  EXPECT_TRUE(GetCullRect(*GetPaintLayerByElementId("target")).IsInfinite());
}

TEST_P(PaintLayerPainterTestCAP, FixedPositionCullRect) {
  SetBodyInnerHTML(R"HTML(
    <div id='target' style='width: 1000px; height: 2000px;
                            position: fixed; top: 100px; left: 200px;'>
    </div>
  )HTML");

  EXPECT_EQ(IntRect(-200, -100, 800, 600),
            GetCullRect(*GetPaintLayerByElementId("target")).Rect());
}

TEST_P(PaintLayerPainterTestCAP, LayerOffscreenNearCullRect) {
  GetDocument().GetSettings()->SetPreferCompositingToLCDTextEnabled(true);
  SetBodyInnerHTML(R"HTML(
    <div style='width: 200px; height: 300px; overflow: scroll;
                position: absolute; top: 3000px; left: 0px;'>
      <div id='target' style='height: 500px; position: relative'></div>
      <div style='width: 10000px; height: 10000px'></div>
    </div>
  )HTML");

  EXPECT_EQ(IntRect(0, 0, 4200, 4300),
            GetCullRect(*GetPaintLayerByElementId("target")).Rect());
}

TEST_P(PaintLayerPainterTestCAP, LayerOffscreenFarCullRect) {
  GetDocument().GetSettings()->SetPreferCompositingToLCDTextEnabled(true);
  SetBodyInnerHTML(R"HTML(
    <div style='width: 200px; height: 300px; overflow: scroll;
                position: absolute; top: 9000px'>
      <div id='target' style='height: 500px; position: relative'></div>
      <div style='width: 10000px; height: 10000px'></div>
    </div>
  )HTML");

  // The layer is too far away from the viewport.
  EXPECT_EQ(IntRect(), GetCullRect(*GetPaintLayerByElementId("target")).Rect());
}

TEST_P(PaintLayerPainterTestCAP, ScrollingLayerCullRect) {
  GetDocument().GetSettings()->SetPreferCompositingToLCDTextEnabled(true);
  SetBodyInnerHTML(R"HTML(
    <style>
      div::-webkit-scrollbar { width: 5px; }
    </style>
    <div style='width: 200px; height: 200px; overflow: scroll'>
      <div id='target'
           style='width: 100px; height: 10000px; position: relative'>
      </div>
    </div>
  )HTML");

  // In screen space, the scroller is (8, 8, 195, 193) (because of overflow clip
  // of 'target', scrollbar and root margin).
  // Applying the viewport clip of the root has no effect because
  // the clip is already small. Mapping it down into the graphics layer
  // space yields (0, 0, 195, 193). This is then expanded by 4000px and clipped
  // by the contents rect.
  EXPECT_EQ(IntRect(0, 0, 195, 4193),
            GetCullRect(*GetPaintLayerByElementId("target")).Rect());
}

TEST_P(PaintLayerPainterTestCAP, NonCompositedScrollingLayerCullRect) {
  GetDocument().GetSettings()->SetPreferCompositingToLCDTextEnabled(false);
  SetBodyInnerHTML(R"HTML(
    <style>
      div::-webkit-scrollbar { width: 5px; }
    </style>
    <div style='width: 200px; height: 200px; overflow: scroll'>
      <div id='target'
           style='width: 100px; height: 10000px; position: relative'>
      </div>
    </div>
  )HTML");

  // See ScrollingLayerCullRect for the calculation.
  EXPECT_EQ(IntRect(0, 0, 195, 193),
            GetCullRect(*GetPaintLayerByElementId("target")).Rect());
}

TEST_P(PaintLayerPainterTestCAP, ClippedBigLayer) {
  SetBodyInnerHTML(R"HTML(
    <div style='width: 1px; height: 1px; overflow: hidden'>
      <div id='target'
           style='width: 10000px; height: 10000px; position: relative'>
      </div>
    </div>
  )HTML");

  // The viewport is not scrollable because of the clip, so the cull rect is
  // just the viewport rect.
  EXPECT_EQ(IntRect(0, 0, 800, 600),
            GetCullRect(*GetPaintLayerByElementId("target")).Rect());
}

}  // namespace blink