Home | History | Annotate | Download | only in compositor_bindings 
      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 WebKit::WebFloatPoint;
     18 using WebKit::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.1, 2.2, 3.3);
    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