// 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/platform/graphics/paint/paint_chunker.h"

#include "base/test/scoped_feature_list.h"
#include "cc/base/features.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/blink/renderer/platform/graphics/paint/drawing_display_item.h"
#include "third_party/blink/renderer/platform/graphics/paint/foreign_layer_display_item.h"
#include "third_party/blink/renderer/platform/graphics/paint/paint_controller_test.h"
#include "third_party/blink/renderer/platform/testing/fake_display_item_client.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::ElementsAre;

namespace blink {

namespace {

class PaintChunkerTest : public testing::Test {
 protected:
  FakeDisplayItemClient client_;
};

DisplayItem::Type DisplayItemType(int offset) {
  auto type =
      static_cast<DisplayItem::Type>(DisplayItem::kDrawingFirst + offset);
  DCHECK(DisplayItem::IsDrawingType(type));
  return type;
}

class TestChunkerDisplayItem : public DrawingDisplayItem {
 public:
  explicit TestChunkerDisplayItem(
      const DisplayItemClient& client,
      DisplayItem::Type type = DisplayItem::kDrawingFirst,
      const IntRect& visual_rect = IntRect())
      : DrawingDisplayItem(client, type, visual_rect, nullptr) {}
};

class TestChunkerOpaqueDisplayItem : public DrawingDisplayItem {
 public:
  explicit TestChunkerOpaqueDisplayItem(
      const DisplayItemClient& client,
      DisplayItem::Type type = DisplayItem::kDrawingFirst,
      const IntRect& visual_rect = IntRect())
      : DrawingDisplayItem(client, type, visual_rect, nullptr) {
    SetKnownToBeOpaqueForTesting();
  }
};

class TestDisplayItemRequiringSeparateChunk : public ForeignLayerDisplayItem {
 public:
  explicit TestDisplayItemRequiringSeparateChunk(
      const DisplayItemClient& client)
      : ForeignLayerDisplayItem(client,
                                DisplayItem::kForeignLayerPlugin,
                                cc::Layer::Create(),
                                IntPoint()) {}
};

TEST_F(PaintChunkerTest, Empty) {
  Vector<PaintChunk> chunks;
  PaintChunker chunker(chunks);
  EXPECT_TRUE(chunks.IsEmpty());

  chunker.ResetChunks(&chunks);
  EXPECT_TRUE(chunks.IsEmpty());
}

TEST_F(PaintChunkerTest, SingleNonEmptyRange) {
  Vector<PaintChunk> chunks;
  PaintChunker chunker(chunks);
  PaintChunk::Id id(client_, DisplayItemType(1));
  chunker.UpdateCurrentPaintChunkProperties(&id, DefaultPaintChunkProperties());
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));

  EXPECT_THAT(chunks, ElementsAre(IsPaintChunk(0, 2, id,
                                               DefaultPaintChunkProperties())));

  Vector<PaintChunk> chunks1;
  chunker.ResetChunks(&chunks1);
  EXPECT_THAT(chunks, ElementsAre(IsPaintChunk(0, 2, id,
                                               DefaultPaintChunkProperties())));
  EXPECT_TRUE(chunks1.IsEmpty());
}

TEST_F(PaintChunkerTest, SamePropertiesTwiceCombineIntoOneChunk) {
  Vector<PaintChunk> chunks;
  PaintChunker chunker(chunks);
  PaintChunk::Id id(client_, DisplayItemType(1));
  chunker.UpdateCurrentPaintChunkProperties(&id, DefaultPaintChunkProperties());
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));
  chunker.UpdateCurrentPaintChunkProperties(&id, DefaultPaintChunkProperties());
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));

  EXPECT_THAT(chunks, ElementsAre(IsPaintChunk(0, 3, id,
                                               DefaultPaintChunkProperties())));

  Vector<PaintChunk> chunks1;
  chunker.ResetChunks(&chunks1);
  EXPECT_THAT(chunks, ElementsAre(IsPaintChunk(0, 3, id,
                                               DefaultPaintChunkProperties())));
  EXPECT_TRUE(chunks1.IsEmpty());
}

TEST_F(PaintChunkerTest, BuildMultipleChunksWithSinglePropertyChanging) {
  Vector<PaintChunk> chunks;
  PaintChunker chunker(chunks);
  PaintChunk::Id id1(client_, DisplayItemType(1));
  chunker.UpdateCurrentPaintChunkProperties(&id1,
                                            DefaultPaintChunkProperties());
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));

  auto simple_transform_node = CreateTransform(
      t0(), TransformationMatrix(0, 1, 2, 3, 4, 5), FloatPoint3D(9, 8, 7));
  auto simple_transform = DefaultPaintChunkProperties();
  simple_transform.SetTransform(*simple_transform_node);

  PaintChunk::Id id2(client_, DisplayItemType(2));
  chunker.UpdateCurrentPaintChunkProperties(&id2, simple_transform);
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));

  auto another_transform_node = CreateTransform(
      t0(), TransformationMatrix(0, 1, 2, 3, 4, 5), FloatPoint3D(9, 8, 7));
  auto another_transform = DefaultPaintChunkProperties();
  another_transform.SetTransform(*another_transform_node);
  PaintChunk::Id id3(client_, DisplayItemType(3));
  chunker.UpdateCurrentPaintChunkProperties(&id3, another_transform);
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));

  EXPECT_THAT(chunks, ElementsAre(IsPaintChunk(0, 2, id1,
                                               DefaultPaintChunkProperties()),
                                  IsPaintChunk(2, 3, id2, simple_transform),
                                  IsPaintChunk(3, 4, id3, another_transform)));
}

