webkit/renderer/compositor_bindings/web_layer_impl_fixed_bounds_unittest.cc

   1 // Copyright 2013 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 <vector>
   6 #include "cc/layers/picture_image_layer.h"
   7 #include "cc/test/fake_layer_tree_host.h"
   8 #include "cc/test/geometry_test_utils.h"
   9 #include "cc/trees/layer_tree_host_common.h"
  10 #include "testing/gtest/include/gtest/gtest.h"
  11 #include "third_party/WebKit/public/platform/WebFloatPoint.h"
  12 #include "third_party/WebKit/public/platform/WebSize.h"
  13 #include "third_party/skia/include/utils/SkMatrix44.h"
  14 #include "ui/gfx/point3_f.h"
  15 #include "webkit/renderer/compositor_bindings/web_layer_impl_fixed_bounds.h"
  16
  17 using blink::WebFloatPoint;
  18 using blink::WebSize;
  19
  20 namespace webkit {
  21 namespace {
  22
  23 TEST(WebLayerImplFixedBoundsTest, IdentityBounds) {
  24   scoped_ptr<WebLayerImplFixedBounds> layer(new WebLayerImplFixedBounds());
  25   layer->setAnchorPoint(WebFloatPoint(0, 0));
  26   layer->SetFixedBounds(gfx::Size(100, 100));
  27   layer->setBounds(WebSize(100, 100));
  28   EXPECT_EQ(WebSize(100, 100), layer->bounds());
  29   EXPECT_EQ(gfx::Size(100, 100), layer->layer()->bounds());
  30   EXPECT_EQ(gfx::Transform(), layer->layer()->transform());
  31 }
  32
  33 gfx::Point3F TransformPoint(const gfx::Transform& transform,
  34                             const gfx::Point3F& point) {
  35   gfx::Point3F result = point;
  36   transform.TransformPoint(&result);
  37   return result;
  38 }
  39
  40 void CheckBoundsScaleSimple(WebLayerImplFixedBounds* layer,
  41                             const WebSize& bounds,
  42                             const gfx::Size& fixed_bounds) {
  43   layer->setBounds(bounds);
  44   layer->SetFixedBounds(fixed_bounds);
  45
  46   EXPECT_EQ(bounds, layer->bounds());
  47   EXPECT_EQ(fixed_bounds, layer->layer()->bounds());
  48   EXPECT_TRUE(layer->transform().isIdentity());
  49   EXPECT_TRUE(layer->sublayerTransform().isIdentity());
  50
  51   // An arbitrary point to check the scale and transforms.
  52   gfx::Point3F original_point(10, 20, 1);
  53   gfx::Point3F scaled_point(
  54       original_point.x() * bounds.width / fixed_bounds.width(),
  55       original_point.y() * bounds.height / fixed_bounds.height(),
  56       original_point.z());
  57   // Test if the bounds scale is correctly applied in transform and
  58   // sublayerTransform.
  59   EXPECT_POINT3F_EQ(scaled_point,
  60                     TransformPoint(layer->layer()->transform(),
  61                                    original_point));
  62   EXPECT_POINT3F_EQ(original_point,
  63                     TransformPoint(layer->layer()->sublayer_transform(),
  64                                    scaled_point));
  65 }
  66
  67 TEST(WebLayerImplFixedBoundsTest, BoundsScaleSimple) {
  68   scoped_ptr<WebLayerImplFixedBounds> layer(new WebLayerImplFixedBounds());
  69   layer->setAnchorPoint(WebFloatPoint(0, 0));
  70   CheckBoundsScaleSimple(layer.get(), WebSize(100, 200), gfx::Size(150, 250));
  71   // Change fixed_bounds.
  72   CheckBoundsScaleSimple(layer.get(), WebSize(100, 200), gfx::Size(75, 100));
  73   // Change bounds.
  74   CheckBoundsScaleSimple(layer.get(), WebSize(300, 100), gfx::Size(75, 100));
  75 }
  76
  77 void ExpectEqualLayerRectsInTarget(cc::Layer* layer1, cc::Layer* layer2) {
  78   gfx::RectF layer1_rect_in_target(layer1->content_bounds());
  79   layer1->draw_transform().TransformRect(&layer1_rect_in_target);
  80
  81   gfx::RectF layer2_rect_in_target(layer2->content_bounds());
  82   layer2->draw_transform().TransformRect(&layer2_rect_in_target);
  83
  84   EXPECT_FLOAT_RECT_EQ(layer1_rect_in_target, layer2_rect_in_target);
  85 }
  86
  87 void CompareFixedBoundsLayerAndNormalLayer(
  88     const WebFloatPoint& anchor_point,
  89     const gfx::Transform& transform,
  90     const gfx::Transform& sublayer_transform) {
  91   const gfx::Size kDeviceViewportSize(800, 600);
  92   const float kDeviceScaleFactor = 2.f;
  93   const float kPageScaleFactor = 1.5f;
  94
  95   WebSize bounds(150, 200);
  96   WebFloatPoint position(20, 30);
  97   WebSize sublayer_bounds(88, 99);
  98   WebFloatPoint sublayer_position(50, 60);
  99   gfx::Size fixed_bounds(160, 70);
 100
 101   scoped_ptr<WebLayerImplFixedBounds> root_layer(new WebLayerImplFixedBounds());
 102
 103   WebLayerImplFixedBounds* fixed_bounds_layer =
 104       new WebLayerImplFixedBounds(cc::PictureImageLayer::Create());
 105   WebLayerImpl* sublayer_under_fixed_bounds_layer = new WebLayerImpl();
 106   sublayer_under_fixed_bounds_layer->setBounds(sublayer_bounds);
 107   sublayer_under_fixed_bounds_layer->setPosition(sublayer_position);
 108   fixed_bounds_layer->addChild(sublayer_under_fixed_bounds_layer);
 109   fixed_bounds_layer->setBounds(bounds);
 110   fixed_bounds_layer->SetFixedBounds(fixed_bounds);
 111   fixed_bounds_layer->setAnchorPoint(anchor_point);
 112   fixed_bounds_layer->setTransform(transform.matrix());
 113   fixed_bounds_layer->setSublayerTransform(sublayer_transform.matrix());
 114   fixed_bounds_layer->setPosition(position);
 115   root_layer->addChild(fixed_bounds_layer);
 116
 117   WebLayerImpl* normal_layer(new WebLayerImpl(cc::PictureImageLayer::Create()));
 118   WebLayerImpl* sublayer_under_normal_layer = new WebLayerImpl();
 119   sublayer_under_normal_layer->setBounds(sublayer_bounds);
 120   sublayer_under_normal_layer->setPosition(sublayer_position);
 121
 122   normal_layer->addChild(sublayer_under_normal_layer);
 123   normal_layer->setBounds(bounds);
 124   normal_layer->setAnchorPoint(anchor_point);
 125   normal_layer->setTransform(transform.matrix());
 126   normal_layer->setSublayerTransform(sublayer_transform.matrix());
 127   normal_layer->setPosition(position);
 128   root_layer->addChild(normal_layer);
 129
 130   scoped_ptr<cc::FakeLayerTreeHost> host = cc::FakeLayerTreeHost::Create();
 131   host->SetRootLayer(root_layer->layer());
 132
 133   {
 134     cc::RenderSurfaceLayerList render_surface_layer_list;
 135     cc::LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
 136         root_layer->layer(), kDeviceViewportSize, &render_surface_layer_list);
 137     inputs.device_scale_factor = kDeviceScaleFactor;
 138     inputs.page_scale_factor = kPageScaleFactor;
 139     inputs.page_scale_application_layer = root_layer->layer(),
 140     cc::LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 141
 142     ExpectEqualLayerRectsInTarget(normal_layer->layer(),
 143                                   fixed_bounds_layer->layer());
 144     ExpectEqualLayerRectsInTarget(sublayer_under_normal_layer->layer(),
 145                                   sublayer_under_fixed_bounds_layer->layer());
 146   }
 147
 148   // Change of fixed bounds should not affect the target geometries.
 149   fixed_bounds_layer->SetFixedBounds(gfx::Size(fixed_bounds.width() / 2,
 150                                                fixed_bounds.height() * 2));
 151
 152   {
 153     cc::RenderSurfaceLayerList render_surface_layer_list;
 154     cc::LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
 155         root_layer->layer(), kDeviceViewportSize, &render_surface_layer_list);
 156     inputs.device_scale_factor = kDeviceScaleFactor;
 157     inputs.page_scale_factor = kPageScaleFactor;
 158     inputs.page_scale_application_layer = root_layer->layer(),
 159     cc::LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 160
 161     ExpectEqualLayerRectsInTarget(normal_layer->layer(),
 162                                   fixed_bounds_layer->layer());
 163     ExpectEqualLayerRectsInTarget(sublayer_under_normal_layer->layer(),
 164                                   sublayer_under_fixed_bounds_layer->layer());
 165   }
 166 }
 167
 168 // A black box test that ensures WebLayerImplFixedBounds won't change target
 169 // geometries. Simple case: identity transforms and zero anchor point.
 170 TEST(WebLayerImplFixedBoundsTest, CompareToWebLayerImplSimple) {
 171   CompareFixedBoundsLayerAndNormalLayer(WebFloatPoint(0, 0),
 172                                         gfx::Transform(),
 173                                         gfx::Transform());
 174 }
 175
 176 // A black box test that ensures WebLayerImplFixedBounds won't change target
 177 // geometries. Complex case: complex transforms and non-zero anchor point.
 178 TEST(WebLayerImplFixedBoundsTest, CompareToWebLayerImplComplex) {
 179   gfx::Transform transform;
 180   // These are arbitrary values that should not affect the results.
 181   transform.Translate3d(50, 60, 70);
 182   transform.Scale3d(2, 3, 4);
 183   transform.RotateAbout(gfx::Vector3dF(33, 44, 55), 99);
 184
 185   gfx::Transform sublayer_transform;
 186   // These are arbitrary values that should not affect the results.
 187   sublayer_transform.Scale3d(1.1f, 2.2f, 3.3f);
 188   sublayer_transform.Translate3d(11, 22, 33);
 189   sublayer_transform.RotateAbout(gfx::Vector3dF(10, 30, 20), 88);
 190
 191   CompareFixedBoundsLayerAndNormalLayer(WebFloatPoint(0, 0),
 192                                         transform,
 193                                         sublayer_transform);
 194
 195   // With non-zero anchor point, WebLayerImplFixedBounds will fall back to
 196   // WebLayerImpl.
 197   CompareFixedBoundsLayerAndNormalLayer(WebFloatPoint(0.4f, 0.6f),
 198                                         transform,
 199                                         sublayer_transform);
 200 }
 201
 202 }  // namespace
 203 }  // namespace webkit