layer_impl_unittest.cc 24 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550
  1. // Copyright 2011 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "cc/layers/layer_impl.h"
  5. #include <algorithm>
  6. #include "base/memory/raw_ptr.h"
  7. #include "cc/layers/painted_scrollbar_layer_impl.h"
  8. #include "cc/layers/solid_color_scrollbar_layer_impl.h"
  9. #include "cc/paint/filter_operation.h"
  10. #include "cc/paint/filter_operations.h"
  11. #include "cc/test/animation_test_common.h"
  12. #include "cc/test/layer_tree_impl_test_base.h"
  13. #include "cc/trees/layer_tree_impl.h"
  14. #include "cc/trees/single_thread_proxy.h"
  15. #include "cc/trees/tree_synchronizer.h"
  16. #include "testing/gmock/include/gmock/gmock.h"
  17. #include "testing/gtest/include/gtest/gtest.h"
  18. #include "ui/gfx/geometry/test/geometry_util.h"
  19. namespace cc {
  20. namespace {
  21. #define EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(code_to_test) \
  22. root->layer_tree_impl()->ResetAllChangeTracking(); \
  23. code_to_test; \
  24. EXPECT_FALSE(root->LayerPropertyChanged()); \
  25. EXPECT_FALSE(child->LayerPropertyChanged()); \
  26. EXPECT_FALSE(grand_child->LayerPropertyChanged());
  27. #define EXECUTE_AND_VERIFY_SUBTREE_CHANGED(code_to_test) \
  28. root->layer_tree_impl()->ResetAllChangeTracking(); \
  29. code_to_test; \
  30. EXPECT_TRUE(root->LayerPropertyChanged()); \
  31. EXPECT_TRUE(root->LayerPropertyChangedFromPropertyTrees()); \
  32. EXPECT_FALSE(root->LayerPropertyChangedNotFromPropertyTrees()); \
  33. EXPECT_TRUE(child->LayerPropertyChanged()); \
  34. EXPECT_TRUE(child->LayerPropertyChangedFromPropertyTrees()); \
  35. EXPECT_FALSE(child->LayerPropertyChangedNotFromPropertyTrees()); \
  36. EXPECT_TRUE(grand_child->LayerPropertyChanged()); \
  37. EXPECT_TRUE(grand_child->LayerPropertyChangedFromPropertyTrees()); \
  38. EXPECT_FALSE(grand_child->LayerPropertyChangedNotFromPropertyTrees());
  39. #define EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(code_to_test) \
  40. root->layer_tree_impl()->ResetAllChangeTracking(); \
  41. root->layer_tree_impl()->property_trees()->set_full_tree_damaged(false); \
  42. code_to_test; \
  43. EXPECT_TRUE(root->LayerPropertyChanged()); \
  44. EXPECT_FALSE(root->LayerPropertyChangedFromPropertyTrees()); \
  45. EXPECT_TRUE(root->LayerPropertyChangedNotFromPropertyTrees()); \
  46. EXPECT_FALSE(child->LayerPropertyChanged()); \
  47. EXPECT_FALSE(grand_child->LayerPropertyChanged());
  48. #define VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(code_to_test) \
  49. root->layer_tree_impl()->ResetAllChangeTracking(); \
  50. host_impl()->ForcePrepareToDraw(); \
  51. EXPECT_FALSE(host_impl()->active_tree()->needs_update_draw_properties()); \
  52. code_to_test; \
  53. EXPECT_TRUE(host_impl()->active_tree()->needs_update_draw_properties());
  54. #define VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(code_to_test) \
  55. root->layer_tree_impl()->ResetAllChangeTracking(); \
  56. host_impl()->ForcePrepareToDraw(); \
  57. EXPECT_FALSE(host_impl()->active_tree()->needs_update_draw_properties()); \
  58. code_to_test; \
  59. EXPECT_FALSE(host_impl()->active_tree()->needs_update_draw_properties());
  60. class LayerImplTest : public LayerTreeImplTestBase, public ::testing::Test {
  61. public:
  62. using LayerTreeImplTestBase::LayerTreeImplTestBase;
  63. };
  64. TEST_F(LayerImplTest, VerifyPendingLayerChangesAreTrackedProperly) {
  65. //
  66. // This test checks that LayerPropertyChanged() has the correct behavior.
  67. //
  68. // The constructor on this will fake that we are on the correct thread.
  69. // Create a simple LayerImpl tree:
  70. host_impl()->CreatePendingTree();
  71. LayerImpl* root = EnsureRootLayerInPendingTree();
  72. CreateClipNode(root);
  73. root->layer_tree_impl()->ResetAllChangeTracking();
  74. LayerImpl* child = AddLayerInPendingTree<LayerImpl>();
  75. CopyProperties(root, child);
  76. LayerImpl* grand_child = AddLayerInPendingTree<LayerImpl>();
  77. CopyProperties(child, grand_child);
  78. UpdatePendingTreeDrawProperties();
  79. // Creating children is an internal operation and should not mark layers as
  80. // changed.
  81. EXPECT_FALSE(root->LayerPropertyChanged());
  82. EXPECT_FALSE(child->LayerPropertyChanged());
  83. EXPECT_FALSE(grand_child->LayerPropertyChanged());
  84. float arbitrary_number = 0.352f;
  85. gfx::Size arbitrary_size = gfx::Size(111, 222);
  86. gfx::Point arbitrary_point = gfx::Point(333, 444);
  87. gfx::Rect arbitrary_rect = gfx::Rect(arbitrary_point, arbitrary_size);
  88. SkColor4f arbitrary_color{0.1f, 0.2f, 0.3f, 1.0f};
  89. gfx::Transform arbitrary_transform;
  90. arbitrary_transform.Scale3d(0.1f, 0.2f, 0.3f);
  91. FilterOperations arbitrary_filters;
  92. arbitrary_filters.Append(FilterOperation::CreateOpacityFilter(0.5f));
  93. // These properties are internal, and should not be considered "change" when
  94. // they are used.
  95. EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
  96. root->UnionUpdateRect(arbitrary_rect));
  97. EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(root->SetBounds(arbitrary_size));
  98. UpdatePendingTreeDrawProperties();
  99. // Changing these properties affects the entire subtree of layers.
  100. EXECUTE_AND_VERIFY_SUBTREE_CHANGED(
  101. host_impl()->pending_tree()->SetFilterMutated(root->element_id(),
  102. arbitrary_filters));
  103. EXECUTE_AND_VERIFY_SUBTREE_CHANGED(
  104. host_impl()->pending_tree()->SetFilterMutated(root->element_id(),
  105. FilterOperations()));
  106. EXECUTE_AND_VERIFY_SUBTREE_CHANGED(
  107. host_impl()->pending_tree()->SetOpacityMutated(root->element_id(),
  108. arbitrary_number));
  109. EXECUTE_AND_VERIFY_SUBTREE_CHANGED(
  110. host_impl()->pending_tree()->SetTransformMutated(root->element_id(),
  111. arbitrary_transform));
  112. // Changing these properties only affects the layer itself.
  113. EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(root->SetDrawsContent(true));
  114. EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(
  115. root->SetBackgroundColor(arbitrary_color));
  116. // Changing these properties does not cause the layer to be marked as changed
  117. // but does cause the layer to need to push properties.
  118. EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetElementId(ElementId(2)));
  119. // After setting all these properties already, setting to the exact same
  120. // values again should not cause any change.
  121. EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetContentsOpaque(true));
  122. EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetDrawsContent(true));
  123. EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetBounds(root->bounds()));
  124. }
  125. TEST_F(LayerImplTest, VerifyNeedsUpdateDrawProperties) {
  126. LayerImpl* root = root_layer();
  127. LayerImpl* layer = AddLayer<LayerImpl>();
  128. layer->SetBounds(gfx::Size(100, 100));
  129. LayerImpl* layer2 = AddLayer<LayerImpl>();
  130. SetElementIdsForTesting();
  131. CopyProperties(root, layer);
  132. CreateTransformNode(layer);
  133. CreateScrollNode(layer, gfx::Size(1, 1));
  134. CopyProperties(root, layer2);
  135. DCHECK(host_impl()->CanDraw());
  136. UpdateActiveTreeDrawProperties();
  137. float arbitrary_number = 0.352f;
  138. gfx::Size arbitrary_size = gfx::Size(111, 222);
  139. gfx::Vector2d arbitrary_vector2d = gfx::Vector2d(111, 222);
  140. gfx::PointF arbitrary_scroll_offset(
  141. gfx::PointAtOffsetFromOrigin(arbitrary_vector2d));
  142. gfx::Size large_size = gfx::Size(1000, 1000);
  143. SkColor4f arbitrary_color{0.1f, 0.2f, 0.3f, 1.0f};
  144. gfx::Transform arbitrary_transform;
  145. arbitrary_transform.Scale3d(0.1f, 0.2f, 0.3f);
  146. FilterOperations arbitrary_filters;
  147. arbitrary_filters.Append(FilterOperation::CreateOpacityFilter(0.5f));
  148. // Set layer to draw content so that their draw property by property trees is
  149. // verified.
  150. VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetDrawsContent(true));
  151. VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer2->SetDrawsContent(true));
  152. // Create a render surface, because we must have a render surface if we have
  153. // filters.
  154. CreateEffectNode(layer).render_surface_reason = RenderSurfaceReason::kTest;
  155. UpdateActiveTreeDrawProperties();
  156. // Related filter functions.
  157. VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
  158. host_impl()->active_tree()->SetFilterMutated(root->element_id(),
  159. arbitrary_filters));
  160. VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
  161. host_impl()->active_tree()->SetFilterMutated(root->element_id(),
  162. arbitrary_filters));
  163. VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
  164. host_impl()->active_tree()->SetFilterMutated(root->element_id(),
  165. FilterOperations()));
  166. VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
  167. host_impl()->active_tree()->SetFilterMutated(root->element_id(),
  168. arbitrary_filters));
  169. // Related scrolling functions.
  170. VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetBounds(large_size));
  171. VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetBounds(large_size));
  172. host_impl()->active_tree()->set_needs_update_draw_properties();
  173. UpdateActiveTreeDrawProperties();
  174. VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->ScrollBy(arbitrary_vector2d));
  175. VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->ScrollBy(gfx::Vector2d()));
  176. VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
  177. layer->layer_tree_impl()->DidUpdateScrollOffset(layer->element_id()));
  178. layer->layer_tree_impl()
  179. ->property_trees()
  180. ->scroll_tree_mutable()
  181. .SetScrollOffsetDeltaForTesting(layer->element_id(), gfx::Vector2dF());
  182. VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
  183. layer->SetCurrentScrollOffset(arbitrary_scroll_offset));
  184. VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
  185. layer->SetCurrentScrollOffset(arbitrary_scroll_offset));
  186. // Unrelated functions, always set to new values, always set needs update.
  187. host_impl()->active_tree()->set_needs_update_draw_properties();
  188. UpdateActiveTreeDrawProperties();
  189. CreateClipNode(layer);
  190. VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetContentsOpaque(true);
  191. layer->NoteLayerPropertyChanged());
  192. VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
  193. layer->SetBackgroundColor(arbitrary_color));
  194. VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
  195. host_impl()->active_tree()->SetOpacityMutated(layer->element_id(),
  196. arbitrary_number));
  197. VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
  198. host_impl()->active_tree()->SetTransformMutated(layer->element_id(),
  199. arbitrary_transform));
  200. VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetBounds(arbitrary_size);
  201. layer->NoteLayerPropertyChanged());
  202. // Unrelated functions, set to the same values, no needs update.
  203. GetEffectNode(layer)->filters = arbitrary_filters;
  204. UpdateActiveTreeDrawProperties();
  205. VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
  206. host_impl()->active_tree()->SetFilterMutated(layer->element_id(),
  207. arbitrary_filters));
  208. VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetContentsOpaque(true));
  209. VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetDrawsContent(true));
  210. VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
  211. layer->SetBackgroundColor(arbitrary_color));
  212. VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetBounds(arbitrary_size));
  213. VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetElementId(ElementId(2)));
  214. }
  215. TEST_F(LayerImplTest, PerspectiveTransformHasReasonableScale) {
  216. LayerImpl* layer = root_layer();
  217. layer->SetBounds(gfx::Size(10, 10));
  218. layer->set_contributes_to_drawn_render_surface(true);
  219. // Ensure that we are close to the maximum scale for the matrix.
  220. {
  221. gfx::Transform transform;
  222. transform.Scale(10.2f, 15.1f);
  223. transform.ApplyPerspectiveDepth(10);
  224. transform.RotateAboutXAxis(15.0f);
  225. layer->draw_properties().screen_space_transform = transform;
  226. ASSERT_TRUE(layer->ScreenSpaceTransform().HasPerspective());
  227. EXPECT_EQ(gfx::Vector2dF(15.f, 15.f), layer->GetIdealContentsScale());
  228. }
  229. // Ensure that we don't fall below the device scale factor.
  230. {
  231. gfx::Transform transform;
  232. transform.Scale(0.1f, 0.2f);
  233. transform.ApplyPerspectiveDepth(10);
  234. transform.RotateAboutXAxis(15.0f);
  235. layer->draw_properties().screen_space_transform = transform;
  236. ASSERT_TRUE(layer->ScreenSpaceTransform().HasPerspective());
  237. EXPECT_EQ(gfx::Vector2dF(1.f, 1.f), layer->GetIdealContentsScale());
  238. }
  239. // Ensure that large scales don't end up extremely large.
  240. {
  241. gfx::Transform transform;
  242. transform.Scale(10000.1f, 10000.2f);
  243. transform.ApplyPerspectiveDepth(10);
  244. transform.RotateAboutXAxis(15.0f);
  245. layer->draw_properties().screen_space_transform = transform;
  246. ASSERT_TRUE(layer->ScreenSpaceTransform().HasPerspective());
  247. EXPECT_EQ(gfx::Vector2dF(127.f, 127.f), layer->GetIdealContentsScale());
  248. }
  249. // Test case from crbug.com/766021.
  250. {
  251. gfx::Transform transform(-0.9397f, -0.7019f, 0.2796f, 2383.4521f, // row 1
  252. -0.0038f, 0.0785f, 1.0613f, 1876.4553f, // row 2
  253. -0.0835f, 0.9081f, -0.4105f, -2208.3035f, // row 3
  254. 0.0001f, -0.0008f, 0.0003f, 2.8435f); // row 4
  255. layer->draw_properties().screen_space_transform = transform;
  256. ASSERT_TRUE(layer->ScreenSpaceTransform().HasPerspective());
  257. EXPECT_EQ(gfx::Vector2dF(1.f, 1.f), layer->GetIdealContentsScale());
  258. }
  259. }
  260. class LayerImplScrollTest : public LayerImplTest {
  261. public:
  262. LayerImplScrollTest() : LayerImplScrollTest(LayerListSettings()) {}
  263. explicit LayerImplScrollTest(const LayerTreeSettings& settings)
  264. : LayerImplTest(settings) {
  265. LayerImpl* root = root_layer();
  266. root->SetBounds(gfx::Size(1, 1));
  267. layer_ = AddLayer<LayerImpl>();
  268. SetElementIdsForTesting();
  269. // Set the max scroll offset by noting that the root layer has bounds (1,1),
  270. // thus whatever bounds are set for the layer will be the max scroll
  271. // offset plus 1 in each direction.
  272. layer_->SetBounds(gfx::Size(51, 81));
  273. CopyProperties(root, layer_);
  274. CreateTransformNode(layer_);
  275. CreateScrollNode(layer_, gfx::Size(1, 1));
  276. UpdateActiveTreeDrawProperties();
  277. }
  278. LayerImpl* layer() { return layer_; }
  279. ScrollTree* scroll_tree(LayerImpl* layer_impl) {
  280. return &layer_impl->layer_tree_impl()
  281. ->property_trees()
  282. ->scroll_tree_mutable();
  283. }
  284. private:
  285. raw_ptr<LayerImpl> layer_;
  286. };
  287. class CommitToPendingTreeLayerImplScrollTest : public LayerImplScrollTest {
  288. public:
  289. CommitToPendingTreeLayerImplScrollTest() : LayerImplScrollTest(settings()) {}
  290. LayerTreeSettings settings() {
  291. LayerListSettings settings;
  292. settings.commit_to_active_tree = false;
  293. return settings;
  294. }
  295. };
  296. TEST_F(LayerImplScrollTest, ScrollByWithZeroOffset) {
  297. // Test that LayerImpl::ScrollBy only affects ScrollDelta and total scroll
  298. // offset is bounded by the range [0, max scroll offset].
  299. EXPECT_POINTF_EQ(gfx::PointF(), CurrentScrollOffset(layer()));
  300. EXPECT_POINTF_EQ(gfx::PointF(),
  301. scroll_tree(layer())->GetScrollOffsetBaseForTesting(
  302. layer()->element_id()));
  303. EXPECT_VECTOR2DF_EQ(gfx::Vector2dF(), ScrollDelta(layer()));
  304. layer()->ScrollBy(gfx::Vector2dF(-100, 100));
  305. EXPECT_POINTF_EQ(gfx::PointF(0, 80), CurrentScrollOffset(layer()));
  306. EXPECT_POINTF_EQ(gfx::PointAtOffsetFromOrigin(ScrollDelta(layer())),
  307. CurrentScrollOffset(layer()));
  308. EXPECT_POINTF_EQ(gfx::PointF(),
  309. scroll_tree(layer())->GetScrollOffsetBaseForTesting(
  310. layer()->element_id()));
  311. layer()->ScrollBy(gfx::Vector2dF(100, -100));
  312. EXPECT_POINTF_EQ(gfx::PointF(50, 0), CurrentScrollOffset(layer()));
  313. EXPECT_POINTF_EQ(gfx::PointAtOffsetFromOrigin(ScrollDelta(layer())),
  314. CurrentScrollOffset(layer()));
  315. EXPECT_POINTF_EQ(gfx::PointF(),
  316. scroll_tree(layer())->GetScrollOffsetBaseForTesting(
  317. layer()->element_id()));
  318. }
  319. TEST_F(LayerImplScrollTest, ScrollByWithNonZeroOffset) {
  320. gfx::PointF scroll_offset(10, 5);
  321. scroll_tree(layer())->UpdateScrollOffsetBaseForTesting(layer()->element_id(),
  322. scroll_offset);
  323. EXPECT_POINTF_EQ(scroll_offset, CurrentScrollOffset(layer()));
  324. EXPECT_POINTF_EQ(scroll_offset,
  325. scroll_tree(layer())->GetScrollOffsetBaseForTesting(
  326. layer()->element_id()));
  327. EXPECT_VECTOR2DF_EQ(gfx::Vector2dF(), ScrollDelta(layer()));
  328. layer()->ScrollBy(gfx::Vector2dF(-100, 100));
  329. EXPECT_POINTF_EQ(gfx::PointF(0, 80), CurrentScrollOffset(layer()));
  330. EXPECT_POINTF_EQ(scroll_offset + ScrollDelta(layer()),
  331. CurrentScrollOffset(layer()));
  332. EXPECT_POINTF_EQ(scroll_offset,
  333. scroll_tree(layer())->GetScrollOffsetBaseForTesting(
  334. layer()->element_id()));
  335. layer()->ScrollBy(gfx::Vector2dF(100, -100));
  336. EXPECT_POINTF_EQ(gfx::PointF(50, 0), CurrentScrollOffset(layer()));
  337. EXPECT_POINTF_EQ(scroll_offset + ScrollDelta(layer()),
  338. CurrentScrollOffset(layer()));
  339. EXPECT_POINTF_EQ(scroll_offset,
  340. scroll_tree(layer())->GetScrollOffsetBaseForTesting(
  341. layer()->element_id()));
  342. }
  343. TEST_F(LayerImplScrollTest, ApplySentScrollsNoListener) {
  344. gfx::PointF scroll_offset(10, 5);
  345. gfx::Vector2dF scroll_delta(20.5f, 8.5f);
  346. gfx::Vector2d sent_scroll_delta(12, -3);
  347. scroll_tree(layer())->UpdateScrollOffsetBaseForTesting(layer()->element_id(),
  348. scroll_offset);
  349. layer()->ScrollBy(sent_scroll_delta);
  350. scroll_tree(layer())->CollectScrollDeltasForTesting();
  351. layer()->SetCurrentScrollOffset(scroll_offset + scroll_delta);
  352. EXPECT_POINTF_EQ(scroll_offset + scroll_delta, CurrentScrollOffset(layer()));
  353. EXPECT_VECTOR2DF_EQ(scroll_delta, ScrollDelta(layer()));
  354. EXPECT_POINTF_EQ(scroll_offset,
  355. scroll_tree(layer())->GetScrollOffsetBaseForTesting(
  356. layer()->element_id()));
  357. scroll_tree(layer())->ApplySentScrollDeltasFromAbortedCommit(
  358. /*main_frame_applied_deltas=*/true);
  359. EXPECT_POINTF_EQ(scroll_offset + scroll_delta, CurrentScrollOffset(layer()));
  360. EXPECT_VECTOR2DF_EQ(scroll_delta - sent_scroll_delta, ScrollDelta(layer()));
  361. EXPECT_POINTF_EQ(scroll_offset + sent_scroll_delta,
  362. scroll_tree(layer())->GetScrollOffsetBaseForTesting(
  363. layer()->element_id()));
  364. }
  365. TEST_F(LayerImplScrollTest, ScrollUserUnscrollableLayer) {
  366. gfx::PointF scroll_offset(10, 5);
  367. gfx::Vector2dF scroll_delta(20.5f, 8.5f);
  368. GetScrollNode(layer())->user_scrollable_vertical = false;
  369. UpdateDrawProperties(layer()->layer_tree_impl());
  370. scroll_tree(layer())->UpdateScrollOffsetBaseForTesting(layer()->element_id(),
  371. scroll_offset);
  372. gfx::Vector2dF unscrolled = layer()->ScrollBy(scroll_delta);
  373. EXPECT_VECTOR2DF_EQ(gfx::Vector2dF(0, 8.5f), unscrolled);
  374. EXPECT_POINTF_EQ(gfx::PointF(30.5f, 5), CurrentScrollOffset(layer()));
  375. }
  376. // |LayerImpl::all_touch_action_regions_| is a cache of all regions on
  377. // |LayerImpl::touch_action_region_| and must be invalidated on changes.
  378. TEST_F(LayerImplScrollTest, TouchActionRegionCacheInvalidation) {
  379. host_impl()->CreatePendingTree();
  380. std::unique_ptr<LayerImpl> pending_layer =
  381. LayerImpl::Create(host_impl()->pending_tree(), 2);
  382. TouchActionRegion region;
  383. region.Union(TouchAction::kNone, gfx::Rect(0, 0, 50, 50));
  384. pending_layer->SetTouchActionRegion(region);
  385. // The values for GetAllTouchActionRegions should be correct on both layers.
  386. // Note that querying GetAllTouchActionRegions will update the cached value
  387. // in |LayerImpl::all_touch_action_regions_|.
  388. EXPECT_EQ(pending_layer->GetAllTouchActionRegions(), region.GetAllRegions());
  389. EXPECT_EQ(layer()->GetAllTouchActionRegions(), Region());
  390. pending_layer->PushPropertiesTo(layer());
  391. // After pushing properties, the value for GetAllTouchActionRegions should
  392. // not be stale.
  393. EXPECT_EQ(pending_layer->GetAllTouchActionRegions(), region.GetAllRegions());
  394. EXPECT_EQ(layer()->GetAllTouchActionRegions(), region.GetAllRegions());
  395. }
  396. TEST_F(CommitToPendingTreeLayerImplScrollTest,
  397. PushPropertiesToMirrorsCurrentScrollOffset) {
  398. gfx::PointF scroll_offset(10, 5);
  399. gfx::Vector2dF scroll_delta(12, 18);
  400. host_impl()->CreatePendingTree();
  401. scroll_tree(layer())->UpdateScrollOffsetBaseForTesting(layer()->element_id(),
  402. scroll_offset);
  403. gfx::Vector2dF unscrolled = layer()->ScrollBy(scroll_delta);
  404. EXPECT_VECTOR2DF_EQ(gfx::Vector2dF(0, 0), unscrolled);
  405. EXPECT_POINTF_EQ(gfx::PointF(22, 23), CurrentScrollOffset(layer()));
  406. scroll_tree(layer())->CollectScrollDeltasForTesting();
  407. std::unique_ptr<LayerImpl> pending_layer =
  408. LayerImpl::Create(host_impl()->sync_tree(), layer()->id());
  409. pending_layer->SetElementId(
  410. LayerIdToElementIdForTesting(pending_layer->id()));
  411. scroll_tree(pending_layer.get())
  412. ->UpdateScrollOffsetBaseForTesting(pending_layer->element_id(),
  413. CurrentScrollOffset(layer()));
  414. pending_layer->PushPropertiesTo(layer());
  415. EXPECT_POINTF_EQ(gfx::PointF(22, 23), CurrentScrollOffset(layer()));
  416. EXPECT_POINTF_EQ(CurrentScrollOffset(layer()),
  417. CurrentScrollOffset(pending_layer.get()));
  418. }
  419. TEST_F(LayerImplTest, JitterTest) {
  420. host_impl()->CreatePendingTree();
  421. auto* root_layer = EnsureRootLayerInPendingTree();
  422. root_layer->SetBounds(gfx::Size(50, 50));
  423. SetupViewport(root_layer, gfx::Size(100, 100), gfx::Size(100, 100));
  424. auto* scroll_layer =
  425. host_impl()->pending_tree()->InnerViewportScrollLayerForTesting();
  426. auto* content_layer = AddLayerInPendingTree<LayerImpl>();
  427. content_layer->SetBounds(gfx::Size(100, 100));
  428. content_layer->SetDrawsContent(true);
  429. CopyProperties(
  430. host_impl()->pending_tree()->OuterViewportScrollLayerForTesting(),
  431. content_layer);
  432. UpdatePendingTreeDrawProperties();
  433. host_impl()->pending_tree()->PushPageScaleFromMainThread(1.f, 1.f, 1.f);
  434. const int scroll = 5;
  435. int accumulated_scroll = 0;
  436. for (int i = 0; i < LayerTreeImpl::kFixedPointHitsThreshold + 1; ++i) {
  437. host_impl()->ActivateSyncTree();
  438. accumulated_scroll += scroll;
  439. SetScrollOffset(
  440. host_impl()->active_tree()->InnerViewportScrollLayerForTesting(),
  441. gfx::PointF(0, accumulated_scroll));
  442. UpdateActiveTreeDrawProperties();
  443. host_impl()->CreatePendingTree();
  444. LayerTreeImpl* pending_tree = host_impl()->pending_tree();
  445. pending_tree->set_source_frame_number(i + 1);
  446. pending_tree->PushPageScaleFromMainThread(1.f, 1.f, 1.f);
  447. // Simulate scroll offset pushed from the main thread.
  448. SetScrollOffset(scroll_layer, gfx::PointF(0, accumulated_scroll));
  449. // The scroll done on the active tree is undone on the pending tree.
  450. content_layer->SetOffsetToTransformParent(
  451. gfx::Vector2dF(0, accumulated_scroll));
  452. content_layer->SetNeedsPushProperties();
  453. UpdateDrawProperties(pending_tree);
  454. float jitter = content_layer->CalculateJitter();
  455. // There should not be any jitter measured till we hit the fixed point hits
  456. // threshold. 250 is sqrt(50 * 50) * 5. 50x50 is the visible bounds of
  457. // content (clipped by the viewport). 5 is the distance between the
  458. // locations of the content in the pending tree and the active tree.
  459. float expected_jitter =
  460. (i == pending_tree->kFixedPointHitsThreshold) ? 250 : 0;
  461. EXPECT_EQ(jitter, expected_jitter);
  462. }
  463. }
  464. } // namespace
  465. } // namespace cc