TEST_F(PaintChunkerTest, BuildMultipleChunksWithDifferentPropertyChanges) {
  Vector<PaintChunk> chunks;
  PaintChunker chunker(chunks);
  PaintChunk::Id id1(client_, DisplayItemType(1));
  chunker.UpdateCurrentPaintChunkProperties(&id1,
                                            DefaultPaintChunkProperties());
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));

  auto simple_transform_node = CreateTransform(
      t0(), TransformationMatrix(0, 0, 0, 0, 0, 0), FloatPoint3D(9, 8, 7));
  auto simple_transform = DefaultPaintChunkProperties();
  simple_transform.SetTransform(*simple_transform_node);
  PaintChunk::Id id2(client_, DisplayItemType(2));
  chunker.UpdateCurrentPaintChunkProperties(&id2, simple_transform);
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));

  auto simple_effect_node = CreateOpacityEffect(e0(), 0.5f);
  auto simple_transform_and_effect = DefaultPaintChunkProperties();
  simple_transform_and_effect.SetTransform(*simple_transform_node);
  simple_transform_and_effect.SetEffect(*simple_effect_node);
  PaintChunk::Id id3(client_, DisplayItemType(3));
  chunker.UpdateCurrentPaintChunkProperties(&id3, simple_transform_and_effect);
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));

  auto new_transform_node = CreateTransform(
      t0(), TransformationMatrix(1, 1, 0, 0, 0, 0), FloatPoint3D(9, 8, 7));
  auto simple_transform_and_effect_with_updated_transform =
      DefaultPaintChunkProperties();
  auto new_effect_node = CreateOpacityEffect(e0(), 0.5f);
  simple_transform_and_effect_with_updated_transform.SetTransform(
      *new_transform_node);
  simple_transform_and_effect_with_updated_transform.SetEffect(
      *new_effect_node);
  PaintChunk::Id id4(client_, DisplayItemType(4));
  chunker.UpdateCurrentPaintChunkProperties(
      &id4, simple_transform_and_effect_with_updated_transform);
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));

  // Test that going back to a previous chunk property still creates a new
  // chunk.
  chunker.UpdateCurrentPaintChunkProperties(nullptr,
                                            simple_transform_and_effect);
  TestChunkerDisplayItem item_after_restore(client_, DisplayItemType(10));
  chunker.IncrementDisplayItemIndex(item_after_restore);
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));

  EXPECT_THAT(
      chunks,
      ElementsAre(
          IsPaintChunk(0, 1, id1, DefaultPaintChunkProperties()),
          IsPaintChunk(1, 3, id2, simple_transform),
          IsPaintChunk(3, 5, id3, simple_transform_and_effect),
          IsPaintChunk(5, 7, id4,
                       simple_transform_and_effect_with_updated_transform),
          IsPaintChunk(7, 9, item_after_restore.GetId(),
                       simple_transform_and_effect)));
}

TEST_F(PaintChunkerTest, BuildChunksFromNestedTransforms) {
  // Test that "nested" transforms linearize using the following
  // sequence of transforms and display items:
  // <root xform>
  //   <paint>
  //   <a xform>
  //     <paint><paint>
  //   </a xform>
  //   <paint>
  // </root xform>
  Vector<PaintChunk> chunks;
  PaintChunker chunker(chunks);
  PaintChunk::Id id1(client_, DisplayItemType(1));
  chunker.UpdateCurrentPaintChunkProperties(&id1,
                                            DefaultPaintChunkProperties());
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));

  auto simple_transform_node = CreateTransform(
      t0(), TransformationMatrix(0, 1, 2, 3, 4, 5), FloatPoint3D(9, 8, 7));
  auto simple_transform = DefaultPaintChunkProperties();
  simple_transform.SetTransform(*simple_transform_node);
  PaintChunk::Id id2(client_, DisplayItemType(2));
  chunker.UpdateCurrentPaintChunkProperties(&id2, simple_transform);
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));

  chunker.UpdateCurrentPaintChunkProperties(nullptr,
                                            DefaultPaintChunkProperties());
  TestChunkerDisplayItem item_after_restore(client_, DisplayItemType(10));
  chunker.IncrementDisplayItemIndex(item_after_restore);

  EXPECT_THAT(chunks, ElementsAre(IsPaintChunk(0, 1, id1,
                                               DefaultPaintChunkProperties()),
                                  IsPaintChunk(1, 3, id2, simple_transform),
                                  IsPaintChunk(3, 4, item_after_restore.GetId(),
                                               DefaultPaintChunkProperties())));
}

