src/cc/test/layer_tree_host_common_test.h

   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 #ifndef CC_TEST_LAYER_TREE_HOST_COMMON_TEST_H_
   6 #define CC_TEST_LAYER_TREE_HOST_COMMON_TEST_H_
   7
   8 #include <vector>
   9
  10 #include "base/memory/scoped_ptr.h"
  11 #include "cc/layers/layer_lists.h"
  12 #include "cc/test/fake_layer_tree_host_client.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 namespace gfx {
  16 class PointF;
  17 class Point3F;
  18 class Size;
  19 class Transform;
  20 }
  21
  22 namespace cc {
  23
  24 class FakeLayerTreeHost;
  25 class Layer;
  26 class LayerImpl;
  27 class RenderSurfaceLayerList;
  28
  29 class LayerTreeHostCommonTestBase {
  30  protected:
  31   LayerTreeHostCommonTestBase();
  32   virtual ~LayerTreeHostCommonTestBase();
  33
  34   template <typename LayerType>
  35   void SetLayerPropertiesForTestingInternal(
  36       LayerType* layer,
  37       const gfx::Transform& transform,
  38       const gfx::Point3F& transform_origin,
  39       const gfx::PointF& position,
  40       const gfx::Size& bounds,
  41       bool flatten_transform,
  42       bool is_3d_sorted) {
  43     layer->SetTransform(transform);
  44     layer->SetTransformOrigin(transform_origin);
  45     layer->SetPosition(position);
  46     layer->SetBounds(bounds);
  47     layer->SetShouldFlattenTransform(flatten_transform);
  48     layer->Set3dSortingContextId(is_3d_sorted ? 1 : 0);
  49   }
  50
  51   void SetLayerPropertiesForTesting(Layer* layer,
  52                                     const gfx::Transform& transform,
  53                                     const gfx::Point3F& transform_origin,
  54                                     const gfx::PointF& position,
  55                                     const gfx::Size& bounds,
  56                                     bool flatten_transform,
  57                                     bool is_3d_sorted);
  58
  59   void SetLayerPropertiesForTesting(LayerImpl* layer,
  60                                     const gfx::Transform& transform,
  61                                     const gfx::Point3F& transform_origin,
  62                                     const gfx::PointF& position,
  63                                     const gfx::Size& bounds,
  64                                     bool flatten_transform,
  65                                     bool is_3d_sorted);
  66
  67   void ExecuteCalculateDrawProperties(Layer* root_layer,
  68                                       float device_scale_factor,
  69                                       float page_scale_factor,
  70                                       Layer* page_scale_application_layer,
  71                                       bool can_use_lcd_text);
  72
  73   void ExecuteCalculateDrawProperties(LayerImpl* root_layer,
  74                                       float device_scale_factor,
  75                                       float page_scale_factor,
  76                                       LayerImpl* page_scale_application_layer,
  77                                       bool can_use_lcd_text);
  78
  79   template <class LayerType>
  80   void ExecuteCalculateDrawProperties(LayerType* root_layer) {
  81     LayerType* page_scale_application_layer = NULL;
  82     ExecuteCalculateDrawProperties(
  83         root_layer, 1.f, 1.f, page_scale_application_layer, false);
  84   }
  85
  86   template <class LayerType>
  87   void ExecuteCalculateDrawProperties(LayerType* root_layer,
  88                                       float device_scale_factor) {
  89     LayerType* page_scale_application_layer = NULL;
  90     ExecuteCalculateDrawProperties(root_layer,
  91                                    device_scale_factor,
  92                                    1.f,
  93                                    page_scale_application_layer,
  94                                    false);
  95   }
  96
  97   template <class LayerType>
  98   void ExecuteCalculateDrawProperties(LayerType* root_layer,
  99                                       float device_scale_factor,
 100                                       float page_scale_factor,
 101                                       LayerType* page_scale_application_layer) {
 102     ExecuteCalculateDrawProperties(root_layer,
 103                                    device_scale_factor,
 104                                    page_scale_factor,
 105                                    page_scale_application_layer,
 106                                    false);
 107   }
 108
 109   RenderSurfaceLayerList* render_surface_layer_list() const {
 110     return render_surface_layer_list_.get();
 111   }
 112
 113   LayerImplList* render_surface_layer_list_impl() const {
 114     return render_surface_layer_list_impl_.get();
 115   }
 116
 117   int render_surface_layer_list_count() const {
 118     return render_surface_layer_list_count_;
 119   }
 120
 121   scoped_ptr<FakeLayerTreeHost> CreateFakeLayerTreeHost();
 122
 123  private:
 124   scoped_ptr<RenderSurfaceLayerList> render_surface_layer_list_;
 125   scoped_ptr<std::vector<LayerImpl*>> render_surface_layer_list_impl_;
 126
 127   FakeLayerTreeHostClient client_;
 128   int render_surface_layer_list_count_;
 129 };
 130
 131 class LayerTreeHostCommonTest : public LayerTreeHostCommonTestBase,
 132                                 public testing::Test {};
 133
 134 }  // namespace cc
 135
 136 #endif  // CC_TEST_LAYER_TREE_HOST_COMMON_TEST_H_