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
|
// 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_LAYERS_PICTURE_LAYER_IMPL_H_
#define CC_LAYERS_PICTURE_LAYER_IMPL_H_
#include <string>
#include <vector>
#include "cc/base/cc_export.h"
#include "cc/base/scoped_ptr_vector.h"
#include "cc/layers/layer_impl.h"
#include "cc/resources/picture_layer_tiling.h"
#include "cc/resources/picture_layer_tiling_set.h"
#include "cc/resources/picture_pile_impl.h"
#include "skia/ext/refptr.h"
#include "third_party/skia/include/core/SkPicture.h"
namespace cc {
struct AppendQuadsData;
class QuadSink;
class MicroBenchmarkImpl;
class CC_EXPORT PictureLayerImpl
: public LayerImpl,
NON_EXPORTED_BASE(public PictureLayerTilingClient) {
public:
static scoped_ptr<PictureLayerImpl> Create(LayerTreeImpl* tree_impl, int id) {
return make_scoped_ptr(new PictureLayerImpl(tree_impl, id));
}
virtual ~PictureLayerImpl();
// LayerImpl overrides.
virtual const char* LayerTypeAsString() const OVERRIDE;
virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
OVERRIDE;
virtual void PushPropertiesTo(LayerImpl* layer) OVERRIDE;
virtual void AppendQuads(QuadSink* quad_sink,
AppendQuadsData* append_quads_data) OVERRIDE;
virtual void UpdateTilePriorities() OVERRIDE;
virtual void DidBecomeActive() OVERRIDE;
virtual void DidBeginTracing() OVERRIDE;
virtual void DidLoseOutputSurface() OVERRIDE;
virtual void CalculateContentsScale(float ideal_contents_scale,
float device_scale_factor,
float page_scale_factor,
bool animating_transform_to_screen,
float* contents_scale_x,
float* contents_scale_y,
gfx::Size* content_bounds) OVERRIDE;
virtual skia::RefPtr<SkPicture> GetPicture() OVERRIDE;
// PictureLayerTilingClient overrides.
virtual scoped_refptr<Tile> CreateTile(PictureLayerTiling* tiling,
gfx::Rect content_rect) OVERRIDE;
virtual void UpdatePile(Tile* tile) OVERRIDE;
virtual gfx::Size CalculateTileSize(
gfx::Size content_bounds) const OVERRIDE;
virtual const Region* GetInvalidation() OVERRIDE;
virtual const PictureLayerTiling* GetTwinTiling(
const PictureLayerTiling* tiling) const OVERRIDE;
// PushPropertiesTo active tree => pending tree.
void SyncTiling(const PictureLayerTiling* tiling);
// Mask-related functions
void SetIsMask(bool is_mask);
virtual ResourceProvider::ResourceId ContentsResourceId() const OVERRIDE;
virtual size_t GPUMemoryUsageInBytes() const OVERRIDE;
virtual void RunMicroBenchmark(MicroBenchmarkImpl* benchmark) OVERRIDE;
protected:
PictureLayerImpl(LayerTreeImpl* tree_impl, int id);
PictureLayerTiling* AddTiling(float contents_scale);
void RemoveTiling(float contents_scale);
void RemoveAllTilings();
void SyncFromActiveLayer(const PictureLayerImpl* other);
void ManageTilings(bool animating_transform_to_screen);
virtual bool ShouldAdjustRasterScale(
bool animating_transform_to_screen) const;
virtual void RecalculateRasterScales(
bool animating_transform_to_screen);
void CleanUpTilingsOnActiveLayer(
std::vector<PictureLayerTiling*> used_tilings);
float MinimumContentsScale() const;
float SnappedContentsScale(float new_contents_scale);
void UpdateLCDTextStatus(bool new_status);
void ResetRasterScale();
void MarkVisibleResourcesAsRequired() const;
bool MarkVisibleTilesAsRequired(
PictureLayerTiling* tiling,
const PictureLayerTiling* optional_twin_tiling,
float contents_scale,
gfx::Rect rect,
const Region& missing_region) const;
void DoPostCommitInitializationIfNeeded() {
if (needs_post_commit_initialization_)
DoPostCommitInitialization();
}
void DoPostCommitInitialization();
bool CanHaveTilings() const;
bool CanHaveTilingWithScale(float contents_scale) const;
void SanityCheckTilingState() const;
bool ShouldUseGPURasterization() const;
virtual void GetDebugBorderProperties(
SkColor* color, float* width) const OVERRIDE;
virtual void AsValueInto(base::DictionaryValue* dict) const OVERRIDE;
PictureLayerImpl* twin_layer_;
scoped_ptr<PictureLayerTilingSet> tilings_;
scoped_refptr<PicturePileImpl> pile_;
Region invalidation_;
gfx::Transform last_screen_space_transform_;
gfx::Size last_bounds_;
float last_content_scale_;
bool is_mask_;
float ideal_page_scale_;
float ideal_device_scale_;
float ideal_source_scale_;
float ideal_contents_scale_;
float raster_page_scale_;
float raster_device_scale_;
float raster_source_scale_;
float raster_contents_scale_;
float low_res_raster_contents_scale_;
bool raster_source_scale_was_animating_;
bool is_using_lcd_text_;
bool needs_post_commit_initialization_;
// A sanity state check to make sure UpdateTilePriorities only gets called
// after a CalculateContentsScale/ManageTilings.
bool should_update_tile_priorities_;
friend class PictureLayer;
DISALLOW_COPY_AND_ASSIGN(PictureLayerImpl);
};
} // namespace cc
#endif // CC_LAYERS_PICTURE_LAYER_IMPL_H_
|