TEST_F(PaintChunkerTest, ChangingPropertiesWithoutItems) {
  // Test that properties can change without display items being generated.
  Vector<PaintChunk> chunks;
  PaintChunker chunker(chunks);
  PaintChunk::Id id1(client_, DisplayItemType(1));
  chunker.UpdateCurrentPaintChunkProperties(&id1,
                                            DefaultPaintChunkProperties());
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));

  auto first_transform_node = CreateTransform(
      t0(), TransformationMatrix(0, 1, 2, 3, 4, 5), FloatPoint3D(9, 8, 7));
  auto first_transform = DefaultPaintChunkProperties();
  first_transform.SetTransform(*first_transform_node);
  PaintChunk::Id id2(client_, DisplayItemType(2));
  chunker.UpdateCurrentPaintChunkProperties(nullptr, first_transform);

  auto second_transform_node = CreateTransform(
      t0(), TransformationMatrix(9, 8, 7, 6, 5, 4), FloatPoint3D(3, 2, 1));
  auto second_transform = DefaultPaintChunkProperties();
  second_transform.SetTransform(*second_transform_node);
  PaintChunk::Id id3(client_, DisplayItemType(3));
  chunker.UpdateCurrentPaintChunkProperties(&id3, second_transform);

  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));
  EXPECT_THAT(chunks, ElementsAre(IsPaintChunk(0, 1, id1,
                                               DefaultPaintChunkProperties()),
                                  IsPaintChunk(1, 2, id3, second_transform)));
}

TEST_F(PaintChunkerTest, CreatesSeparateChunksWhenRequested) {
  // Tests that the chunker creates a separate chunks for display items which
  // require it.
  Vector<PaintChunk> chunks;
  PaintChunker chunker(chunks);
  FakeDisplayItemClient client1;
  TestDisplayItemRequiringSeparateChunk i1(client1);
  FakeDisplayItemClient client2;
  TestDisplayItemRequiringSeparateChunk i2(client2);
  FakeDisplayItemClient client3;
  TestDisplayItemRequiringSeparateChunk i3(client3);

  PaintChunk::Id id0(client_, DisplayItemType(0));
  chunker.UpdateCurrentPaintChunkProperties(&id0,
                                            DefaultPaintChunkProperties());
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));
  chunker.IncrementDisplayItemIndex(i1);
  chunker.IncrementDisplayItemIndex(i2);
  TestChunkerDisplayItem after_i2(client_, DisplayItemType(10));
  chunker.IncrementDisplayItemIndex(after_i2);
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));
  chunker.UpdateCurrentPaintChunkProperties(&id0,
                                            DefaultPaintChunkProperties());
  chunker.IncrementDisplayItemIndex(i3);

  EXPECT_THAT(
      chunks,
      ElementsAre(
          IsPaintChunk(0, 1, id0, DefaultPaintChunkProperties()),
          IsPaintChunk(1, 2, i1.GetId(), DefaultPaintChunkProperties()),
          IsPaintChunk(2, 3, i2.GetId(), DefaultPaintChunkProperties()),
          IsPaintChunk(3, 5, after_i2.GetId(), DefaultPaintChunkProperties()),
          IsPaintChunk(5, 6, i3.GetId(), DefaultPaintChunkProperties())));
}

TEST_F(PaintChunkerTest, ForceNewChunkWithNewId) {
  Vector<PaintChunk> chunks;
  PaintChunker chunker(chunks);
  PaintChunk::Id id0(client_, DisplayItemType(0));
  chunker.UpdateCurrentPaintChunkProperties(&id0,
                                            DefaultPaintChunkProperties());
  EXPECT_TRUE(chunker.WillForceNewChunk());
  EXPECT_EQ(0u, chunks.size());
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));
  EXPECT_FALSE(chunker.WillForceNewChunk());
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));
  EXPECT_EQ(1u, chunks.size());

  chunker.SetWillForceNewChunk(true);
  EXPECT_TRUE(chunker.WillForceNewChunk());
  EXPECT_EQ(1u, chunks.size());
  PaintChunk::Id id1(client_, DisplayItemType(1));
  chunker.UpdateCurrentPaintChunkProperties(&id1,
                                            DefaultPaintChunkProperties());
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));
  EXPECT_EQ(2u, chunks.size());
  EXPECT_FALSE(chunker.WillForceNewChunk());
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));
  EXPECT_EQ(2u, chunks.size());

  chunker.SetWillForceNewChunk(true);
  PaintChunk::Id id2(client_, DisplayItemType(2));
  EXPECT_TRUE(chunker.WillForceNewChunk());
  chunker.UpdateCurrentPaintChunkProperties(&id2,
                                            DefaultPaintChunkProperties());
  EXPECT_EQ(2u, chunks.size());
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));
  EXPECT_EQ(3u, chunks.size());
  EXPECT_FALSE(chunker.WillForceNewChunk());
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));

  EXPECT_THAT(
      chunks,
      ElementsAre(IsPaintChunk(0, 2, id0, DefaultPaintChunkProperties()),
                  IsPaintChunk(2, 4, id1, DefaultPaintChunkProperties()),
                  IsPaintChunk(4, 6, id2, DefaultPaintChunkProperties())));
}

