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