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
|
// Copyright 2014 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_SURFACES_SURFACE_AGGREGATOR_H_
#define CC_SURFACES_SURFACE_AGGREGATOR_H_
#include <set>
#include <unordered_map>
#include <unordered_set>
#include "base/macros.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
#include "cc/quads/draw_quad.h"
#include "cc/quads/render_pass.h"
#include "cc/resources/transferable_resource.h"
#include "cc/surfaces/surface_id.h"
#include "cc/surfaces/surfaces_export.h"
namespace cc {
class CompositorFrame;
class DelegatedFrameData;
class ResourceProvider;
class Surface;
class SurfaceDrawQuad;
class SurfaceManager;
class CC_SURFACES_EXPORT SurfaceAggregator {
public:
using SurfaceIndexMap = std::unordered_map<SurfaceId, int, SurfaceIdHash>;
SurfaceAggregator(SurfaceManager* manager,
ResourceProvider* provider,
bool aggregate_only_damaged);
~SurfaceAggregator();
scoped_ptr<CompositorFrame> Aggregate(SurfaceId surface_id);
void ReleaseResources(SurfaceId surface_id);
SurfaceIndexMap& previous_contained_surfaces() {
return previous_contained_surfaces_;
}
void SetFullDamageForSurface(SurfaceId surface_id);
private:
struct ClipData {
ClipData() : is_clipped(false) {}
ClipData(bool is_clipped, const gfx::Rect& rect)
: is_clipped(is_clipped), rect(rect) {}
bool is_clipped;
gfx::Rect rect;
};
struct PrewalkResult {
PrewalkResult();
~PrewalkResult();
bool has_copy_requests = false;
// This is the set of Surfaces that were referenced by another Surface, but
// not included in a SurfaceDrawQuad.
std::set<SurfaceId> undrawn_surfaces;
};
ClipData CalculateClipRect(const ClipData& surface_clip,
const ClipData& quad_clip,
const gfx::Transform& target_transform);
RenderPassId RemapPassId(RenderPassId surface_local_pass_id,
SurfaceId surface_id);
void HandleSurfaceQuad(const SurfaceDrawQuad* surface_quad,
const gfx::Transform& target_transform,
const ClipData& clip_rect,
RenderPass* dest_pass);
SharedQuadState* CopySharedQuadState(const SharedQuadState* source_sqs,
const gfx::Transform& target_transform,
const ClipData& clip_rect,
RenderPass* dest_render_pass);
void CopyQuadsToPass(
const QuadList& source_quad_list,
const SharedQuadStateList& source_shared_quad_state_list,
const std::unordered_map<ResourceId, ResourceId>& resource_to_child_map,
const gfx::Transform& target_transform,
const ClipData& clip_rect,
RenderPass* dest_pass,
SurfaceId surface_id);
gfx::Rect PrewalkTree(SurfaceId surface_id, PrewalkResult* result);
void CopyUndrawnSurfaces(PrewalkResult* prewalk);
void CopyPasses(const DelegatedFrameData* frame_data, Surface* surface);
// Remove Surfaces that were referenced before but aren't currently
// referenced from the ResourceProvider.
// Also notifies SurfaceAggregatorClient of newly added and removed
// child surfaces.
void ProcessAddedAndRemovedSurfaces();
int ChildIdForSurface(Surface* surface);
gfx::Rect DamageRectForSurface(const Surface* surface,
const RenderPass& source,
const gfx::Rect& full_rect) const;
SurfaceManager* manager_;
ResourceProvider* provider_;
class RenderPassIdAllocator;
using RenderPassIdAllocatorMap =
std::unordered_map<SurfaceId,
scoped_ptr<RenderPassIdAllocator>,
SurfaceIdHash>;
RenderPassIdAllocatorMap render_pass_allocator_map_;
int next_render_pass_id_;
const bool aggregate_only_damaged_;
using SurfaceToResourceChildIdMap =
std::unordered_map<SurfaceId, int, SurfaceIdHash>;
SurfaceToResourceChildIdMap surface_id_to_resource_child_id_;
// The following state is only valid for the duration of one Aggregate call
// and is only stored on the class to avoid having to pass through every
// function call.
// This is the set of surfaces referenced in the aggregation so far, used to
// detect cycles.
using SurfaceSet = std::set<SurfaceId>;
SurfaceSet referenced_surfaces_;
// For each Surface used in the last aggregation, gives the frame_index at
// that time.
SurfaceIndexMap previous_contained_surfaces_;
SurfaceIndexMap contained_surfaces_;
// After surface validation, every Surface in this set is valid.
std::unordered_set<SurfaceId, SurfaceIdHash> valid_surfaces_;
// This is the pass list for the aggregated frame.
RenderPassList* dest_pass_list_;
// The root damage rect of the currently-aggregating frame.
gfx::Rect root_damage_rect_;
// True if the frame that's currently being aggregated has copy requests.
// This is valid during Aggregate after PrewalkTree is called.
bool has_copy_requests_;
// Resource list for the aggregated frame.
TransferableResourceArray* dest_resource_list_;
base::WeakPtrFactory<SurfaceAggregator> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(SurfaceAggregator);
};
} // namespace cc
#endif // CC_SURFACES_SURFACE_AGGREGATOR_H_
|
