debug.dart 10.8 KB
Newer Older
Ian Hickson's avatar
Ian Hickson committed
1
// Copyright 2014 The Flutter Authors. All rights reserved.
2 3 4
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

5 6
import 'object.dart';

7
export 'package:flutter/foundation.dart' show debugPrint;
8

9 10 11
// Any changes to this file should be reflected in the debugAssertAllRenderVarsUnset()
// function below.

12
const HSVColor _kDebugDefaultRepaintColor = HSVColor.fromAHSV(0.4, 60.0, 1.0, 1.0);
13

14
/// Causes each RenderBox to paint a box around its bounds, and some extra
Ian Hickson's avatar
Ian Hickson committed
15
/// boxes, such as [RenderPadding], to draw construction lines.
16
///
17
/// The edges of the boxes are painted as a one-pixel-thick `const Color(0xFF00FFFF)` outline.
18
///
19
/// Spacing is painted as a solid `const Color(0x90909090)` area.
20
///
21 22 23
/// Padding is filled in solid `const Color(0x900090FF)`, with the inner edge
/// outlined in `const Color(0xFF0090FF)`, using [debugPaintPadding].
bool debugPaintSizeEnabled = false;
24

Adam Barth's avatar
Adam Barth committed
25
/// Causes each RenderBox to paint a line at each of its baselines.
26
bool debugPaintBaselinesEnabled = false;
Adam Barth's avatar
Adam Barth committed
27 28

/// Causes each Layer to paint a box around its bounds.
29
bool debugPaintLayerBordersEnabled = false;
Adam Barth's avatar
Adam Barth committed
30

31 32 33 34 35 36
/// Causes objects like [RenderPointerListener] to flash while they are being
/// tapped. This can be useful to see how large the hit box is, e.g. when
/// debugging buttons that are harder to hit than expected.
///
/// For details on how to support this in your [RenderBox] subclass, see
/// [RenderBox.debugHandleEvent].
37
bool debugPaintPointersEnabled = false;
38

39
/// Overlay a rotating set of colors when repainting layers in debug mode.
40 41 42 43 44
///
/// See also:
///
///  * [RepaintBoundary], which can be used to contain repaints when unchanged
///    areas are being excessively repainted.
45
bool debugRepaintRainbowEnabled = false;
46

47
/// Overlay a rotating set of colors when repainting text in debug mode.
48 49
bool debugRepaintTextRainbowEnabled = false;

50
/// The current color to overlay when repainting a layer.
51 52 53 54 55 56 57
///
/// This is used by painting debug code that implements
/// [debugRepaintRainbowEnabled] or [debugRepaintTextRainbowEnabled].
///
/// The value is incremented by [RenderView.compositeFrame] if either of those
/// flags is enabled.
HSVColor debugCurrentRepaintColor = _kDebugDefaultRepaintColor;
58

59
/// Log the call stacks that mark render objects as needing layout.
60 61 62 63 64
///
/// For sanity, this only logs the stack traces of cases where an object is
/// added to the list of nodes needing layout. This avoids printing multiple
/// redundant stack traces as a single [RenderObject.markNeedsLayout] call walks
/// up the tree.
65 66
bool debugPrintMarkNeedsLayoutStacks = false;

67 68 69 70 71 72 73 74 75 76 77 78 79 80
/// Log the call stacks that mark render objects as needing paint.
bool debugPrintMarkNeedsPaintStacks = false;

/// Log the dirty render objects that are laid out each frame.
///
/// Combined with [debugPrintBeginFrameBanner], this allows you to distinguish
/// layouts triggered by the initial mounting of a render tree (e.g. in a call
/// to [runApp]) from the regular layouts triggered by the pipeline.
///
/// Combined with [debugPrintMarkNeedsLayoutStacks], this lets you watch a
/// render object's dirty/clean lifecycle.
///
/// See also:
///
81 82 83 84
///  * [debugProfileLayoutsEnabled], which does something similar for layout
///    but using the timeline view.
///  * [debugProfilePaintsEnabled], which does something similar for painting
///    but using the timeline view.
85 86 87 88 89
///  * [debugPrintRebuildDirtyWidgets], which does something similar for widgets
///    being rebuilt.
///  * The discussion at [RendererBinding.drawFrame].
bool debugPrintLayouts = false;

