WriteParam(m, p.damage_rect);
WriteParam(m, p.transform_to_root_target);
WriteParam(m, p.has_transparent_background);
- WriteParam(m, p.shared_quad_state_list.size());
WriteParam(m, p.quad_list.size());
- size_t shared_quad_state_index = 0;
- size_t last_shared_quad_state_index = kuint32max;
- for (cc::QuadList::ConstIterator iter = p.quad_list.begin();
- iter != p.quad_list.end();
- ++iter) {
- const cc::DrawQuad* quad = &*iter;
+ cc::SharedQuadStateList::ConstIterator shared_quad_state_iter =
+ p.shared_quad_state_list.begin();
+ cc::SharedQuadStateList::ConstIterator last_shared_quad_state_iter =
+ p.shared_quad_state_list.end();
+ for (const auto& quad : p.quad_list) {
DCHECK(quad->rect.Contains(quad->visible_rect))
<< quad->material << " rect: " << quad->rect.ToString()
<< " visible_rect: " << quad->visible_rect.ToString();
break;
}
- const cc::ScopedPtrVector<cc::SharedQuadState>& sqs_list =
- p.shared_quad_state_list;
-
- // This is an invalid index.
- size_t bad_index = sqs_list.size();
-
// Null shared quad states should not occur.
DCHECK(quad->shared_quad_state);
- if (!quad->shared_quad_state) {
- WriteParam(m, bad_index);
- continue;
- }
// SharedQuadStates should appear in the order they are used by DrawQuads.
// Find the SharedQuadState for this DrawQuad.
- while (shared_quad_state_index < sqs_list.size() &&
- quad->shared_quad_state != sqs_list[shared_quad_state_index])
- ++shared_quad_state_index;
-
- DCHECK_LT(shared_quad_state_index, sqs_list.size());
- if (shared_quad_state_index >= sqs_list.size()) {
- WriteParam(m, bad_index);
- continue;
- }
-
- WriteParam(m, shared_quad_state_index);
- if (shared_quad_state_index != last_shared_quad_state_index) {
- WriteParam(m, *sqs_list[shared_quad_state_index]);
- last_shared_quad_state_index = shared_quad_state_index;
+ while (shared_quad_state_iter != p.shared_quad_state_list.end() &&
+ quad->shared_quad_state != *shared_quad_state_iter)
+ ++shared_quad_state_iter;
+
+ DCHECK(shared_quad_state_iter != p.shared_quad_state_list.end());
+
+ if (shared_quad_state_iter != last_shared_quad_state_iter) {
+ WriteParam(m, true);
+ WriteParam(m, **shared_quad_state_iter);
+ last_shared_quad_state_iter = shared_quad_state_iter;
+ } else {
+ WriteParam(m, false);
}
}
}
static size_t ReserveSizeForRenderPassWrite(const cc::RenderPass& p) {
size_t to_reserve = sizeof(cc::RenderPass);
- to_reserve += p.shared_quad_state_list.size() * sizeof(cc::SharedQuadState);
+ // Whether the quad points to a new shared quad state for each quad.
+ to_reserve += p.quad_list.size() * sizeof(bool);
- // The shared_quad_state_index for each quad.
- to_reserve += p.quad_list.size() * sizeof(size_t);
+ // Shared quad state is only written when a quad contains a shared quad state
+ // that has not been written.
+ to_reserve += p.shared_quad_state_list.size() * sizeof(cc::SharedQuadState);
// The largest quad type, verified by a unit test.
- to_reserve += p.quad_list.size() * sizeof(cc::kLargestDrawQuad);
+ to_reserve += p.quad_list.size() * cc::LargestDrawQuadSize();
return to_reserve;
}
gfx::Rect damage_rect;
gfx::Transform transform_to_root_target;
bool has_transparent_background;
- size_t shared_quad_state_list_size;
size_t quad_list_size;
if (!ReadParam(m, iter, &id) ||
!ReadParam(m, iter, &damage_rect) ||
!ReadParam(m, iter, &transform_to_root_target) ||
!ReadParam(m, iter, &has_transparent_background) ||
- !ReadParam(m, iter, &shared_quad_state_list_size) ||
!ReadParam(m, iter, &quad_list_size))
return false;
transform_to_root_target,
has_transparent_background);
- size_t last_shared_quad_state_index = kuint32max;
for (size_t i = 0; i < quad_list_size; ++i) {
cc::DrawQuad::Material material;
PickleIterator temp_iter = *iter;
return false;
}
- size_t shared_quad_state_index;
- if (!ReadParam(m, iter, &shared_quad_state_index))
- return false;
- if (shared_quad_state_index >= shared_quad_state_list_size)
- return false;
- // SharedQuadState indexes should be in ascending order.
- if (last_shared_quad_state_index != kuint32max &&
- shared_quad_state_index < last_shared_quad_state_index)
+ bool has_new_shared_quad_state;
+ if (!ReadParam(m, iter, &has_new_shared_quad_state))
return false;
// If the quad has a new shared quad state, read it in.
- if (last_shared_quad_state_index != shared_quad_state_index) {
+ if (has_new_shared_quad_state) {
cc::SharedQuadState* state = p->CreateAndAppendSharedQuadState();
if (!ReadParam(m, iter, state))
return false;
- last_shared_quad_state_index = shared_quad_state_index;
}
draw_quad->shared_quad_state = p->shared_quad_state_list.back();
l->append(", ");
l->append("[");
- for (size_t i = 0; i < p.shared_quad_state_list.size(); ++i) {
- if (i)
+ for (const auto& shared_quad_state : p.shared_quad_state_list) {
+ if (shared_quad_state != p.shared_quad_state_list.front())
l->append(", ");
- LogParam(*p.shared_quad_state_list[i], l);
+ LogParam(*shared_quad_state, l);
}
l->append("], [");
- for (cc::QuadList::ConstIterator iter = p.quad_list.begin();
- iter != p.quad_list.end();
- ++iter) {
- if (iter != p.quad_list.begin())
+ for (const auto& quad : p.quad_list) {
+ if (quad != p.quad_list.front())
l->append(", ");
- const cc::DrawQuad* quad = &*iter;
switch (quad->material) {
case cc::DrawQuad::CHECKERBOARD:
LogParam(*cc::CheckerboardDrawQuad::MaterialCast(quad), l);
to_reserve += p.resource_list.size() * sizeof(cc::TransferableResource);
for (size_t i = 0; i < p.render_pass_list.size(); ++i) {
const cc::RenderPass* pass = p.render_pass_list[i];
+ to_reserve += sizeof(size_t) * 2;
to_reserve += ReserveSizeForRenderPassWrite(*pass);
}
m->Reserve(to_reserve);
WriteParam(m, p.device_scale_factor);
WriteParam(m, p.resource_list);
WriteParam(m, p.render_pass_list.size());
- for (size_t i = 0; i < p.render_pass_list.size(); ++i)
+ for (size_t i = 0; i < p.render_pass_list.size(); ++i) {
+ WriteParam(m, p.render_pass_list[i]->quad_list.size());
+ WriteParam(m, p.render_pass_list[i]->shared_quad_state_list.size());
WriteParam(m, *p.render_pass_list[i]);
+ }
}
bool ParamTraits<cc::DelegatedFrameData>::Read(const Message* m,
return false;
const static size_t kMaxRenderPasses = 10000;
+ const static size_t kMaxSharedQuadStateListSize = 100000;
+ const static size_t kMaxQuadListSize = 1000000;
size_t num_render_passes;
if (!ReadParam(m, iter, &p->resource_list) ||
num_render_passes > kMaxRenderPasses || num_render_passes == 0)
return false;
for (size_t i = 0; i < num_render_passes; ++i) {
- scoped_ptr<cc::RenderPass> render_pass = cc::RenderPass::Create();
+ size_t quad_list_size;
+ size_t shared_quad_state_list_size;
+ if (!ReadParam(m, iter, &quad_list_size) ||
+ !ReadParam(m, iter, &shared_quad_state_list_size) ||
+ quad_list_size > kMaxQuadListSize ||
+ shared_quad_state_list_size > kMaxSharedQuadStateListSize)
+ return false;
+ scoped_ptr<cc::RenderPass> render_pass =
+ cc::RenderPass::Create(shared_quad_state_list_size, quad_list_size);
if (!ReadParam(m, iter, render_pass.get()))
return false;
p->render_pass_list.push_back(render_pass.Pass());
projects / platform / framework / web / crosswalk.git / blobdiff