src/cc/trees/layer_tree_host_common.h

   1 // Copyright 2011 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_TREES_LAYER_TREE_HOST_COMMON_H_
   6 #define CC_TREES_LAYER_TREE_HOST_COMMON_H_
   7
   8 #include <limits>
   9 #include <vector>
  10
  11 #include "base/bind.h"
  12 #include "base/memory/ref_counted.h"
  13 #include "cc/base/cc_export.h"
  14 #include "cc/base/scoped_ptr_vector.h"
  15 #include "cc/layers/layer_lists.h"
  16 #include "ui/gfx/rect.h"
  17 #include "ui/gfx/transform.h"
  18 #include "ui/gfx/vector2d.h"
  19
  20 namespace cc {
  21
  22 class LayerImpl;
  23 class Layer;
  24 class SwapPromise;
  25
  26 class CC_EXPORT LayerTreeHostCommon {
  27  public:
  28   static gfx::Rect CalculateVisibleRect(const gfx::Rect& target_surface_rect,
  29                                         const gfx::Rect& layer_bound_rect,
  30                                         const gfx::Transform& transform);
  31
  32   template <typename LayerType, typename RenderSurfaceLayerListType>
  33   struct CalcDrawPropsInputs {
  34    public:
  35     CalcDrawPropsInputs(LayerType* root_layer,
  36                         const gfx::Size& device_viewport_size,
  37                         const gfx::Transform& device_transform,
  38                         float device_scale_factor,
  39                         float page_scale_factor,
  40                         const LayerType* page_scale_application_layer,
  41                         int max_texture_size,
  42                         bool can_use_lcd_text,
  43                         bool can_render_to_separate_surface,
  44                         bool can_adjust_raster_scales,
  45                         RenderSurfaceLayerListType* render_surface_layer_list,
  46                         int current_render_surface_layer_list_id)
  47         : root_layer(root_layer),
  48           device_viewport_size(device_viewport_size),
  49           device_transform(device_transform),
  50           device_scale_factor(device_scale_factor),
  51           page_scale_factor(page_scale_factor),
  52           page_scale_application_layer(page_scale_application_layer),
  53           max_texture_size(max_texture_size),
  54           can_use_lcd_text(can_use_lcd_text),
  55           can_render_to_separate_surface(can_render_to_separate_surface),
  56           can_adjust_raster_scales(can_adjust_raster_scales),
  57           render_surface_layer_list(render_surface_layer_list),
  58           current_render_surface_layer_list_id(
  59               current_render_surface_layer_list_id) {}
  60
  61     LayerType* root_layer;
  62     gfx::Size device_viewport_size;
  63     const gfx::Transform& device_transform;
  64     float device_scale_factor;
  65     float page_scale_factor;
  66     const LayerType* page_scale_application_layer;
  67     int max_texture_size;
  68     bool can_use_lcd_text;
  69     bool can_render_to_separate_surface;
  70     bool can_adjust_raster_scales;
  71     RenderSurfaceLayerListType* render_surface_layer_list;
  72     int current_render_surface_layer_list_id;
  73   };
  74
  75   template <typename LayerType, typename RenderSurfaceLayerListType>
  76   struct CalcDrawPropsInputsForTesting
  77       : public CalcDrawPropsInputs<LayerType, RenderSurfaceLayerListType> {
  78     CalcDrawPropsInputsForTesting(
  79         LayerType* root_layer,
  80         const gfx::Size& device_viewport_size,
  81         const gfx::Transform& device_transform,
  82         RenderSurfaceLayerListType* render_surface_layer_list);
  83     CalcDrawPropsInputsForTesting(
  84         LayerType* root_layer,
  85         const gfx::Size& device_viewport_size,
  86         RenderSurfaceLayerListType* render_surface_layer_list);
  87
  88    private:
  89     const gfx::Transform identity_transform_;
  90   };
  91
  92   typedef CalcDrawPropsInputs<Layer, RenderSurfaceLayerList>
  93       CalcDrawPropsMainInputs;
  94   typedef CalcDrawPropsInputsForTesting<Layer, RenderSurfaceLayerList>
  95       CalcDrawPropsMainInputsForTesting;
  96   static void CalculateDrawProperties(CalcDrawPropsMainInputs* inputs);
  97
  98   typedef CalcDrawPropsInputs<LayerImpl, LayerImplList> CalcDrawPropsImplInputs;
  99   typedef CalcDrawPropsInputsForTesting<LayerImpl, LayerImplList>
 100       CalcDrawPropsImplInputsForTesting;
 101   static void CalculateDrawProperties(CalcDrawPropsImplInputs* inputs);
 102
 103   template <typename LayerType>
 104   static bool RenderSurfaceContributesToTarget(LayerType*,
 105                                                int target_surface_layer_id);
 106
 107   template <typename LayerType>
 108   static void CallFunctionForSubtree(
 109       LayerType* root_layer,
 110       const base::Callback<void(LayerType* layer)>& function);
 111
 112   // Returns a layer with the given id if one exists in the subtree starting
 113   // from the given root layer (including mask and replica layers).
 114   template <typename LayerType>
 115   static LayerType* FindLayerInSubtree(LayerType* root_layer, int layer_id);
 116
 117   static Layer* get_layer_as_raw_ptr(const LayerList& layers, size_t index) {
 118     return layers[index].get();
 119   }
 120
 121   static LayerImpl* get_layer_as_raw_ptr(const OwnedLayerImplList& layers,
 122                                          size_t index) {
 123     return layers[index];
 124   }
 125
 126   static LayerImpl* get_layer_as_raw_ptr(const LayerImplList& layers,
 127                                          size_t index) {
 128     return layers[index];
 129   }
 130
 131   struct ScrollUpdateInfo {
 132     int layer_id;
 133     gfx::Vector2d scroll_delta;
 134   };
 135 };
 136
 137 struct CC_EXPORT ScrollAndScaleSet {
 138   ScrollAndScaleSet();
 139   ~ScrollAndScaleSet();
 140
 141   std::vector<LayerTreeHostCommon::ScrollUpdateInfo> scrolls;
 142   float page_scale_delta;
 143   float top_controls_delta;
 144   ScopedPtrVector<SwapPromise> swap_promises;
 145 };
 146
 147 template <typename LayerType>
 148 bool LayerTreeHostCommon::RenderSurfaceContributesToTarget(
 149     LayerType* layer,
 150     int target_surface_layer_id) {
 151   // A layer will either contribute its own content, or its render surface's
 152   // content, to the target surface. The layer contributes its surface's content
 153   // when both the following are true:
 154   //  (1) The layer actually has a render surface, and
 155   //  (2) The layer's render surface is not the same as the target surface.
 156   //
 157   // Otherwise, the layer just contributes itself to the target surface.
 158
 159   return layer->render_surface() && layer->id() != target_surface_layer_id;
 160 }
 161
 162 template <typename LayerType>
 163 LayerType* LayerTreeHostCommon::FindLayerInSubtree(LayerType* root_layer,
 164                                                    int layer_id) {
 165   if (!root_layer)
 166     return NULL;
 167
 168   if (root_layer->id() == layer_id)
 169     return root_layer;
 170
 171   if (root_layer->mask_layer() && root_layer->mask_layer()->id() == layer_id)
 172     return root_layer->mask_layer();
 173
 174   if (root_layer->replica_layer() &&
 175       root_layer->replica_layer()->id() == layer_id)
 176     return root_layer->replica_layer();
 177
 178   for (size_t i = 0; i < root_layer->children().size(); ++i) {
 179     if (LayerType* found = FindLayerInSubtree(
 180             get_layer_as_raw_ptr(root_layer->children(), i), layer_id))
 181       return found;
 182   }
 183   return NULL;
 184 }
 185
 186 template <typename LayerType>
 187 void LayerTreeHostCommon::CallFunctionForSubtree(
 188     LayerType* root_layer,
 189     const base::Callback<void(LayerType* layer)>& function) {
 190   function.Run(root_layer);
 191
 192   if (LayerType* mask_layer = root_layer->mask_layer())
 193     function.Run(mask_layer);
 194   if (LayerType* replica_layer = root_layer->replica_layer()) {
 195     function.Run(replica_layer);
 196     if (LayerType* mask_layer = replica_layer->mask_layer())
 197       function.Run(mask_layer);
 198   }
 199
 200   for (size_t i = 0; i < root_layer->children().size(); ++i) {
 201     CallFunctionForSubtree(get_layer_as_raw_ptr(root_layer->children(), i),
 202                            function);
 203   }
 204 }
 205
 206 template <typename LayerType, typename RenderSurfaceLayerListType>
 207 LayerTreeHostCommon::CalcDrawPropsInputsForTesting<LayerType,
 208                                                    RenderSurfaceLayerListType>::
 209     CalcDrawPropsInputsForTesting(
 210         LayerType* root_layer,
 211         const gfx::Size& device_viewport_size,
 212         const gfx::Transform& device_transform,
 213         RenderSurfaceLayerListType* render_surface_layer_list)
 214     : CalcDrawPropsInputs<LayerType, RenderSurfaceLayerListType>(
 215           root_layer,
 216           device_viewport_size,
 217           device_transform,
 218           1.f,
 219           1.f,
 220           NULL,
 221           std::numeric_limits<int>::max() / 2,
 222           false,
 223           true,
 224           false,
 225           render_surface_layer_list,
 226           0) {
 227   DCHECK(root_layer);
 228   DCHECK(render_surface_layer_list);
 229 }
 230
 231 template <typename LayerType, typename RenderSurfaceLayerListType>
 232 LayerTreeHostCommon::CalcDrawPropsInputsForTesting<LayerType,
 233                                                    RenderSurfaceLayerListType>::
 234     CalcDrawPropsInputsForTesting(
 235         LayerType* root_layer,
 236         const gfx::Size& device_viewport_size,
 237         RenderSurfaceLayerListType* render_surface_layer_list)
 238     : CalcDrawPropsInputs<LayerType, RenderSurfaceLayerListType>(
 239           root_layer,
 240           device_viewport_size,
 241           identity_transform_,
 242           1.f,
 243           1.f,
 244           NULL,
 245           std::numeric_limits<int>::max() / 2,
 246           false,
 247           true,
 248           false,
 249           render_surface_layer_list,
 250           0) {
 251   DCHECK(root_layer);
 252   DCHECK(render_surface_layer_list);
 253 }
 254
 255 }  // namespace cc
 256
 257 #endif  // CC_TREES_LAYER_TREE_HOST_COMMON_H_