90
/// Check the intrinsic sizes of each [RenderBox] during layout.
91
///
92 93 94
/// By default this is turned off since these checks are expensive. If you are
/// implementing your own children of [RenderBox] with custom intrinsics, turn
/// this on in your unit tests for additional validations.
95 96
bool debugCheckIntrinsicSizes = false;

97 98
/// Adds [dart:developer.Timeline] events for every [RenderObject] layout.
///
Ian Hickson's avatar
Ian Hickson committed
99 100 101 102 103 104 105 106 107 108 109 110
/// The timing information this flag exposes is not representative of the actual
/// cost of layout, because the overhead of adding timeline events is
/// significant relative to the time each object takes to lay out. However, it
/// can expose unexpected layout behavior in the timeline.
///
/// In debug builds, additional information is included in the trace (such as
/// the properties of render objects being laid out). Collecting this data is
/// expensive and further makes these traces non-representative of actual
/// performance. This data is omitted in profile builds.
///
/// For more information about performance debugging in Flutter, see
/// <https://flutter.dev/docs/perf/rendering>.
111 112 113 114 115 116 117 118 119 120
///
/// See also:
///
///  * [debugPrintLayouts], which does something similar for layout but using
///    console output.
///  * [debugProfileBuildsEnabled], which does something similar for widgets
///    being rebuilt.
///  * [debugProfilePaintsEnabled], which does something similar for painting.
bool debugProfileLayoutsEnabled = false;

121 122
/// Adds [dart:developer.Timeline] events for every [RenderObject] painted.
///
123
/// The timing information this flag exposes is not representative of actual
Ian Hickson's avatar
Ian Hickson committed
124 125 126 127 128 129 130 131
/// paints, because the overhead of adding timeline events is significant
/// relative to the time each object takes to paint. However, it can expose
/// unexpected painting in the timeline.
///
/// In debug builds, additional information is included in the trace (such as
/// the properties of render objects being painted). Collecting this data is
/// expensive and further makes these traces non-representative of actual
/// performance. This data is omitted in profile builds.
132
///
Ian Hickson's avatar
Ian Hickson committed
133 134
/// For more information about performance debugging in Flutter, see
/// <https://flutter.dev/docs/perf/rendering>.
135 136 137
///
/// See also:
///
138 139 140
///  * [debugProfileBuildsEnabled], which does something similar for widgets
///    being rebuilt, and [debugPrintRebuildDirtyWidgets], its console
///    equivalent.
141 142
///  * [debugProfileLayoutsEnabled], which does something similar for layout,
///    and [debugPrintLayouts], its console equivalent.
143
///  * The discussion at [RendererBinding.drawFrame].
144 145
///  * [RepaintBoundary], which can be used to contain repaints when unchanged
///    areas are being excessively repainted.
146 147
bool debugProfilePaintsEnabled = false;

148
/// Signature for [debugOnProfilePaint] implementations.
149
typedef ProfilePaintCallback = void Function(RenderObject renderObject);
150 151 152 153 154 155 156 157 158 159 160 161 162 163 164

/// Callback invoked for every [RenderObject] painted each frame.
///
/// This callback is only invoked in debug builds.
///
/// See also:
///
///  * [debugProfilePaintsEnabled], which does something similar but adds
///    [dart:developer.Timeline] events instead of invoking a callback.
///  * [debugOnRebuildDirtyWidget], which does something similar for widgets
///    being built.
///  * [WidgetInspectorService], which uses the [debugOnProfilePaint]
///    callback to generate aggregate profile statistics describing what paints
///    occurred when the `ext.flutter.inspector.trackRepaintWidgets` service
///    extension is enabled.
165
ProfilePaintCallback? debugOnProfilePaint;
166

167 168
/// Setting to true will cause all clipping effects from the layer tree to be
/// ignored.
169 170
///
/// Can be used to debug whether objects being clipped are painting excessively
171 172 173 174 175 176
/// in clipped areas. Can also be used to check whether excessive use of
/// clipping is affecting performance.
///
/// This will not reduce the number of [Layer] objects created; the compositing
/// strategy is unaffected. It merely causes the clipping layers to be skipped
/// when building the scene.
177 178
bool debugDisableClipLayers = false;

