1
    2
    3
    4
    5
    6
    7
    8
    9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
  100
  101
  102
  103
  104
  105
  106
  107
  108
  109
  110
  111
  112
  113
  114
  115
  116
  117
  118
  119
  120
  121
  122


cc / trees / debug_rect_history.h [blame]

// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef CC_TREES_DEBUG_RECT_HISTORY_H_
#define CC_TREES_DEBUG_RECT_HISTORY_H_

#include <memory>
#include <vector>

#include "cc/cc_export.h"
#include "cc/input/touch_action.h"
#include "cc/layers/layer_collections.h"
#include "ui/gfx/geometry/rect.h"

namespace cc {

class LayerImpl;
class LayerTreeDebugState;
class LayerTreeImpl;
class HeadsUpDisplayLayerImpl;

// There are various types of debug rects:
//
// - Paint rects (update rects): regions of a layer that needed to be
// re-uploaded to the texture resource; in most cases implying that they had to
// be repainted, too.
//
// - Property-changed rects: enclosing bounds of layers that cause changes to
// the screen even if the layer did not change internally. (For example, if the
// layer's opacity or position changes.)
//
// - Surface damage rects: the aggregate damage on a target surface that is
// caused by all layers and surfaces that contribute to it. This includes (1)
// paint rects, (2) property- changed rects, and (3) newly exposed areas.
//
// - Screen space rects: this is the region the contents occupy in screen space.
//
// - Layout shift rects: regions of an animation frame that were shifted while
// the page is loading content.
enum class DebugRectType {
  kPaint,
  kPropertyChanged,
  kSurfaceDamage,
  kScreenSpace,
  kTouchEventHandler,
  kWheelEventHandler,
  kScrollEventHandler,
  kMainThreadScrollHitTest,
  kMainThreadScrollRepaint,
  kRasterInducingScroll,
  kAnimationBounds,
  kLayoutShift,
};

struct DebugRect {
  DebugRect(DebugRectType new_type,
            const gfx::Rect& new_rect,
            TouchAction new_touch_action = TouchAction::kNone,
            uint32_t main_thread_scroll_repaint_reasons = 0)
      : type(new_type),
        rect(new_rect),
        touch_action(new_touch_action),
        main_thread_scroll_repaint_reasons(main_thread_scroll_repaint_reasons) {
    DCHECK(type == DebugRectType::kTouchEventHandler ||
           touch_action == TouchAction::kNone);
    DCHECK(type != DebugRectType::kMainThreadScrollRepaint ||
           !main_thread_scroll_repaint_reasons);
  }
  DebugRectType type;
  gfx::Rect rect;
  // Valid when `type` is `kTouchEventHandler`, otherwise default to
  // `TouchAction::kNone`.
  TouchAction touch_action;
  // Valid when `type` is `kMainThreadScrollRepaint`, otherwise 0.
  uint32_t main_thread_scroll_repaint_reasons;
};

// This class maintains a history of rects of various types that can be used
// for debugging purposes. The overhead of collecting rects is performed only if
// the appropriate LayerTreeSettings are enabled.
class CC_EXPORT DebugRectHistory {
 public:
  static std::unique_ptr<DebugRectHistory> Create();

  DebugRectHistory(const DebugRectHistory&) = delete;
  ~DebugRectHistory();

  DebugRectHistory& operator=(const DebugRectHistory&) = delete;

  // Note: Saving debug rects must happen before layers' change tracking is
  // reset.
  void SaveDebugRectsForCurrentFrame(
      LayerTreeImpl* tree_impl,
      HeadsUpDisplayLayerImpl* hud_layer,
      const RenderSurfaceList& render_surface_list,
      const LayerTreeDebugState& debug_state);

  const std::vector<DebugRect>& debug_rects() { return debug_rects_; }

 private:
  DebugRectHistory();

  void SaveLayoutShiftRects(HeadsUpDisplayLayerImpl* hud);
  void SavePaintRects(LayerTreeImpl* tree_impl);
  void SavePropertyChangedRects(LayerTreeImpl* tree_impl, LayerImpl* hud_layer);
  void SaveSurfaceDamageRects(const RenderSurfaceList& render_surface_list);
  void SaveScreenSpaceRects(const RenderSurfaceList& render_surface_list);
  void SaveTouchEventHandlerRects(LayerTreeImpl* tree_impl);
  void SaveWheelEventHandlerRects(LayerTreeImpl* tree_impl);
  void SaveScrollEventHandlerRects(LayerTreeImpl* tree_impl);
  void SaveMainThreadScrollHitTestRects(LayerTreeImpl* tree_impl);
  void SaveMainThreadScrollRepaintOrRasterInducingScrollRects(
      LayerTreeImpl* tree_impl,
      DebugRectType type);

  std::vector<DebugRect> debug_rects_;
};

}  // namespace cc

#endif  // CC_TREES_DEBUG_RECT_HISTORY_H_