TEST_F(PaintChunkerTest, ForceNewChunkWithoutNewId) {
  Vector<PaintChunk> chunks;
  PaintChunker chunker(chunks);
  PaintChunk::Id id0(client_, DisplayItemType(0));
  chunker.UpdateCurrentPaintChunkProperties(nullptr,
                                            DefaultPaintChunkProperties());
  EXPECT_TRUE(chunker.WillForceNewChunk());
  EXPECT_EQ(0u, chunks.size());
  chunker.IncrementDisplayItemIndex(
      TestChunkerDisplayItem(id0.client, id0.type));
  EXPECT_FALSE(chunker.WillForceNewChunk());
  EXPECT_EQ(1u, chunks.size());
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));

  chunker.SetWillForceNewChunk(true);
  EXPECT_TRUE(chunker.WillForceNewChunk());
  EXPECT_EQ(1u, chunks.size());
  PaintChunk::Id id1(client_, DisplayItemType(1));
  chunker.IncrementDisplayItemIndex(
      TestChunkerDisplayItem(id1.client, id1.type));
  EXPECT_FALSE(chunker.WillForceNewChunk());
  EXPECT_EQ(2u, chunks.size());
  chunker.IncrementDisplayItemIndex(
      TestChunkerDisplayItem(client_, DisplayItemType(2)));

  chunker.SetWillForceNewChunk(true);
  EXPECT_TRUE(chunker.WillForceNewChunk());
  EXPECT_EQ(2u, chunks.size());
  PaintChunk::Id id2(client_, DisplayItemType(3));
  chunker.IncrementDisplayItemIndex(
      TestChunkerDisplayItem(id2.client, id2.type));
  EXPECT_FALSE(chunker.WillForceNewChunk());
  EXPECT_EQ(3u, chunks.size());
  chunker.IncrementDisplayItemIndex(
      TestChunkerDisplayItem(client_, DisplayItemType(4)));

  EXPECT_THAT(
      chunks,
      ElementsAre(IsPaintChunk(0, 2, id0, DefaultPaintChunkProperties()),
                  IsPaintChunk(2, 4, id1, DefaultPaintChunkProperties()),
                  IsPaintChunk(4, 6, id2, DefaultPaintChunkProperties())));
}

TEST_F(PaintChunkerTest, SetAndImmediatelyUnSetWillForceNewChunk) {
  Vector<PaintChunk> chunks;
  PaintChunker chunker(chunks);
  PaintChunk::Id id0(client_, DisplayItemType(0));
  chunker.UpdateCurrentPaintChunkProperties(nullptr,
                                            DefaultPaintChunkProperties());
  EXPECT_TRUE(chunker.WillForceNewChunk());
  EXPECT_EQ(0u, chunks.size());
  chunker.IncrementDisplayItemIndex(
      TestChunkerDisplayItem(id0.client, id0.type));
  EXPECT_FALSE(chunker.WillForceNewChunk());
  EXPECT_EQ(1u, chunks.size());
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));

  // This should not force a new chunk. Simulates a ScopedPaintChunkHint
  // without any painting in the scope.
  chunker.SetWillForceNewChunk(true);
  chunker.SetWillForceNewChunk(false);
  EXPECT_FALSE(chunker.WillForceNewChunk());
  chunker.IncrementDisplayItemIndex(
      TestChunkerDisplayItem(client_, DisplayItemType(1)));
  EXPECT_EQ(1u, chunks.size());

  EXPECT_THAT(chunks, ElementsAre(IsPaintChunk(0, 3, id0,
                                               DefaultPaintChunkProperties())));
}

TEST_F(PaintChunkerTest, NoNewChunkForSamePropertyDifferentIds) {
  Vector<PaintChunk> chunks;
  PaintChunker chunker(chunks);
  PaintChunk::Id id0(client_, DisplayItemType(0));
  chunker.UpdateCurrentPaintChunkProperties(&id0,
                                            DefaultPaintChunkProperties());
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));

  PaintChunk::Id id1(client_, DisplayItemType(1));
  chunker.UpdateCurrentPaintChunkProperties(&id1,
                                            DefaultPaintChunkProperties());
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));

  chunker.UpdateCurrentPaintChunkProperties(nullptr,
                                            DefaultPaintChunkProperties());
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));

  EXPECT_THAT(chunks, ElementsAre(IsPaintChunk(0, 6, id0,
                                               DefaultPaintChunkProperties())));
}

