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
17using blink::WebFloatPoint;
18using blink::WebSize;
19
20namespace webkit {
21namespace {
22
23TEST(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
33gfx::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
40void 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
67TEST(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
77void 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
87void 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.
170TEST(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.
178TEST(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
204