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