// Ensure that items following a forced chunk begin using the next display
// item's id.
TEST_F(PaintChunkerTest, ChunksFollowingForcedChunk) {
  Vector<PaintChunk> chunks;
  PaintChunker chunker(chunks);
  FakeDisplayItemClient client;
  TestChunkerDisplayItem before_forced1(client, DisplayItemType(1));
  TestChunkerDisplayItem before_forced2(client, DisplayItemType(2));
  TestDisplayItemRequiringSeparateChunk forced(client);
  TestChunkerDisplayItem after_forced1(client, DisplayItemType(3));
  TestChunkerDisplayItem after_forced2(client, DisplayItemType(4));

  PaintChunk::Id id0(client, DisplayItemType(5));
  chunker.UpdateCurrentPaintChunkProperties(&id0,
                                            DefaultPaintChunkProperties());
  // Both before_forced items should be in a chunk together.
  chunker.IncrementDisplayItemIndex(before_forced1);
  chunker.IncrementDisplayItemIndex(before_forced2);
  // |forced| forces a dedicted paint chunk.
  chunker.IncrementDisplayItemIndex(forced);
  // Both after_forced items should be in a chunk together.
  chunker.IncrementDisplayItemIndex(after_forced1);
  chunker.IncrementDisplayItemIndex(after_forced2);

  EXPECT_THAT(
      chunks,
      ElementsAre(
          IsPaintChunk(0, 2, id0, DefaultPaintChunkProperties()),
          IsPaintChunk(2, 3, forced.GetId(), DefaultPaintChunkProperties()),
          IsPaintChunk(3, 5, after_forced1.GetId(),
                       DefaultPaintChunkProperties())));
}

TEST_F(PaintChunkerTest, ChunkIdsSkippingCache) {
  Vector<PaintChunk> chunks;
  PaintChunker chunker(chunks);

  PaintChunk::Id id1(client_, DisplayItemType(1));
  chunker.UpdateCurrentPaintChunkProperties(&id1,
                                            DefaultPaintChunkProperties());
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));

  auto simple_transform_node = CreateTransform(
      t0(), TransformationMatrix(0, 1, 2, 3, 4, 5), FloatPoint3D(9, 8, 7));
  auto simple_transform = DefaultPaintChunkProperties();
  simple_transform.SetTransform(*simple_transform_node);

  FakeDisplayItemClient uncacheable_client;
  uncacheable_client.Invalidate(PaintInvalidationReason::kUncacheable);
  PaintChunk::Id id2(uncacheable_client, DisplayItemType(2));
  chunker.UpdateCurrentPaintChunkProperties(&id2, simple_transform);

  TestChunkerDisplayItem uncacheable_item(uncacheable_client);
  chunker.IncrementDisplayItemIndex(uncacheable_item);
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));

  TestDisplayItemRequiringSeparateChunk uncacheable_separate_chunk_item(
      uncacheable_client);
  chunker.IncrementDisplayItemIndex(uncacheable_separate_chunk_item);

  TestChunkerDisplayItem after_separate_chunk(client_, DisplayItemType(3));
  chunker.IncrementDisplayItemIndex(after_separate_chunk);

  chunker.UpdateCurrentPaintChunkProperties(nullptr,
                                            DefaultPaintChunkProperties());
  TestChunkerDisplayItem after_restore(client_, DisplayItemType(4));
  chunker.IncrementDisplayItemIndex(after_restore);

  EXPECT_THAT(
      chunks,
      ElementsAre(
          IsPaintChunk(0, 2, id1, DefaultPaintChunkProperties()),
          IsPaintChunk(2, 4, id2, simple_transform),
          IsPaintChunk(4, 5, uncacheable_separate_chunk_item.GetId(),
                       simple_transform),
          IsPaintChunk(5, 6, after_separate_chunk.GetId(), simple_transform),
          IsPaintChunk(6, 7, after_restore.GetId(),
                       DefaultPaintChunkProperties())));
  EXPECT_TRUE(chunks[0].is_cacheable);
  EXPECT_FALSE(chunks[1].is_cacheable);
  EXPECT_FALSE(chunks[2].is_cacheable);
  EXPECT_TRUE(chunks[3].is_cacheable);
  EXPECT_TRUE(chunks[4].is_cacheable);
}