179 180
/// Setting to true will cause all physical modeling effects from the layer
/// tree, such as shadows from elevations, to be ignored.
181 182 183
///
/// Can be used to check whether excessive use of physical models is affecting
/// performance.
184 185 186 187
///
/// This will not reduce the number of [Layer] objects created; the compositing
/// strategy is unaffected. It merely causes the physical shape layers to be
/// skipped when building the scene.
188 189
bool debugDisablePhysicalShapeLayers = false;

190 191
/// Setting to true will cause all opacity effects from the layer tree to be
/// ignored.
192 193
///
/// An optimization to not paint the child at all when opacity is 0 will still
194 195 196 197 198 199 200 201
/// remain.
///
/// Can be used to check whether excessive use of opacity effects is affecting
/// performance.
///
/// This will not reduce the number of [Layer] objects created; the compositing
/// strategy is unaffected. It merely causes the opacity layers to be skipped
/// when building the scene.
202
bool debugDisableOpacityLayers = false;
203

204
void _debugDrawDoubleRect(Canvas canvas, Rect outerRect, Rect innerRect, Color color) {
205
  final Path path = Path()
206 207 208
    ..fillType = PathFillType.evenOdd
    ..addRect(outerRect)
    ..addRect(innerRect);
209
  final Paint paint = Paint()
210 211 212 213
    ..color = color;
  canvas.drawPath(path, paint);
}

214
/// Paint a diagram showing the given area as padding.
215 216 217
///
/// Called by [RenderPadding.debugPaintSize] when [debugPaintSizeEnabled] is
/// true.
218
void debugPaintPadding(Canvas canvas, Rect outerRect, Rect? innerRect, { double outlineWidth = 2.0 }) {
219 220
  assert(() {
    if (innerRect != null && !innerRect.isEmpty) {
221 222
      _debugDrawDoubleRect(canvas, outerRect, innerRect, const Color(0x900090FF));
      _debugDrawDoubleRect(canvas, innerRect.inflate(outlineWidth).intersect(outerRect), innerRect, const Color(0xFF0090FF));
223
    } else {
224
      final Paint paint = Paint()
225
        ..color = const Color(0x90909090);
226 227 228
      canvas.drawRect(outerRect, paint);
    }
    return true;
229
  }());
230 231
}

232 233 234 235 236
/// Returns true if none of the rendering library debug variables have been changed.
///
/// This function is used by the test framework to ensure that debug variables
/// haven't been inadvertently changed.
///
237 238
/// See [the rendering library](rendering/rendering-library.html) for a complete
/// list.
239 240 241 242
///
/// The `debugCheckIntrinsicSizesOverride` argument can be provided to override
/// the expected value for [debugCheckIntrinsicSizes]. (This exists because the
/// test framework itself overrides this value in some cases.)
243
bool debugAssertAllRenderVarsUnset(String reason, { bool debugCheckIntrinsicSizesOverride = false }) {
244 245 246 247 248 249
  assert(() {
    if (debugPaintSizeEnabled ||
        debugPaintBaselinesEnabled ||
        debugPaintLayerBordersEnabled ||
        debugPaintPointersEnabled ||
        debugRepaintRainbowEnabled ||
250
        debugRepaintTextRainbowEnabled ||
251
        debugCurrentRepaintColor != _kDebugDefaultRepaintColor ||
252
        debugPrintMarkNeedsLayoutStacks ||
253 254
        debugPrintMarkNeedsPaintStacks ||
        debugPrintLayouts ||
255
        debugCheckIntrinsicSizes != debugCheckIntrinsicSizesOverride ||
256
        debugProfileLayoutsEnabled ||
257
        debugProfilePaintsEnabled ||
258 259 260 261
        debugOnProfilePaint != null ||
        debugDisableClipLayers ||
        debugDisablePhysicalShapeLayers ||
        debugDisableOpacityLayers) {
262
      throw FlutterError(reason);
263 264
    }
    return true;
265
  }());
266 267
  return true;
}