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
|
// 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_RESOURCES_PICTURE_PILE_H_
#define CC_RESOURCES_PICTURE_PILE_H_
#include <bitset>
#include <utility>
#include <vector>
#include "base/containers/hash_tables.h"
#include "base/memory/ref_counted.h"
#include "cc/base/tiling_data.h"
#include "cc/resources/picture.h"
namespace cc {
class PicturePileImpl;
class CC_EXPORT PicturePile : public RecordingSource {
public:
PicturePile(float min_contents_scale, const gfx::Size& tile_grid_size);
~PicturePile() override;
// RecordingSource overrides.
bool UpdateAndExpandInvalidation(ContentLayerClient* painter,
Region* invalidation,
bool can_use_lcd_text,
const gfx::Size& layer_size,
const gfx::Rect& visible_layer_rect,
int frame_number,
RecordingMode recording_mode) override;
scoped_refptr<RasterSource> CreateRasterSource() const override;
gfx::Size GetSize() const final;
void SetEmptyBounds() override;
void SetSlowdownRasterScaleFactor(int factor) override;
void SetBackgroundColor(SkColor background_color) override;
void SetRequiresClear(bool requires_clear) override;
bool IsSuitableForGpuRasterization() const override;
void SetUnsuitableForGpuRasterizationForTesting() override;
gfx::Size GetTileGridSizeForTesting() const override;
protected:
class CC_EXPORT PictureInfo {
public:
enum { INVALIDATION_FRAMES_TRACKED = 32 };
PictureInfo();
~PictureInfo();
bool Invalidate(int frame_number);
bool NeedsRecording(int frame_number, int distance_to_visible);
void SetPicture(scoped_refptr<Picture> picture);
const Picture* GetPicture() const;
float GetInvalidationFrequencyForTesting() const {
return GetInvalidationFrequency();
}
private:
void AdvanceInvalidationHistory(int frame_number);
float GetInvalidationFrequency() const;
int last_frame_number_;
scoped_refptr<const Picture> picture_;
std::bitset<INVALIDATION_FRAMES_TRACKED> invalidation_history_;
};
typedef std::pair<int, int> PictureMapKey;
typedef base::hash_map<PictureMapKey, PictureInfo> PictureMap;
// 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;
void Clear();
void SetMinContentsScale(float min_contents_scale);
void SetTileGridSize(const gfx::Size& tile_grid_size);
gfx::Rect PaddedRect(const PictureMapKey& key) const;
gfx::Rect PadRect(const gfx::Rect& rect) const;
int buffer_pixels() const { return tiling_.border_texels(); }
// A picture pile is a tiled set of pictures. The picture map is a map of tile
// indices to picture infos.
PictureMap picture_map_;
TilingData tiling_;
// If non-empty, all pictures tiles inside this rect are recorded. There may
// be recordings outside this rect, but everything inside the rect is
// recorded.
gfx::Rect recorded_viewport_;
float min_contents_scale_;
gfx::Size tile_grid_size_;
int slow_down_raster_scale_factor_for_debug_;
bool can_use_lcd_text_;
// A hint about whether there are any recordings. This may be a false
// positive.
bool has_any_recordings_;
bool clear_canvas_with_debug_color_;
bool requires_clear_;
bool is_solid_color_;
SkColor solid_color_;
SkColor background_color_;
int pixel_record_distance_;
private:
friend class PicturePileImpl;
void CreatePictures(ContentLayerClient* painter,
RecordingMode recording_mode,
const std::vector<gfx::Rect>& record_rects);
void GetInvalidTileRects(const gfx::Rect& interest_rect,
Region* invalidation,
const gfx::Rect& visible_layer_rect,
int frame_number,
std::vector<gfx::Rect>* invalid_tiles);
bool ApplyInvalidationAndResize(const gfx::Rect& interest_rect,
Region* invalidation,
const gfx::Size& layer_size,
int frame_number,
bool can_use_lcd_text_changed);
void DetermineIfSolidColor();
void SetBufferPixels(int buffer_pixels);
bool is_suitable_for_gpu_rasterization_;
DISALLOW_COPY_AND_ASSIGN(PicturePile);
};
} // namespace cc
#endif // CC_RESOURCES_PICTURE_PILE_H_
|