TEST_F(PaintChunkerTest, AddHitTestDataToCurrentChunk) {
  Vector<PaintChunk> chunks;
  PaintChunker chunker(chunks);

  PaintChunk::Id id1(client_, DisplayItemType(1));

  chunker.UpdateCurrentPaintChunkProperties(&id1,
                                            DefaultPaintChunkProperties());
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(
      client_, DisplayItemType(2), IntRect(0, 0, 10, 10)));

  PaintChunk::Id id2(client_, DisplayItemType(3));
  auto transform = Create2DTranslation(t0(), 10, 20);
  PropertyTreeState properties(*transform, c0(), e0());
  chunker.UpdateCurrentPaintChunkProperties(&id2, properties);
  // This is not used as id of the chunk because we already have |id2|.
  PaintChunk::Id hit_test_id(client_, DisplayItem::kHitTest);
  chunker.AddHitTestDataToCurrentChunk(hit_test_id, IntRect(10, 20, 30, 40),
                                       TouchAction::kAuto, false);
  chunker.AddHitTestDataToCurrentChunk(hit_test_id, IntRect(20, 30, 40, 50),
                                       TouchAction::kPan, false);

  chunker.SetWillForceNewChunk(true);
  PaintChunk::Id id3(client_, DisplayItemType(4));
  chunker.AddHitTestDataToCurrentChunk(id3, IntRect(40, 50, 60, 70),
                                       TouchAction::kAuto, false);
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(
      client_, DisplayItemType(5), IntRect(0, 0, 10, 10)));

  HitTestData hit_test_data;
  hit_test_data.touch_action_rects = {
      {IntRect(20, 30, 40, 50), TouchAction::kPan}};
  if (RuntimeEnabledFeatures::CompositeAfterPaintEnabled()) {
    EXPECT_THAT(
        chunks,
        ElementsAre(IsPaintChunk(0, 1, id1, DefaultPaintChunkProperties(),
                                 nullptr, IntRect(0, 0, 10, 10)),
                    IsPaintChunk(1, 1, id2, properties, &hit_test_data,
                                 IntRect(10, 20, 50, 60)),
                    IsPaintChunk(1, 2, id3, properties, nullptr,
                                 IntRect(0, 0, 100, 120))));
  } else {
    EXPECT_THAT(
        chunks,
        ElementsAre(
            IsPaintChunk(0, 1, id1, DefaultPaintChunkProperties(), nullptr,
                         IntRect(0, 0, 10, 10)),
            IsPaintChunk(1, 1, id2, properties, &hit_test_data,
                         IntRect(20, 30, 40, 50)),
            IsPaintChunk(1, 2, PaintChunk::Id(client_, DisplayItemType(5)),
                         properties, nullptr, IntRect(0, 0, 10, 10))));
  }
}

TEST_F(PaintChunkerTest, AddHitTestDataToCurrentChunkWheelRegionsEnabled) {
  base::test::ScopedFeatureList scoped_feature_list;
  scoped_feature_list.InitAndEnableFeature(::features::kWheelEventRegions);
  Vector<PaintChunk> chunks;
  PaintChunker chunker(chunks);

  PaintChunk::Id id1(client_, DisplayItemType(1));

  chunker.UpdateCurrentPaintChunkProperties(&id1,
                                            DefaultPaintChunkProperties());
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(
      client_, DisplayItemType(2), IntRect(0, 0, 10, 10)));

  PaintChunk::Id id2(client_, DisplayItemType(3));
  auto transform = Create2DTranslation(t0(), 10, 20);
  PropertyTreeState properties(*transform, c0(), e0());
  chunker.UpdateCurrentPaintChunkProperties(&id2, properties);
  // This is not used as id of the chunk because we already have |id2|.
  PaintChunk::Id hit_test_id(client_, DisplayItem::kHitTest);
  chunker.AddHitTestDataToCurrentChunk(hit_test_id, IntRect(10, 20, 30, 40),
                                       TouchAction::kAuto, false);
  chunker.AddHitTestDataToCurrentChunk(hit_test_id, IntRect(20, 30, 40, 50),
                                       TouchAction::kPan, false);
  chunker.AddHitTestDataToCurrentChunk(hit_test_id, IntRect(25, 35, 5, 10),
                                       TouchAction::kAuto, true);

  chunker.SetWillForceNewChunk(true);
  PaintChunk::Id id3(client_, DisplayItemType(4));
  chunker.AddHitTestDataToCurrentChunk(id3, IntRect(40, 50, 60, 70),
                                       TouchAction::kAuto, false);
  chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(
      client_, DisplayItemType(5), IntRect(0, 0, 10, 10)));

  HitTestData hit_test_data;
  hit_test_data.touch_action_rects = {
      {IntRect(20, 30, 40, 50), TouchAction::kPan}};
  hit_test_data.wheel_event_rects = {IntRect(25, 35, 5, 10)};
  if (RuntimeEnabledFeatures::CompositeAfterPaintEnabled()) {
    EXPECT_THAT(
        chunks,
        ElementsAre(IsPaintChunk(0, 1, id1, DefaultPaintChunkProperties(),
                                 nullptr, IntRect(0, 0, 10, 10)),
                    IsPaintChunk(1, 1, id2, properties, &hit_test_data,
                                 IntRect(10, 20, 50, 60)),
                    IsPaintChunk(1, 2, id3, properties, nullptr,
                                 IntRect(0, 0, 100, 120))));
  } else {
    EXPECT_THAT(
        chunks,
        ElementsAre(
            IsPaintChunk(0, 1, id1, DefaultPaintChunkProperties(), nullptr,
                         IntRect(0, 0, 10, 10)),
            IsPaintChunk(1, 1, id2, properties, &hit_test_data,
                         IntRect(20, 30, 40, 50)),
            IsPaintChunk(1, 2, PaintChunk::Id(client_, DisplayItemType(5)),
                         properties, nullptr, IntRect(0, 0, 10, 10))));
  }
}

