cc/blink/web_layer_impl_fixed_bounds_unittest.cc

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