cc/debug/debug_rect_history.cc

   1 // Copyright 2012 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 "cc/debug/debug_rect_history.h"
   6
   7 #include "cc/base/math_util.h"
   8 #include "cc/layers/layer_impl.h"
   9 #include "cc/layers/render_surface_impl.h"
  10 #include "cc/trees/damage_tracker.h"
  11 #include "cc/trees/layer_tree_host.h"
  12 #include "cc/trees/layer_tree_host_common.h"
  13
  14 namespace cc {
  15
  16 // static
  17 scoped_ptr<DebugRectHistory> DebugRectHistory::Create() {
  18   return make_scoped_ptr(new DebugRectHistory());
  19 }
  20
  21 DebugRectHistory::DebugRectHistory() {}
  22
  23 DebugRectHistory::~DebugRectHistory() {}
  24
  25 void DebugRectHistory::SaveDebugRectsForCurrentFrame(
  26     LayerImpl* root_layer,
  27     const LayerImplList& render_surface_layer_list,
  28     const std::vector<gfx::Rect>& occluding_screen_space_rects,
  29     const std::vector<gfx::Rect>& non_occluding_screen_space_rects,
  30     const LayerTreeDebugState& debug_state) {
  31   // For now, clear all rects from previous frames. In the future we may want to
  32   // store all debug rects for a history of many frames.
  33   debug_rects_.clear();
  34
  35   if (debug_state.show_touch_event_handler_rects)
  36     SaveTouchEventHandlerRects(root_layer);
  37
  38   if (debug_state.show_wheel_event_handler_rects)
  39     SaveWheelEventHandlerRects(root_layer);
  40
  41   if (debug_state.show_non_fast_scrollable_rects)
  42     SaveNonFastScrollableRects(root_layer);
  43
  44   if (debug_state.show_paint_rects)
  45     SavePaintRects(root_layer);
  46
  47   if (debug_state.show_property_changed_rects)
  48     SavePropertyChangedRects(render_surface_layer_list);
  49
  50   if (debug_state.show_surface_damage_rects)
  51     SaveSurfaceDamageRects(render_surface_layer_list);
  52
  53   if (debug_state.show_screen_space_rects)
  54     SaveScreenSpaceRects(render_surface_layer_list);
  55
  56   if (debug_state.show_occluding_rects)
  57     SaveOccludingRects(occluding_screen_space_rects);
  58
  59   if (debug_state.show_non_occluding_rects)
  60     SaveNonOccludingRects(non_occluding_screen_space_rects);
  61 }
  62
  63 void DebugRectHistory::SavePaintRects(LayerImpl* layer) {
  64   // We would like to visualize where any layer's paint rect (update rect) has
  65   // changed, regardless of whether this layer is skipped for actual drawing or
  66   // not. Therefore we traverse recursively over all layers, not just the render
  67   // surface list.
  68
  69   if (!layer->update_rect().IsEmpty() && layer->DrawsContent()) {
  70     float width_scale = layer->content_bounds().width() /
  71                         static_cast<float>(layer->bounds().width());
  72     float height_scale = layer->content_bounds().height() /
  73                          static_cast<float>(layer->bounds().height());
  74     gfx::RectF update_content_rect =
  75         gfx::ScaleRect(layer->update_rect(), width_scale, height_scale);
  76     debug_rects_.push_back(
  77         DebugRect(PAINT_RECT_TYPE,
  78                   MathUtil::MapClippedRect(layer->screen_space_transform(),
  79                                            update_content_rect)));
  80   }
  81
  82   for (unsigned i = 0; i < layer->children().size(); ++i)
  83     SavePaintRects(layer->children()[i]);
  84 }
  85
  86 void DebugRectHistory::SavePropertyChangedRects(
  87     const LayerImplList& render_surface_layer_list) {
  88   for (int surface_index = render_surface_layer_list.size() - 1;
  89        surface_index >= 0;
  90        --surface_index) {
  91     LayerImpl* render_surface_layer = render_surface_layer_list[surface_index];
  92     RenderSurfaceImpl* render_surface = render_surface_layer->render_surface();
  93     DCHECK(render_surface);
  94
  95     const LayerImplList& layer_list = render_surface->layer_list();
  96     for (unsigned layer_index = 0;
  97          layer_index < layer_list.size();
  98          ++layer_index) {
  99       LayerImpl* layer = layer_list[layer_index];
 100
 101       if (LayerTreeHostCommon::RenderSurfaceContributesToTarget<LayerImpl>(
 102               layer, render_surface_layer->id()))
 103         continue;
 104
 105       if (layer->LayerIsAlwaysDamaged())
 106         continue;
 107
 108       if (layer->LayerPropertyChanged() ||
 109           layer->LayerSurfacePropertyChanged()) {
 110         debug_rects_.push_back(
 111             DebugRect(PROPERTY_CHANGED_RECT_TYPE,
 112                       MathUtil::MapClippedRect(
 113                           layer->screen_space_transform(),
 114                           gfx::RectF(gfx::PointF(), layer->content_bounds()))));
 115       }
 116     }
 117   }
 118 }
 119
 120 void DebugRectHistory::SaveSurfaceDamageRects(
 121     const LayerImplList& render_surface_layer_list) {
 122   for (int surface_index = render_surface_layer_list.size() - 1;
 123        surface_index >= 0;
 124        --surface_index) {
 125     LayerImpl* render_surface_layer = render_surface_layer_list[surface_index];
 126     RenderSurfaceImpl* render_surface = render_surface_layer->render_surface();
 127     DCHECK(render_surface);
 128
 129     debug_rects_.push_back(DebugRect(
 130         SURFACE_DAMAGE_RECT_TYPE,
 131         MathUtil::MapClippedRect(
 132             render_surface->screen_space_transform(),
 133             render_surface->damage_tracker()->current_damage_rect())));
 134   }
 135 }
 136
 137 void DebugRectHistory::SaveScreenSpaceRects(
 138     const LayerImplList& render_surface_layer_list) {
 139   for (int surface_index = render_surface_layer_list.size() - 1;
 140        surface_index >= 0;
 141        --surface_index) {
 142     LayerImpl* render_surface_layer = render_surface_layer_list[surface_index];
 143     RenderSurfaceImpl* render_surface = render_surface_layer->render_surface();
 144     DCHECK(render_surface);
 145
 146     debug_rects_.push_back(DebugRect(
 147         SCREEN_SPACE_RECT_TYPE,
 148         MathUtil::MapClippedRect(render_surface->screen_space_transform(),
 149                                  render_surface->content_rect())));
 150
 151     if (render_surface_layer->replica_layer()) {
 152       debug_rects_.push_back(
 153           DebugRect(REPLICA_SCREEN_SPACE_RECT_TYPE,
 154                     MathUtil::MapClippedRect(
 155                         render_surface->replica_screen_space_transform(),
 156                         render_surface->content_rect())));
 157     }
 158   }
 159 }
 160
 161 void DebugRectHistory::SaveOccludingRects(
 162     const std::vector<gfx::Rect>& occluding_rects) {
 163   for (size_t i = 0; i < occluding_rects.size(); ++i)
 164     debug_rects_.push_back(DebugRect(OCCLUDING_RECT_TYPE, occluding_rects[i]));
 165 }
 166
 167 void DebugRectHistory::SaveNonOccludingRects(
 168     const std::vector<gfx::Rect>& non_occluding_rects) {
 169   for (size_t i = 0; i < non_occluding_rects.size(); ++i) {
 170     debug_rects_.push_back(
 171         DebugRect(NONOCCLUDING_RECT_TYPE, non_occluding_rects[i]));
 172   }
 173 }
 174
 175 void DebugRectHistory::SaveTouchEventHandlerRects(LayerImpl* layer) {
 176   LayerTreeHostCommon::CallFunctionForSubtree<LayerImpl>(
 177       layer,
 178       base::Bind(&DebugRectHistory::SaveTouchEventHandlerRectsCallback,
 179                  base::Unretained(this)));
 180 }
 181
 182 void DebugRectHistory::SaveTouchEventHandlerRectsCallback(LayerImpl* layer) {
 183   for (Region::Iterator iter(layer->touch_event_handler_region());
 184        iter.has_rect();
 185        iter.next()) {
 186     gfx::RectF touch_rect = gfx::ScaleRect(iter.rect(),
 187                                            layer->contents_scale_x(),
 188                                            layer->contents_scale_y());
 189     debug_rects_.push_back(DebugRect(TOUCH_EVENT_HANDLER_RECT_TYPE,
 190                                      MathUtil::MapClippedRect(
 191                                          layer->screen_space_transform(),
 192                                          touch_rect)));
 193   }
 194 }
 195
 196 void DebugRectHistory::SaveWheelEventHandlerRects(LayerImpl* layer) {
 197   LayerTreeHostCommon::CallFunctionForSubtree<LayerImpl>(
 198       layer,
 199       base::Bind(&DebugRectHistory::SaveWheelEventHandlerRectsCallback,
 200                  base::Unretained(this)));
 201 }
 202
 203 void DebugRectHistory::SaveWheelEventHandlerRectsCallback(LayerImpl* layer) {
 204   if (!layer->have_wheel_event_handlers())
 205     return;
 206
 207   gfx::RectF wheel_rect = gfx::RectF(layer->content_bounds());
 208   wheel_rect.Scale(layer->contents_scale_x(), layer->contents_scale_y());
 209   debug_rects_.push_back(DebugRect(WHEEL_EVENT_HANDLER_RECT_TYPE,
 210                                    MathUtil::MapClippedRect(
 211                                        layer->screen_space_transform(),
 212                                        wheel_rect)));
 213 }
 214
 215 void DebugRectHistory::SaveNonFastScrollableRects(LayerImpl* layer) {
 216   LayerTreeHostCommon::CallFunctionForSubtree<LayerImpl>(
 217       layer,
 218       base::Bind(&DebugRectHistory::SaveNonFastScrollableRectsCallback,
 219                  base::Unretained(this)));
 220 }
 221
 222 void DebugRectHistory::SaveNonFastScrollableRectsCallback(LayerImpl* layer) {
 223   for (Region::Iterator iter(layer->non_fast_scrollable_region());
 224        iter.has_rect();
 225        iter.next()) {
 226     gfx::RectF scroll_rect = gfx::ScaleRect(iter.rect(),
 227                                             layer->contents_scale_x(),
 228                                             layer->contents_scale_y());
 229     debug_rects_.push_back(DebugRect(NON_FAST_SCROLLABLE_RECT_TYPE,
 230                                      MathUtil::MapClippedRect(
 231                                          layer->screen_space_transform(),
 232                                          scroll_rect)));
 233   }
 234 }
 235
 236 }  // namespace cc