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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
|
// Copyright 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CC_PLAYBACK_PICTURE_PILE_IMPL_H_
#define CC_PLAYBACK_PICTURE_PILE_IMPL_H_
#include <map>
#include <set>
#include <vector>
#include "base/time/time.h"
#include "cc/base/cc_export.h"
#include "cc/debug/rendering_stats_instrumentation.h"
#include "cc/playback/picture_pile.h"
#include "cc/playback/pixel_ref_map.h"
#include "cc/playback/raster_source.h"
#include "skia/ext/analysis_canvas.h"
#include "skia/ext/refptr.h"
class SkCanvas;
class SkPicture;
class SkPixelRef;
namespace gfx {
class Rect;
}
namespace cc {
class CC_EXPORT PicturePileImpl : public RasterSource {
public:
static scoped_refptr<PicturePileImpl> CreateFromPicturePile(
const PicturePile* other,
bool can_use_lcd_text);
// RasterSource overrides. See RasterSource header for full description.
// When slow-down-raster-scale-factor is set to a value greater than 1, the
// reported rasterize time (in stats_instrumentation) is the minimum measured
// value over all runs.
void PlaybackToCanvas(SkCanvas* canvas,
const gfx::Rect& canvas_bitmap_rect,
const gfx::Rect& canvas_playback_rect,
float contents_scale) const override;
void PlaybackToSharedCanvas(SkCanvas* canvas,
const gfx::Rect& canvas_rect,
float contents_scale) const override;
void PerformSolidColorAnalysis(
const gfx::Rect& content_rect,
float contents_scale,
RasterSource::SolidColorAnalysis* analysis) const override;
void GatherPixelRefs(
const gfx::Rect& content_rect,
float contents_scale,
std::vector<skia::PositionPixelRef>* pixel_refs) const override;
bool CoversRect(const gfx::Rect& content_rect,
float contents_scale) const override;
void SetShouldAttemptToUseDistanceFieldText() override;
bool ShouldAttemptToUseDistanceFieldText() const override;
gfx::Size GetSize() const override;
bool IsSolidColor() const override;
SkColor GetSolidColor() const override;
bool HasRecordings() const override;
bool CanUseLCDText() const override;
scoped_refptr<RasterSource> CreateCloneWithoutLCDText() const override;
// Tracing functionality.
void DidBeginTracing() override;
void AsValueInto(base::trace_event::TracedValue* array) const override;
skia::RefPtr<SkPicture> GetFlattenedPicture() override;
size_t GetPictureMemoryUsage() const override;
// Iterator used to return SkPixelRefs from this picture pile.
// Public for testing.
class CC_EXPORT PixelRefIterator {
public:
PixelRefIterator(const gfx::Rect& content_rect,
float contents_scale,
const PicturePileImpl* picture_pile);
~PixelRefIterator();
const skia::PositionPixelRef* operator->() const {
return &(*pixel_ref_iterator_);
}
const skia::PositionPixelRef& operator*() const {
return *pixel_ref_iterator_;
}
PixelRefIterator& operator++();
operator bool() const { return pixel_ref_iterator_; }
private:
void AdvanceToTilePictureWithPixelRefs();
const PicturePileImpl* picture_pile_;
gfx::Rect layer_rect_;
TilingData::Iterator tile_iterator_;
PixelRefMap::Iterator pixel_ref_iterator_;
std::set<const void*> processed_pictures_;
};
protected:
friend class PicturePile;
friend class PixelRefIterator;
using PictureMapKey = PicturePile::PictureMapKey;
using PictureMap = PicturePile::PictureMap;
PicturePileImpl();
explicit PicturePileImpl(const PicturePile* other, bool can_use_lcd_text);
explicit PicturePileImpl(const PicturePileImpl* other, bool can_use_lcd_text);
~PicturePileImpl() override;
int buffer_pixels() const { return tiling_.border_texels(); }
// These members are const as this raster source may be in use on another
// thread and so should not be touched after construction.
const PictureMap picture_map_;
const TilingData tiling_;
const SkColor background_color_;
const bool requires_clear_;
const bool can_use_lcd_text_;
const bool is_solid_color_;
const SkColor solid_color_;
const gfx::Rect recorded_viewport_;
const bool has_any_recordings_;
const bool clear_canvas_with_debug_color_;
const float min_contents_scale_;
const int slow_down_raster_scale_factor_for_debug_;
// TODO(enne/vmiura): this has a read/write race between raster and compositor
// threads with multi-threaded Ganesh. Make this const or remove it.
bool should_attempt_to_use_distance_field_text_;
size_t picture_memory_usage_;
private:
typedef std::map<const Picture*, Region> PictureRegionMap;
// Called when analyzing a tile. We can use AnalysisCanvas as
// SkPicture::AbortCallback, which allows us to early out from analysis.
void RasterForAnalysis(skia::AnalysisCanvas* canvas,
const gfx::Rect& canvas_rect,
float contents_scale) const;
void CoalesceRasters(const gfx::Rect& canvas_rect,
const gfx::Rect& content_rect,
float contents_scale,
PictureRegionMap* result) const;
void RasterCommon(SkCanvas* canvas,
SkPicture::AbortCallback* callback,
const gfx::Rect& canvas_rect,
float contents_scale) const;
// An internal CanRaster check that goes to the picture_map rather than
// using the recorded_viewport hint.
bool CanRasterSlowTileCheck(const gfx::Rect& layer_rect) const;
gfx::Rect PaddedRect(const PictureMapKey& key) const;
DISALLOW_COPY_AND_ASSIGN(PicturePileImpl);
};
} // namespace cc
#endif // CC_PLAYBACK_PICTURE_PILE_IMPL_H_
|