TEST_F(PaintChunkerTest, ChunkBoundsAndKnownToBeOpaqueAllOpaqueItems) {
  ScopedCompositeAfterPaintForTest cap(true);
  Vector<PaintChunk> chunks;
  PaintChunker chunker(chunks);
  FakeDisplayItemClient client1("client1");
  FakeDisplayItemClient client2("client2");
  FakeDisplayItemClient client3("client3");

  auto properties = DefaultPaintChunkProperties();
  chunker.UpdateCurrentPaintChunkProperties(nullptr, properties);
  // Single opaque item.
  chunker.IncrementDisplayItemIndex(TestChunkerOpaqueDisplayItem(
      client1, DisplayItemType(0), IntRect(0, 0, 100, 100)));
  chunker.SetWillForceNewChunk(true);
  // Two opaque items. No empty area in the united bounds.
  chunker.IncrementDisplayItemIndex(TestChunkerOpaqueDisplayItem(
      client1, DisplayItemType(1), IntRect(0, 0, 100, 100)));
  chunker.IncrementDisplayItemIndex(TestChunkerOpaqueDisplayItem(
      client2, DisplayItemType(2), IntRect(0, 100, 100, 50)));
  chunker.SetWillForceNewChunk(true);
  // Two opaque items. Has empty area in the united bounds.
  chunker.IncrementDisplayItemIndex(TestChunkerOpaqueDisplayItem(
      client1, DisplayItemType(3), IntRect(0, 0, 100, 100)));
  chunker.IncrementDisplayItemIndex(TestChunkerOpaqueDisplayItem(
      client3, DisplayItemType(4), IntRect(50, 50, 100, 100)));

  EXPECT_THAT(
      chunks,
      ElementsAre(
          IsPaintChunk(0, 1, PaintChunk::Id(client1, DisplayItemType(0)),
                       properties, nullptr, IntRect(0, 0, 100, 100)),
          IsPaintChunk(1, 3, PaintChunk::Id(client1, DisplayItemType(1)),
                       properties, nullptr, IntRect(0, 0, 100, 150)),
          IsPaintChunk(3, 5, PaintChunk::Id(client1, DisplayItemType(3)),
                       properties, nullptr, IntRect(0, 0, 150, 150))));
  ASSERT_EQ(3u, chunks.size());
  EXPECT_TRUE(chunks[0].known_to_be_opaque);
  EXPECT_TRUE(chunks[1].known_to_be_opaque);
  EXPECT_FALSE(chunks[2].known_to_be_opaque);
}

