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                                       bool layers_always_allowed_lcd_text);
  73
  74   void ExecuteCalculateDrawProperties(LayerImpl* root_layer,
  75                                       float device_scale_factor,
  76                                       float page_scale_factor,
  77                                       LayerImpl* page_scale_application_layer,
  78                                       bool can_use_lcd_text,
  79                                       bool layers_always_allowed_lcd_text);
  80
  81   template <class LayerType>
  82   void ExecuteCalculateDrawProperties(LayerType* root_layer) {
  83     LayerType* page_scale_application_layer = NULL;
  84     ExecuteCalculateDrawProperties(root_layer, 1.f, 1.f,
  85                                    page_scale_application_layer, false, false);
  86   }
  87
  88   template <class LayerType>
  89   void ExecuteCalculateDrawProperties(LayerType* root_layer,
  90                                       float device_scale_factor) {
  91     LayerType* page_scale_application_layer = NULL;
  92     ExecuteCalculateDrawProperties(root_layer, device_scale_factor, 1.f,
  93                                    page_scale_application_layer, false, false);
  94   }
  95
  96   template <class LayerType>
  97   void ExecuteCalculateDrawProperties(LayerType* root_layer,
  98                                       float device_scale_factor,
  99                                       float page_scale_factor,
 100                                       LayerType* page_scale_application_layer) {
 101     ExecuteCalculateDrawProperties(root_layer, device_scale_factor,
 102                                    page_scale_factor,
 103                                    page_scale_application_layer, false, false);
 104   }
 105
 106   RenderSurfaceLayerList* render_surface_layer_list() const {
 107     return render_surface_layer_list_.get();
 108   }
 109
 110   LayerImplList* render_surface_layer_list_impl() const {
 111     return render_surface_layer_list_impl_.get();
 112   }
 113
 114   int render_surface_layer_list_count() const {
 115     return render_surface_layer_list_count_;
 116   }
 117
 118   scoped_ptr<FakeLayerTreeHost> CreateFakeLayerTreeHost();
 119
 120  private:
 121   scoped_ptr<RenderSurfaceLayerList> render_surface_layer_list_;
 122   scoped_ptr<std::vector<LayerImpl*>> render_surface_layer_list_impl_;
 123
 124   FakeLayerTreeHostClient client_;
 125   int render_surface_layer_list_count_;
 126 };
 127
 128 class LayerTreeHostCommonTest : public LayerTreeHostCommonTestBase,
 129                                 public testing::Test {};
 130
 131 }  // namespace cc
 132
 133 #endif  // CC_TEST_LAYER_TREE_HOST_COMMON_TEST_H_