src/cc/layers/layer_impl_unittest.cc

   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
   5 #include "cc/layers/layer_impl.h"
   6
   7 #include "cc/layers/painted_scrollbar_layer_impl.h"
   8 #include "cc/output/filter_operation.h"
   9 #include "cc/output/filter_operations.h"
  10 #include "cc/test/fake_impl_proxy.h"
  11 #include "cc/test/fake_layer_tree_host_impl.h"
  12 #include "cc/test/fake_output_surface.h"
  13 #include "cc/test/geometry_test_utils.h"
  14 #include "cc/test/test_shared_bitmap_manager.h"
  15 #include "cc/trees/layer_tree_impl.h"
  16 #include "cc/trees/single_thread_proxy.h"
  17 #include "testing/gmock/include/gmock/gmock.h"
  18 #include "testing/gtest/include/gtest/gtest.h"
  19 #include "third_party/skia/include/effects/SkBlurImageFilter.h"
  20
  21 namespace cc {
  22 namespace {
  23
  24 #define EXECUTE_AND_VERIFY_SUBTREE_CHANGED(code_to_test)                       \
  25   root->ResetAllChangeTrackingForSubtree();                                    \
  26   code_to_test;                                                                \
  27   EXPECT_TRUE(root->needs_push_properties());                                  \
  28   EXPECT_FALSE(child->needs_push_properties());                                \
  29   EXPECT_FALSE(grand_child->needs_push_properties());                          \
  30   EXPECT_TRUE(root->LayerPropertyChanged());                                   \
  31   EXPECT_TRUE(child->LayerPropertyChanged());                                  \
  32   EXPECT_TRUE(grand_child->LayerPropertyChanged());
  33
  34 #define EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(code_to_test)                \
  35   root->ResetAllChangeTrackingForSubtree();                                    \
  36   code_to_test;                                                                \
  37   EXPECT_FALSE(root->needs_push_properties());                                 \
  38   EXPECT_FALSE(child->needs_push_properties());                                \
  39   EXPECT_FALSE(grand_child->needs_push_properties());                          \
  40   EXPECT_FALSE(root->LayerPropertyChanged());                                  \
  41   EXPECT_FALSE(child->LayerPropertyChanged());                                 \
  42   EXPECT_FALSE(grand_child->LayerPropertyChanged());
  43
  44 #define EXECUTE_AND_VERIFY_NEEDS_PUSH_PROPERTIES_AND_SUBTREE_DID_NOT_CHANGE(   \
  45       code_to_test)                                                            \
  46   root->ResetAllChangeTrackingForSubtree();                                    \
  47   code_to_test;                                                                \
  48   EXPECT_TRUE(root->needs_push_properties());                                  \
  49   EXPECT_FALSE(child->needs_push_properties());                                \
  50   EXPECT_FALSE(grand_child->needs_push_properties());                          \
  51   EXPECT_FALSE(root->LayerPropertyChanged());                                  \
  52   EXPECT_FALSE(child->LayerPropertyChanged());                                 \
  53   EXPECT_FALSE(grand_child->LayerPropertyChanged());
  54
  55 #define EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(code_to_test)                    \
  56   root->ResetAllChangeTrackingForSubtree();                                    \
  57   code_to_test;                                                                \
  58   EXPECT_TRUE(root->needs_push_properties());                                  \
  59   EXPECT_FALSE(child->needs_push_properties());                                \
  60   EXPECT_FALSE(grand_child->needs_push_properties());                          \
  61   EXPECT_TRUE(root->LayerPropertyChanged());                                   \
  62   EXPECT_FALSE(child->LayerPropertyChanged());                                 \
  63   EXPECT_FALSE(grand_child->LayerPropertyChanged());
  64
  65 #define VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(code_to_test)                      \
  66   root->ResetAllChangeTrackingForSubtree();                                    \
  67   host_impl.ForcePrepareToDraw();                                              \
  68   EXPECT_FALSE(host_impl.active_tree()->needs_update_draw_properties());       \
  69   code_to_test;                                                                \
  70   EXPECT_TRUE(host_impl.active_tree()->needs_update_draw_properties());
  71
  72 #define VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(code_to_test)                   \
  73   root->ResetAllChangeTrackingForSubtree();                                    \
  74   host_impl.ForcePrepareToDraw();                                              \
  75   EXPECT_FALSE(host_impl.active_tree()->needs_update_draw_properties());       \
  76   code_to_test;                                                                \
  77   EXPECT_FALSE(host_impl.active_tree()->needs_update_draw_properties());
  78
  79 TEST(LayerImplTest, VerifyLayerChangesAreTrackedProperly) {
  80   //
  81   // This test checks that layerPropertyChanged() has the correct behavior.
  82   //
  83
  84   // The constructor on this will fake that we are on the correct thread.
  85   // Create a simple LayerImpl tree:
  86   FakeImplProxy proxy;
  87   TestSharedBitmapManager shared_bitmap_manager;
  88   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
  89   EXPECT_TRUE(host_impl.InitializeRenderer(FakeOutputSurface::Create3d()));
  90   scoped_ptr<LayerImpl> root_clip =
  91       LayerImpl::Create(host_impl.active_tree(), 1);
  92   scoped_ptr<LayerImpl> root_ptr =
  93       LayerImpl::Create(host_impl.active_tree(), 2);
  94   LayerImpl* root = root_ptr.get();
  95   root_clip->AddChild(root_ptr.Pass());
  96   scoped_ptr<LayerImpl> scroll_parent =
  97       LayerImpl::Create(host_impl.active_tree(), 3);
  98   LayerImpl* scroll_child = LayerImpl::Create(host_impl.active_tree(), 4).get();
  99   std::set<LayerImpl*>* scroll_children = new std::set<LayerImpl*>();
 100   scroll_children->insert(scroll_child);
 101   scroll_children->insert(root);
 102
 103   scoped_ptr<LayerImpl> clip_parent =
 104       LayerImpl::Create(host_impl.active_tree(), 5);
 105   LayerImpl* clip_child = LayerImpl::Create(host_impl.active_tree(), 6).get();
 106   std::set<LayerImpl*>* clip_children = new std::set<LayerImpl*>();
 107   clip_children->insert(clip_child);
 108   clip_children->insert(root);
 109
 110   root->AddChild(LayerImpl::Create(host_impl.active_tree(), 7));
 111   LayerImpl* child = root->children()[0];
 112   child->AddChild(LayerImpl::Create(host_impl.active_tree(), 8));
 113   LayerImpl* grand_child = child->children()[0];
 114
 115   root->SetScrollClipLayer(root_clip->id());
 116
 117   // Adding children is an internal operation and should not mark layers as
 118   // changed.
 119   EXPECT_FALSE(root->LayerPropertyChanged());
 120   EXPECT_FALSE(child->LayerPropertyChanged());
 121   EXPECT_FALSE(grand_child->LayerPropertyChanged());
 122
 123   gfx::PointF arbitrary_point_f = gfx::PointF(0.125f, 0.25f);
 124   gfx::Point3F arbitrary_point_3f = gfx::Point3F(0.125f, 0.25f, 0.f);
 125   float arbitrary_number = 0.352f;
 126   gfx::Size arbitrary_size = gfx::Size(111, 222);
 127   gfx::Point arbitrary_point = gfx::Point(333, 444);
 128   gfx::Vector2d arbitrary_vector2d = gfx::Vector2d(111, 222);
 129   gfx::Rect arbitrary_rect = gfx::Rect(arbitrary_point, arbitrary_size);
 130   gfx::RectF arbitrary_rect_f =
 131       gfx::RectF(arbitrary_point_f, gfx::SizeF(1.234f, 5.678f));
 132   SkColor arbitrary_color = SkColorSetRGB(10, 20, 30);
 133   gfx::Transform arbitrary_transform;
 134   arbitrary_transform.Scale3d(0.1f, 0.2f, 0.3f);
 135   FilterOperations arbitrary_filters;
 136   arbitrary_filters.Append(FilterOperation::CreateOpacityFilter(0.5f));
 137   SkXfermode::Mode arbitrary_blend_mode = SkXfermode::kMultiply_Mode;
 138
 139   // These properties are internal, and should not be considered "change" when
 140   // they are used.
 141   EXECUTE_AND_VERIFY_NEEDS_PUSH_PROPERTIES_AND_SUBTREE_DID_NOT_CHANGE(
 142       root->SetUpdateRect(arbitrary_rect));
 143   EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(root->SetBounds(arbitrary_size));
 144
 145   // Changing these properties affects the entire subtree of layers.
 146   EXECUTE_AND_VERIFY_SUBTREE_CHANGED(
 147       root->SetTransformOrigin(arbitrary_point_3f));
 148   EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetFilters(arbitrary_filters));
 149   EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetFilters(FilterOperations()));
 150   EXECUTE_AND_VERIFY_SUBTREE_CHANGED(
 151       root->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 9)));
 152   EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetMasksToBounds(true));
 153   EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetContentsOpaque(true));
 154   EXECUTE_AND_VERIFY_SUBTREE_CHANGED(
 155       root->SetReplicaLayer(LayerImpl::Create(host_impl.active_tree(), 10)));
 156   EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetPosition(arbitrary_point_f));
 157   EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetShouldFlattenTransform(false));
 158   EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->Set3dSortingContextId(1));
 159   EXECUTE_AND_VERIFY_SUBTREE_CHANGED(
 160       root->SetDoubleSided(false));  // constructor initializes it to "true".
 161   EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->ScrollBy(arbitrary_vector2d));
 162   EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetScrollDelta(gfx::Vector2d()));
 163   EXECUTE_AND_VERIFY_SUBTREE_CHANGED(
 164       root->SetScrollOffset(gfx::ScrollOffset(arbitrary_vector2d)));
 165   EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetHideLayerAndSubtree(true));
 166   EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetOpacity(arbitrary_number));
 167   EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetBlendMode(arbitrary_blend_mode));
 168   EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetTransform(arbitrary_transform));
 169
 170   // Changing these properties only affects the layer itself.
 171   EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(root->SetContentBounds(arbitrary_size));
 172   EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(
 173       root->SetContentsScale(arbitrary_number, arbitrary_number));
 174   EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(root->SetDrawsContent(true));
 175   EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(
 176       root->SetBackgroundColor(arbitrary_color));
 177   EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(
 178       root->SetBackgroundFilters(arbitrary_filters));
 179
 180   // Special case: check that SetBounds changes behavior depending on
 181   // masksToBounds.
 182   root->SetMasksToBounds(false);
 183   EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(root->SetBounds(gfx::Size(135, 246)));
 184   root->SetMasksToBounds(true);
 185   // Should be a different size than previous call, to ensure it marks tree
 186   // changed.
 187   EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetBounds(arbitrary_size));
 188
 189   // Changing this property does not cause the layer to be marked as changed
 190   // but does cause the layer to need to push properties.
 191   EXECUTE_AND_VERIFY_NEEDS_PUSH_PROPERTIES_AND_SUBTREE_DID_NOT_CHANGE(
 192       root->SetIsRootForIsolatedGroup(true));
 193
 194   // Changing these properties should cause the layer to need to push properties
 195   EXECUTE_AND_VERIFY_NEEDS_PUSH_PROPERTIES_AND_SUBTREE_DID_NOT_CHANGE(
 196       root->SetScrollParent(scroll_parent.get()));
 197   EXECUTE_AND_VERIFY_NEEDS_PUSH_PROPERTIES_AND_SUBTREE_DID_NOT_CHANGE(
 198       root->SetScrollChildren(scroll_children));
 199   EXECUTE_AND_VERIFY_NEEDS_PUSH_PROPERTIES_AND_SUBTREE_DID_NOT_CHANGE(
 200       root->SetClipParent(clip_parent.get()));
 201   EXECUTE_AND_VERIFY_NEEDS_PUSH_PROPERTIES_AND_SUBTREE_DID_NOT_CHANGE(
 202       root->SetClipChildren(clip_children));
 203   EXECUTE_AND_VERIFY_NEEDS_PUSH_PROPERTIES_AND_SUBTREE_DID_NOT_CHANGE(
 204       root->SetNumDescendantsThatDrawContent(10));
 205
 206   // After setting all these properties already, setting to the exact same
 207   // values again should not cause any change.
 208   EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
 209       root->SetTransformOrigin(arbitrary_point_3f));
 210   EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetMasksToBounds(true));
 211   EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
 212       root->SetPosition(arbitrary_point_f));
 213   EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
 214       root->SetShouldFlattenTransform(false));
 215   EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->Set3dSortingContextId(1));
 216   EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
 217       root->SetTransform(arbitrary_transform));
 218   EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
 219       root->SetDoubleSided(false));  // constructor initializes it to "true".
 220   EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
 221       root->SetScrollDelta(gfx::Vector2d()));
 222   EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
 223       root->SetScrollOffset(gfx::ScrollOffset(arbitrary_vector2d)));
 224   EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
 225       root->SetContentBounds(arbitrary_size));
 226   EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
 227       root->SetContentsScale(arbitrary_number, arbitrary_number));
 228   EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetContentsOpaque(true));
 229   EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetOpacity(arbitrary_number));
 230   EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
 231       root->SetBlendMode(arbitrary_blend_mode));
 232   EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
 233       root->SetIsRootForIsolatedGroup(true));
 234   EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetDrawsContent(true));
 235   EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetBounds(arbitrary_size));
 236   EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
 237       root->SetScrollParent(scroll_parent.get()));
 238   EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
 239       root->SetScrollChildren(scroll_children));
 240   EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
 241       root->SetClipParent(clip_parent.get()));
 242   EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
 243       root->SetClipChildren(clip_children));
 244 }
 245
 246 TEST(LayerImplTest, VerifyNeedsUpdateDrawProperties) {
 247   FakeImplProxy proxy;
 248   TestSharedBitmapManager shared_bitmap_manager;
 249   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
 250   EXPECT_TRUE(host_impl.InitializeRenderer(FakeOutputSurface::Create3d()));
 251   host_impl.active_tree()->SetRootLayer(
 252       LayerImpl::Create(host_impl.active_tree(), 1));
 253   LayerImpl* root = host_impl.active_tree()->root_layer();
 254   scoped_ptr<LayerImpl> layer_ptr =
 255       LayerImpl::Create(host_impl.active_tree(), 2);
 256   LayerImpl* layer = layer_ptr.get();
 257   root->AddChild(layer_ptr.Pass());
 258   layer->SetScrollClipLayer(root->id());
 259   DCHECK(host_impl.CanDraw());
 260
 261   gfx::PointF arbitrary_point_f = gfx::PointF(0.125f, 0.25f);
 262   float arbitrary_number = 0.352f;
 263   gfx::Size arbitrary_size = gfx::Size(111, 222);
 264   gfx::Point arbitrary_point = gfx::Point(333, 444);
 265   gfx::Vector2d arbitrary_vector2d = gfx::Vector2d(111, 222);
 266   gfx::Size large_size = gfx::Size(1000, 1000);
 267   gfx::Rect arbitrary_rect = gfx::Rect(arbitrary_point, arbitrary_size);
 268   gfx::RectF arbitrary_rect_f =
 269       gfx::RectF(arbitrary_point_f, gfx::SizeF(1.234f, 5.678f));
 270   SkColor arbitrary_color = SkColorSetRGB(10, 20, 30);
 271   gfx::Transform arbitrary_transform;
 272   arbitrary_transform.Scale3d(0.1f, 0.2f, 0.3f);
 273   FilterOperations arbitrary_filters;
 274   arbitrary_filters.Append(FilterOperation::CreateOpacityFilter(0.5f));
 275   SkXfermode::Mode arbitrary_blend_mode = SkXfermode::kMultiply_Mode;
 276
 277   // Related filter functions.
 278   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetFilters(arbitrary_filters));
 279   VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetFilters(arbitrary_filters));
 280   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetFilters(FilterOperations()));
 281   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetFilters(arbitrary_filters));
 282
 283   // Related scrolling functions.
 284   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetBounds(large_size));
 285   VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetBounds(large_size));
 286   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->ScrollBy(arbitrary_vector2d));
 287   VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->ScrollBy(gfx::Vector2d()));
 288   layer->SetScrollDelta(gfx::Vector2d(0, 0));
 289   host_impl.ForcePrepareToDraw();
 290   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
 291       layer->SetScrollDelta(arbitrary_vector2d));
 292   VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
 293       layer->SetScrollDelta(arbitrary_vector2d));
 294   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
 295       layer->SetScrollOffset(gfx::ScrollOffset(arbitrary_vector2d)));
 296   VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
 297       layer->SetScrollOffset(gfx::ScrollOffset(arbitrary_vector2d)));
 298
 299   // Unrelated functions, always set to new values, always set needs update.
 300   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
 301       layer->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 4)));
 302   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetMasksToBounds(true));
 303   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetContentsOpaque(true));
 304   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
 305       layer->SetReplicaLayer(LayerImpl::Create(host_impl.active_tree(), 5)));
 306   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetPosition(arbitrary_point_f));
 307   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetShouldFlattenTransform(false));
 308   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->Set3dSortingContextId(1));
 309
 310   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
 311       layer->SetDoubleSided(false));  // constructor initializes it to "true".
 312   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetContentBounds(arbitrary_size));
 313   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
 314       layer->SetContentsScale(arbitrary_number, arbitrary_number));
 315   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetDrawsContent(true));
 316   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
 317       layer->SetBackgroundColor(arbitrary_color));
 318   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
 319       layer->SetBackgroundFilters(arbitrary_filters));
 320   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetOpacity(arbitrary_number));
 321   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
 322       layer->SetBlendMode(arbitrary_blend_mode));
 323   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetTransform(arbitrary_transform));
 324   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetBounds(arbitrary_size));
 325
 326   // Unrelated functions, set to the same values, no needs update.
 327   VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
 328       layer->SetIsRootForIsolatedGroup(true));
 329   VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetFilters(arbitrary_filters));
 330   VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetMasksToBounds(true));
 331   VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetContentsOpaque(true));
 332   VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetPosition(arbitrary_point_f));
 333   VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->Set3dSortingContextId(1));
 334   VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
 335       layer->SetDoubleSided(false));  // constructor initializes it to "true".
 336   VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
 337       layer->SetContentBounds(arbitrary_size));
 338   VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
 339       layer->SetContentsScale(arbitrary_number, arbitrary_number));
 340   VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetDrawsContent(true));
 341   VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
 342       layer->SetBackgroundColor(arbitrary_color));
 343   VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
 344       layer->SetBackgroundFilters(arbitrary_filters));
 345   VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetOpacity(arbitrary_number));
 346   VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
 347       layer->SetBlendMode(arbitrary_blend_mode));
 348   VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
 349       layer->SetIsRootForIsolatedGroup(true));
 350   VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
 351       layer->SetTransform(arbitrary_transform));
 352   VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetBounds(arbitrary_size));
 353 }
 354
 355 TEST(LayerImplTest, SafeOpaqueBackgroundColor) {
 356   FakeImplProxy proxy;
 357   TestSharedBitmapManager shared_bitmap_manager;
 358   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
 359   EXPECT_TRUE(host_impl.InitializeRenderer(FakeOutputSurface::Create3d()));
 360   scoped_ptr<LayerImpl> layer = LayerImpl::Create(host_impl.active_tree(), 1);
 361
 362   for (int contents_opaque = 0; contents_opaque < 2; ++contents_opaque) {
 363     for (int layer_opaque = 0; layer_opaque < 2; ++layer_opaque) {
 364       for (int host_opaque = 0; host_opaque < 2; ++host_opaque) {
 365         layer->SetContentsOpaque(!!contents_opaque);
 366         layer->SetBackgroundColor(layer_opaque ? SK_ColorRED
 367                                                : SK_ColorTRANSPARENT);
 368         host_impl.active_tree()->set_background_color(
 369             host_opaque ? SK_ColorRED : SK_ColorTRANSPARENT);
 370
 371         SkColor safe_color = layer->SafeOpaqueBackgroundColor();
 372         if (contents_opaque) {
 373           EXPECT_EQ(SkColorGetA(safe_color), 255u)
 374               << "Flags: " << contents_opaque << ", " << layer_opaque << ", "
 375               << host_opaque << "\n";
 376         } else {
 377           EXPECT_NE(SkColorGetA(safe_color), 255u)
 378               << "Flags: " << contents_opaque << ", " << layer_opaque << ", "
 379               << host_opaque << "\n";
 380         }
 381       }
 382     }
 383   }
 384 }
 385
 386 TEST(LayerImplTest, TransformInvertibility) {
 387   FakeImplProxy proxy;
 388   TestSharedBitmapManager shared_bitmap_manager;
 389   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
 390
 391   scoped_ptr<LayerImpl> layer = LayerImpl::Create(host_impl.active_tree(), 1);
 392   EXPECT_TRUE(layer->transform().IsInvertible());
 393   EXPECT_TRUE(layer->transform_is_invertible());
 394
 395   gfx::Transform transform;
 396   transform.Scale3d(
 397       SkDoubleToMScalar(1.0), SkDoubleToMScalar(1.0), SkDoubleToMScalar(0.0));
 398   layer->SetTransform(transform);
 399   EXPECT_FALSE(layer->transform().IsInvertible());
 400   EXPECT_FALSE(layer->transform_is_invertible());
 401
 402   transform.MakeIdentity();
 403   transform.ApplyPerspectiveDepth(SkDoubleToMScalar(100.0));
 404   transform.RotateAboutZAxis(75.0);
 405   transform.RotateAboutXAxis(32.2);
 406   transform.RotateAboutZAxis(-75.0);
 407   transform.Translate3d(SkDoubleToMScalar(50.5),
 408                         SkDoubleToMScalar(42.42),
 409                         SkDoubleToMScalar(-100.25));
 410
 411   layer->SetTransform(transform);
 412   EXPECT_TRUE(layer->transform().IsInvertible());
 413   EXPECT_TRUE(layer->transform_is_invertible());
 414 }
 415
 416 class LayerImplScrollTest : public testing::Test {
 417  public:
 418   LayerImplScrollTest()
 419       : host_impl_(settings(), &proxy_, &shared_bitmap_manager_), root_id_(7) {
 420     host_impl_.active_tree()->SetRootLayer(
 421         LayerImpl::Create(host_impl_.active_tree(), root_id_));
 422     host_impl_.active_tree()->root_layer()->AddChild(
 423         LayerImpl::Create(host_impl_.active_tree(), root_id_ + 1));
 424     layer()->SetScrollClipLayer(root_id_);
 425     // Set the max scroll offset by noting that the root layer has bounds (1,1),
 426     // thus whatever bounds are set for the layer will be the max scroll
 427     // offset plus 1 in each direction.
 428     host_impl_.active_tree()->root_layer()->SetBounds(gfx::Size(1, 1));
 429     gfx::Vector2d max_scroll_offset(51, 81);
 430     layer()->SetBounds(gfx::Size(max_scroll_offset.x(), max_scroll_offset.y()));
 431   }
 432
 433   LayerImpl* layer() {
 434     return host_impl_.active_tree()->root_layer()->children()[0];
 435   }
 436
 437   LayerTreeHostImpl& host_impl() { return host_impl_; }
 438
 439   LayerTreeImpl* tree() { return host_impl_.active_tree(); }
 440
 441   LayerTreeSettings settings() {
 442     LayerTreeSettings settings;
 443     settings.use_pinch_virtual_viewport = true;
 444     return settings;
 445   }
 446
 447  private:
 448   FakeImplProxy proxy_;
 449   TestSharedBitmapManager shared_bitmap_manager_;
 450   FakeLayerTreeHostImpl host_impl_;
 451   int root_id_;
 452 };
 453
 454 TEST_F(LayerImplScrollTest, ScrollByWithZeroOffset) {
 455   // Test that LayerImpl::ScrollBy only affects ScrollDelta and total scroll
 456   // offset is bounded by the range [0, max scroll offset].
 457
 458   EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->TotalScrollOffset());
 459   EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->scroll_offset());
 460   EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta());
 461
 462   layer()->ScrollBy(gfx::Vector2dF(-100, 100));
 463   EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 80), layer()->TotalScrollOffset());
 464
 465   EXPECT_VECTOR_EQ(layer()->ScrollDelta(), layer()->TotalScrollOffset());
 466   EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->scroll_offset());
 467
 468   layer()->ScrollBy(gfx::Vector2dF(100, -100));
 469   EXPECT_VECTOR_EQ(gfx::Vector2dF(50, 0), layer()->TotalScrollOffset());
 470
 471   EXPECT_VECTOR_EQ(layer()->ScrollDelta(), layer()->TotalScrollOffset());
 472   EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->scroll_offset());
 473 }
 474
 475 TEST_F(LayerImplScrollTest, ScrollByWithNonZeroOffset) {
 476   gfx::ScrollOffset scroll_offset(10, 5);
 477   layer()->SetScrollOffset(scroll_offset);
 478
 479   EXPECT_VECTOR_EQ(scroll_offset, layer()->TotalScrollOffset());
 480   EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset());
 481   EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta());
 482
 483   layer()->ScrollBy(gfx::Vector2dF(-100, 100));
 484   EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 80), layer()->TotalScrollOffset());
 485
 486   EXPECT_VECTOR_EQ(gfx::ScrollOffsetWithDelta(scroll_offset,
 487                                               layer()->ScrollDelta()),
 488                    layer()->TotalScrollOffset());
 489   EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset());
 490
 491   layer()->ScrollBy(gfx::Vector2dF(100, -100));
 492   EXPECT_VECTOR_EQ(gfx::Vector2dF(50, 0), layer()->TotalScrollOffset());
 493
 494   EXPECT_VECTOR_EQ(gfx::ScrollOffsetWithDelta(scroll_offset,
 495                                               layer()->ScrollDelta()),
 496                    layer()->TotalScrollOffset());
 497   EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset());
 498 }
 499
 500 class ScrollDelegateIgnore : public LayerImpl::ScrollOffsetDelegate {
 501  public:
 502   void SetTotalScrollOffset(const gfx::ScrollOffset& new_value) override {
 503     last_attempted_set_offset_ = new_value;
 504   }
 505   gfx::ScrollOffset last_attempted_set_offset() const {
 506     return last_attempted_set_offset_;
 507   }
 508
 509   gfx::ScrollOffset GetTotalScrollOffset() override {
 510     return gfx::ScrollOffset(fixed_offset_);
 511   }
 512   bool IsExternalFlingActive() const override { return false; }
 513   void Update() const override { }
 514
 515   void set_fixed_offset(const gfx::Vector2dF& fixed_offset) {
 516     fixed_offset_ = fixed_offset;
 517   }
 518
 519  private:
 520   gfx::ScrollOffset last_attempted_set_offset_;
 521   gfx::Vector2dF fixed_offset_;
 522 };
 523
 524 TEST_F(LayerImplScrollTest, ScrollByWithIgnoringDelegate) {
 525   gfx::ScrollOffset scroll_offset(10, 5);
 526   layer()->SetScrollOffset(scroll_offset);
 527
 528   EXPECT_VECTOR_EQ(scroll_offset, layer()->TotalScrollOffset());
 529   EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset());
 530   EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta());
 531
 532   ScrollDelegateIgnore delegate;
 533   gfx::Vector2dF fixed_offset(32, 12);
 534   delegate.set_fixed_offset(fixed_offset);
 535   layer()->SetScrollOffsetDelegate(&delegate);
 536
 537   EXPECT_VECTOR_EQ(fixed_offset, layer()->TotalScrollOffset());
 538   EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset());
 539
 540   layer()->ScrollBy(gfx::Vector2dF(-100, 100));
 541
 542   EXPECT_VECTOR_EQ(fixed_offset, layer()->TotalScrollOffset());
 543   EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset());
 544
 545   layer()->SetScrollOffsetDelegate(nullptr);
 546
 547   EXPECT_VECTOR_EQ(fixed_offset, layer()->TotalScrollOffset());
 548   EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset());
 549
 550   gfx::Vector2dF scroll_delta(1, 1);
 551   layer()->ScrollBy(scroll_delta);
 552
 553   EXPECT_VECTOR_EQ(fixed_offset + scroll_delta, layer()->TotalScrollOffset());
 554   EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset());
 555 }
 556
 557 class ScrollDelegateAccept : public LayerImpl::ScrollOffsetDelegate {
 558  public:
 559   void SetTotalScrollOffset(const gfx::ScrollOffset& new_value) override {
 560     current_offset_ = new_value;
 561   }
 562   gfx::ScrollOffset GetTotalScrollOffset() override { return current_offset_; }
 563   bool IsExternalFlingActive() const override { return false; }
 564   void Update() const override { }
 565
 566  private:
 567   gfx::ScrollOffset current_offset_;
 568 };
 569
 570 TEST_F(LayerImplScrollTest, ScrollByWithAcceptingDelegate) {
 571   gfx::ScrollOffset scroll_offset(10, 5);
 572   layer()->SetScrollOffset(scroll_offset);
 573
 574   EXPECT_VECTOR_EQ(scroll_offset, layer()->TotalScrollOffset());
 575   EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset());
 576   EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta());
 577
 578   ScrollDelegateAccept delegate;
 579   layer()->SetScrollOffsetDelegate(&delegate);
 580
 581   EXPECT_VECTOR_EQ(scroll_offset, layer()->TotalScrollOffset());
 582   EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset());
 583   EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->ScrollDelta());
 584
 585   layer()->ScrollBy(gfx::Vector2dF(-100, 100));
 586
 587   EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 80), layer()->TotalScrollOffset());
 588   EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset());
 589
 590   layer()->SetScrollOffsetDelegate(nullptr);
 591
 592   EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 80), layer()->TotalScrollOffset());
 593   EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset());
 594
 595   gfx::Vector2dF scroll_delta(1, 1);
 596   layer()->ScrollBy(scroll_delta);
 597
 598   EXPECT_VECTOR_EQ(gfx::Vector2dF(1, 80), layer()->TotalScrollOffset());
 599   EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset());
 600 }
 601
 602 TEST_F(LayerImplScrollTest, ApplySentScrollsNoDelegate) {
 603   gfx::ScrollOffset scroll_offset(10, 5);
 604   gfx::Vector2dF scroll_delta(20.5f, 8.5f);
 605   gfx::Vector2d sent_scroll_delta(12, -3);
 606
 607   layer()->SetScrollOffset(scroll_offset);
 608   layer()->ScrollBy(scroll_delta);
 609   layer()->SetSentScrollDelta(sent_scroll_delta);
 610
 611   EXPECT_VECTOR_EQ(gfx::ScrollOffsetWithDelta(scroll_offset, scroll_delta),
 612                    layer()->TotalScrollOffset());
 613   EXPECT_VECTOR_EQ(scroll_delta, layer()->ScrollDelta());
 614   EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset());
 615   EXPECT_VECTOR_EQ(sent_scroll_delta, layer()->sent_scroll_delta());
 616
 617   layer()->ApplySentScrollDeltasFromAbortedCommit();
 618
 619   EXPECT_VECTOR_EQ(gfx::ScrollOffsetWithDelta(scroll_offset, scroll_delta),
 620                    layer()->TotalScrollOffset());
 621   EXPECT_VECTOR_EQ(scroll_delta - sent_scroll_delta, layer()->ScrollDelta());
 622   EXPECT_VECTOR_EQ(gfx::ScrollOffsetWithDelta(scroll_offset, sent_scroll_delta),
 623                    layer()->scroll_offset());
 624   EXPECT_VECTOR_EQ(gfx::Vector2d(), layer()->sent_scroll_delta());
 625 }
 626
 627 TEST_F(LayerImplScrollTest, ApplySentScrollsWithIgnoringDelegate) {
 628   gfx::ScrollOffset scroll_offset(10, 5);
 629   gfx::Vector2d sent_scroll_delta(12, -3);
 630   gfx::Vector2dF fixed_offset(32, 12);
 631
 632   layer()->SetScrollOffset(scroll_offset);
 633   ScrollDelegateIgnore delegate;
 634   delegate.set_fixed_offset(fixed_offset);
 635   layer()->SetScrollOffsetDelegate(&delegate);
 636   layer()->SetSentScrollDelta(sent_scroll_delta);
 637
 638   EXPECT_VECTOR_EQ(fixed_offset, layer()->TotalScrollOffset());
 639   EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset());
 640   EXPECT_VECTOR_EQ(sent_scroll_delta, layer()->sent_scroll_delta());
 641
 642   layer()->ApplySentScrollDeltasFromAbortedCommit();
 643
 644   EXPECT_VECTOR_EQ(fixed_offset, delegate.last_attempted_set_offset());
 645
 646   EXPECT_VECTOR_EQ(fixed_offset, layer()->TotalScrollOffset());
 647   EXPECT_VECTOR_EQ(gfx::ScrollOffsetWithDelta(scroll_offset, sent_scroll_delta),
 648                    layer()->scroll_offset());
 649   EXPECT_VECTOR_EQ(gfx::Vector2d(), layer()->sent_scroll_delta());
 650 }
 651
 652 TEST_F(LayerImplScrollTest, ApplySentScrollsWithAcceptingDelegate) {
 653   gfx::ScrollOffset scroll_offset(10, 5);
 654   gfx::Vector2d sent_scroll_delta(12, -3);
 655   gfx::Vector2dF scroll_delta(20.5f, 8.5f);
 656
 657   layer()->SetScrollOffset(scroll_offset);
 658   ScrollDelegateAccept delegate;
 659   layer()->SetScrollOffsetDelegate(&delegate);
 660   layer()->ScrollBy(scroll_delta);
 661   layer()->SetSentScrollDelta(sent_scroll_delta);
 662
 663   EXPECT_VECTOR_EQ(gfx::ScrollOffsetWithDelta(scroll_offset, scroll_delta),
 664                    layer()->TotalScrollOffset());
 665   EXPECT_VECTOR_EQ(scroll_offset, layer()->scroll_offset());
 666   EXPECT_VECTOR_EQ(sent_scroll_delta, layer()->sent_scroll_delta());
 667
 668   layer()->ApplySentScrollDeltasFromAbortedCommit();
 669
 670   EXPECT_VECTOR_EQ(gfx::ScrollOffsetWithDelta(scroll_offset, scroll_delta),
 671                    layer()->TotalScrollOffset());
 672   EXPECT_VECTOR_EQ(gfx::ScrollOffsetWithDelta(scroll_offset, sent_scroll_delta),
 673                    layer()->scroll_offset());
 674   EXPECT_VECTOR_EQ(gfx::Vector2d(), layer()->sent_scroll_delta());
 675 }
 676
 677 TEST_F(LayerImplScrollTest, ScrollUserUnscrollableLayer) {
 678   gfx::ScrollOffset scroll_offset(10, 5);
 679   gfx::Vector2dF scroll_delta(20.5f, 8.5f);
 680
 681   layer()->set_user_scrollable_vertical(false);
 682   layer()->SetScrollOffset(scroll_offset);
 683   gfx::Vector2dF unscrolled = layer()->ScrollBy(scroll_delta);
 684
 685   EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 8.5f), unscrolled);
 686   EXPECT_VECTOR_EQ(gfx::Vector2dF(30.5f, 5), layer()->TotalScrollOffset());
 687 }
 688
 689 TEST_F(LayerImplScrollTest, PushPropertiesToMirrorsTotalScrollOffset) {
 690   gfx::ScrollOffset scroll_offset(10, 5);
 691   gfx::Vector2dF scroll_delta(12, 18);
 692
 693   host_impl().CreatePendingTree();
 694
 695   layer()->SetScrollOffset(scroll_offset);
 696   gfx::Vector2dF unscrolled = layer()->ScrollBy(scroll_delta);
 697
 698   EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 0), unscrolled);
 699   EXPECT_VECTOR_EQ(gfx::Vector2dF(22, 23), layer()->TotalScrollOffset());
 700
 701   layer()->SetSentScrollDelta(scroll_delta);
 702
 703   scoped_ptr<LayerImpl> pending_layer =
 704       LayerImpl::Create(host_impl().sync_tree(), layer()->id());
 705   pending_layer->SetScrollOffset(layer()->TotalScrollOffset());
 706
 707   pending_layer->PushPropertiesTo(layer());
 708
 709   EXPECT_VECTOR_EQ(gfx::Vector2dF(22, 23), layer()->TotalScrollOffset());
 710   EXPECT_VECTOR_EQ(layer()->TotalScrollOffset(),
 711                    pending_layer->TotalScrollOffset());
 712 }
 713
 714 TEST_F(LayerImplScrollTest, SetNewScrollbarParameters) {
 715   gfx::ScrollOffset scroll_offset(10, 5);
 716   layer()->SetScrollOffset(scroll_offset);
 717
 718   scoped_ptr<PaintedScrollbarLayerImpl> vertical_scrollbar(
 719       PaintedScrollbarLayerImpl::Create(tree(), 100, VERTICAL));
 720   vertical_scrollbar->SetScrollLayerAndClipLayerByIds(
 721       layer()->id(), tree()->root_layer()->id());
 722
 723   int expected_vertical_maximum =
 724       layer()->bounds().height() - tree()->root_layer()->bounds().height();
 725   EXPECT_EQ(expected_vertical_maximum, vertical_scrollbar->maximum());
 726   EXPECT_EQ(scroll_offset.y(), vertical_scrollbar->current_pos());
 727
 728   scoped_ptr<PaintedScrollbarLayerImpl> horizontal_scrollbar(
 729       PaintedScrollbarLayerImpl::Create(tree(), 101, HORIZONTAL));
 730   horizontal_scrollbar->SetScrollLayerAndClipLayerByIds(
 731       layer()->id(), tree()->root_layer()->id());
 732
 733   int expected_horizontal_maximum =
 734       layer()->bounds().width() - tree()->root_layer()->bounds().width();
 735   EXPECT_EQ(expected_horizontal_maximum, horizontal_scrollbar->maximum());
 736   EXPECT_EQ(scroll_offset.x(), horizontal_scrollbar->current_pos());
 737 }
 738
 739 }  // namespace
 740 }  // namespace cc