TEST_F(PaintChunkerTest, ChunkBoundsAndKnownToBeOpaqueWithHitTest) {
  ScopedCompositeAfterPaintForTest cap(true);
  Vector<PaintChunk> chunks;
  PaintChunker chunker(chunks);
  FakeDisplayItemClient client1("client1");
  FakeDisplayItemClient client2("client2");
  FakeDisplayItemClient client3("client3");

  auto properties = DefaultPaintChunkProperties();
  chunker.UpdateCurrentPaintChunkProperties(nullptr, properties);
  // Hit test rect only.
  chunker.AddHitTestDataToCurrentChunk(
      PaintChunk::Id(client1, DisplayItemType(0)), IntRect(10, 20, 30, 40),
      TouchAction::kAuto, false);
  chunker.SetWillForceNewChunk(true);

  // Hit test rect is smaller than the opaque item.
  chunker.IncrementDisplayItemIndex(TestChunkerOpaqueDisplayItem(
      client1, DisplayItemType(1), IntRect(0, 0, 100, 100)));
  chunker.AddHitTestDataToCurrentChunk(
      PaintChunk::Id(client1, DisplayItemType(2)), IntRect(0, 0, 50, 100),
      TouchAction::kAuto, false);
  chunker.SetWillForceNewChunk(true);
  // Hit test rect is the same as the opaque item.
  chunker.IncrementDisplayItemIndex(TestChunkerOpaqueDisplayItem(
      client1, DisplayItemType(3), IntRect(0, 0, 100, 100)));
  chunker.AddHitTestDataToCurrentChunk(
      PaintChunk::Id(client1, DisplayItemType(4)), IntRect(0, 0, 100, 100),
      TouchAction::kAuto, false);
  chunker.SetWillForceNewChunk(true);
  // Hit test rect is bigger than the opaque item.
  chunker.IncrementDisplayItemIndex(TestChunkerOpaqueDisplayItem(
      client1, DisplayItemType(5), IntRect(0, 0, 100, 100)));
  chunker.AddHitTestDataToCurrentChunk(
      PaintChunk::Id(client1, DisplayItemType(6)), IntRect(0, 100, 200, 100),
      TouchAction::kAuto, false);

  EXPECT_THAT(
      chunks,
      ElementsAre(
          IsPaintChunk(0, 0, PaintChunk::Id(client1, DisplayItemType(0)),
                       properties, nullptr, IntRect(10, 20, 30, 40)),
          IsPaintChunk(0, 1, PaintChunk::Id(client1, DisplayItemType(1)),
                       properties, nullptr, IntRect(0, 0, 100, 100)),
          IsPaintChunk(1, 2, PaintChunk::Id(client1, DisplayItemType(3)),
                       properties, nullptr, IntRect(0, 0, 100, 100)),
          IsPaintChunk(2, 3, PaintChunk::Id(client1, DisplayItemType(5)),
                       properties, nullptr, IntRect(0, 0, 200, 200))));
  ASSERT_EQ(4u, chunks.size());
  EXPECT_FALSE(chunks[0].known_to_be_opaque);
  EXPECT_TRUE(chunks[1].known_to_be_opaque);
  EXPECT_TRUE(chunks[2].known_to_be_opaque);
  EXPECT_FALSE(chunks[3].known_to_be_opaque);
}

TEST_F(PaintChunkerTest, ChunkBoundsAndKnownToBeOpaqueMixedOpaquenessItems) {
  ScopedCompositeAfterPaintForTest cap(true);
  Vector<PaintChunk> chunks;
  PaintChunker chunker(chunks);
  FakeDisplayItemClient client1("client1");
  FakeDisplayItemClient client2("client2");
  IntRect visual_rect1(0, 0, 100, 100);
  IntRect visual_rect2(50, 50, 50, 50);

  auto properties = DefaultPaintChunkProperties();
  chunker.UpdateCurrentPaintChunkProperties(nullptr, properties);
  // Single translucent item .
  chunker.IncrementDisplayItemIndex(
      TestChunkerDisplayItem(client1, DisplayItemType(1), visual_rect1));
  chunker.SetWillForceNewChunk(true);
  // Two items, one translucent, one opaque. The opaque item doesn't contain
  // the translucent item.
  chunker.IncrementDisplayItemIndex(
      TestChunkerDisplayItem(client1, DisplayItemType(2), visual_rect1));
  chunker.IncrementDisplayItemIndex(
      TestChunkerOpaqueDisplayItem(client2, DisplayItemType(3), visual_rect2));
  chunker.SetWillForceNewChunk(true);
  // Two items, one translucent, one opaque, with the same visual rect.
  chunker.IncrementDisplayItemIndex(
      TestChunkerDisplayItem(client1, DisplayItemType(4), visual_rect1));
  chunker.IncrementDisplayItemIndex(
      TestChunkerOpaqueDisplayItem(client1, DisplayItemType(5), visual_rect1));
  chunker.SetWillForceNewChunk(true);
  // Two items, one opaque, one translucent. The opaque item contains the
  // translucent item.
  chunker.IncrementDisplayItemIndex(
      TestChunkerOpaqueDisplayItem(client1, DisplayItemType(6), visual_rect1));
  chunker.IncrementDisplayItemIndex(
      TestChunkerDisplayItem(client2, DisplayItemType(7), visual_rect2));

  chunker.ResetChunks(nullptr);

  EXPECT_THAT(
      chunks,
      ElementsAre(
          IsPaintChunk(0, 1, PaintChunk::Id(client1, DisplayItemType(1)),
                       properties, nullptr, IntRect(0, 0, 100, 100)),
          IsPaintChunk(1, 3, PaintChunk::Id(client1, DisplayItemType(2)),
                       properties, nullptr, IntRect(0, 0, 100, 100)),
          IsPaintChunk(3, 5, PaintChunk::Id(client1, DisplayItemType(4)),
                       properties, nullptr, IntRect(0, 0, 100, 100)),
          IsPaintChunk(5, 7, PaintChunk::Id(client1, DisplayItemType(6)),
                       properties, nullptr, IntRect(0, 0, 100, 100))));
  ASSERT_EQ(4u, chunks.size());
  EXPECT_FALSE(chunks[0].known_to_be_opaque);
  EXPECT_FALSE(chunks[1].known_to_be_opaque);
  EXPECT_TRUE(chunks[2].known_to_be_opaque);
  EXPECT_TRUE(chunks[3].known_to_be_opaque);
}

}  // namespace
}  // namespace blink