diff options
Diffstat (limited to 'content')
| -rw-r--r-- | content/common/DEPS | 1 | ||||
| -rw-r--r-- | content/common/cc_messages.cc | 261 | ||||
| -rw-r--r-- | content/common/cc_messages.h | 119 | ||||
| -rw-r--r-- | content/common/cc_messages_unittest.cc | 431 | ||||
| -rw-r--r-- | content/content_common.gypi | 1 | ||||
| -rw-r--r-- | content/content_tests.gypi | 1 | ||||
| -rw-r--r-- | content/public/common/common_param_traits.cc | 21 | ||||
| -rw-r--r-- | content/public/common/common_param_traits.h | 8 |
8 files changed, 843 insertions, 0 deletions
diff --git a/content/common/DEPS b/content/common/DEPS index 5a35a26..2d409fc 100644 --- a/content/common/DEPS +++ b/content/common/DEPS @@ -1,4 +1,5 @@ include_rules = [ + "+cc", "+media/base", "+sandbox/linux/seccomp-legacy", ] diff --git a/content/common/cc_messages.cc b/content/common/cc_messages.cc index a8243f6..6c1c440 100644 --- a/content/common/cc_messages.cc +++ b/content/common/cc_messages.cc @@ -309,4 +309,265 @@ void ParamTraits<WebKit::WebTransformationMatrix>::Log( l->append(") "); } +void ParamTraits<cc::RenderPass>::Write( + Message* m, const param_type& p) { + WriteParam(m, p.id); + WriteParam(m, p.output_rect); + WriteParam(m, p.damage_rect); + WriteParam(m, p.transform_to_root_target); + WriteParam(m, p.has_transparent_background); + WriteParam(m, p.has_occlusion_from_outside_target_surface); + WriteParam(m, p.filters); + // TODO(danakj): filter isn't being serialized. + WriteParam(m, p.background_filters); + WriteParam(m, p.shared_quad_state_list.size()); + WriteParam(m, p.quad_list.size()); + + for (size_t i = 0; i < p.shared_quad_state_list.size(); ++i) + WriteParam(m, *p.shared_quad_state_list[i]); + + size_t shared_quad_state_index = 0; + for (size_t i = 0; i < p.quad_list.size(); ++i) { + const cc::DrawQuad* quad = p.quad_list[i]; + + switch (quad->material) { + case cc::DrawQuad::CHECKERBOARD: + WriteParam(m, *cc::CheckerboardDrawQuad::MaterialCast(quad)); + break; + case cc::DrawQuad::DEBUG_BORDER: + WriteParam(m, *cc::DebugBorderDrawQuad::MaterialCast(quad)); + break; + case cc::DrawQuad::IO_SURFACE_CONTENT: + WriteParam(m, *cc::IOSurfaceDrawQuad::MaterialCast(quad)); + break; + case cc::DrawQuad::TEXTURE_CONTENT: + WriteParam(m, *cc::TextureDrawQuad::MaterialCast(quad)); + break; + case cc::DrawQuad::RENDER_PASS: + WriteParam(m, *cc::RenderPassDrawQuad::MaterialCast(quad)); + break; + case cc::DrawQuad::SOLID_COLOR: + WriteParam(m, *cc::SolidColorDrawQuad::MaterialCast(quad)); + break; + case cc::DrawQuad::TILED_CONTENT: + WriteParam(m, *cc::TileDrawQuad::MaterialCast(quad)); + break; + case cc::DrawQuad::STREAM_VIDEO_CONTENT: + WriteParam(m, *cc::StreamVideoDrawQuad::MaterialCast(quad)); + break; + case cc::DrawQuad::YUV_VIDEO_CONTENT: + WriteParam(m, *cc::YUVVideoDrawQuad::MaterialCast(quad)); + break; + case cc::DrawQuad::INVALID: + 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; + } + + DCHECK_LT(shared_quad_state_index, p.shared_quad_state_list.size()); + WriteParam(m, shared_quad_state_index); + } +} + +template<typename QuadType> +static scoped_ptr<cc::DrawQuad> ReadDrawQuad(const Message* m, + PickleIterator* iter) { + scoped_ptr<QuadType> quad = QuadType::Create(); + if (!ReadParam(m, iter, quad.get())) + return scoped_ptr<QuadType>(NULL).template PassAs<cc::DrawQuad>(); + return quad.template PassAs<cc::DrawQuad>(); +} + +bool ParamTraits<cc::RenderPass>::Read( + const Message* m, PickleIterator* iter, param_type* p) { + cc::RenderPass::Id id(-1, -1); + gfx::Rect output_rect; + gfx::RectF damage_rect; + WebKit::WebTransformationMatrix transform_to_root_target; + bool has_transparent_background; + bool has_occlusion_from_outside_target_surface; + WebKit::WebFilterOperations filters; + WebKit::WebFilterOperations background_filters; + size_t shared_quad_state_list_size; + size_t quad_list_size; + + if (!ReadParam(m, iter, &id) || + !ReadParam(m, iter, &output_rect) || + !ReadParam(m, iter, &damage_rect) || + !ReadParam(m, iter, &transform_to_root_target) || + !ReadParam(m, iter, &has_transparent_background) || + !ReadParam(m, iter, &has_occlusion_from_outside_target_surface) || + !ReadParam(m, iter, &filters) || + !ReadParam(m, iter, &background_filters) || + !ReadParam(m, iter, &shared_quad_state_list_size) || + !ReadParam(m, iter, &quad_list_size)) + return false; + + p->SetAll(id, + output_rect, + damage_rect, + transform_to_root_target, + has_transparent_background, + has_occlusion_from_outside_target_surface, + filters, + NULL, // TODO(danakj): filter isn't being serialized. + background_filters); + + for (size_t i = 0; i < shared_quad_state_list_size; ++i) { + scoped_ptr<cc::SharedQuadState> state(cc::SharedQuadState::Create()); + if (!ReadParam(m, iter, state.get())) + return false; + p->shared_quad_state_list.append(state.Pass()); + } + + size_t last_shared_quad_state_index = 0; + for (size_t i = 0; i < quad_list_size; ++i) { + cc::DrawQuad::Material material; + PickleIterator temp_iter = *iter; + if (!ReadParam(m, &temp_iter, &material)) + return false; + + scoped_ptr<cc::DrawQuad> draw_quad; + switch (material) { + case cc::DrawQuad::CHECKERBOARD: + draw_quad = ReadDrawQuad<cc::CheckerboardDrawQuad>(m, iter); + break; + case cc::DrawQuad::DEBUG_BORDER: + draw_quad = ReadDrawQuad<cc::DebugBorderDrawQuad>(m, iter); + break; + case cc::DrawQuad::IO_SURFACE_CONTENT: + draw_quad = ReadDrawQuad<cc::IOSurfaceDrawQuad>(m, iter); + break; + case cc::DrawQuad::TEXTURE_CONTENT: + draw_quad = ReadDrawQuad<cc::TextureDrawQuad>(m, iter); + break; + case cc::DrawQuad::RENDER_PASS: + draw_quad = ReadDrawQuad<cc::RenderPassDrawQuad>(m, iter); + break; + case cc::DrawQuad::SOLID_COLOR: + draw_quad = ReadDrawQuad<cc::SolidColorDrawQuad>(m, iter); + break; + case cc::DrawQuad::TILED_CONTENT: + draw_quad = ReadDrawQuad<cc::TileDrawQuad>(m, iter); + break; + case cc::DrawQuad::STREAM_VIDEO_CONTENT: + draw_quad = ReadDrawQuad<cc::StreamVideoDrawQuad>(m, iter); + break; + case cc::DrawQuad::YUV_VIDEO_CONTENT: + draw_quad = ReadDrawQuad<cc::YUVVideoDrawQuad>(m, iter); + break; + case cc::DrawQuad::INVALID: + break; + } + if (!draw_quad) + return false; + + size_t shared_quad_state_index; + if (!ReadParam(m, iter, &shared_quad_state_index) || + shared_quad_state_index >= p->shared_quad_state_list.size()) + return false; + // SharedQuadState indexes should be in ascending order. + if (shared_quad_state_index < last_shared_quad_state_index) + return false; + last_shared_quad_state_index = shared_quad_state_index; + + draw_quad->shared_quad_state = + p->shared_quad_state_list[shared_quad_state_index]; + + p->quad_list.append(draw_quad.Pass()); + } + + return true; +} + +void ParamTraits<cc::RenderPass>::Log( + const param_type& p, std::string* l) { + l->append("RenderPass(("); + LogParam(p.id, l); + l->append("), "); + LogParam(p.output_rect, l); + l->append(", "); + LogParam(p.damage_rect, l); + l->append(", "); + LogParam(p.transform_to_root_target, l); + l->append(", "); + LogParam(p.has_transparent_background, l); + l->append(", "); + LogParam(p.has_occlusion_from_outside_target_surface, l); + l->append(", "); + LogParam(p.filters, l); + l->append(", "); + // TODO(danakj): filter isn't being serialized. + LogParam(p.background_filters, l); + l->append(", "); + + l->append("["); + for (size_t i = 0; i < p.shared_quad_state_list.size(); ++i) { + if (i) + l->append(", "); + LogParam(*p.shared_quad_state_list[i], l); + } + l->append("], ["); + for (size_t i = 0; i < p.quad_list.size(); ++i) { + if (i) + l->append(", "); + const cc::DrawQuad* quad = p.quad_list[i]; + switch (quad->material) { + case cc::DrawQuad::CHECKERBOARD: + LogParam(*cc::CheckerboardDrawQuad::MaterialCast(quad), l); + break; + case cc::DrawQuad::DEBUG_BORDER: + LogParam(*cc::DebugBorderDrawQuad::MaterialCast(quad), l); + break; + case cc::DrawQuad::IO_SURFACE_CONTENT: + LogParam(*cc::IOSurfaceDrawQuad::MaterialCast(quad), l); + break; + case cc::DrawQuad::TEXTURE_CONTENT: + LogParam(*cc::TextureDrawQuad::MaterialCast(quad), l); + break; + case cc::DrawQuad::RENDER_PASS: + LogParam(*cc::RenderPassDrawQuad::MaterialCast(quad), l); + break; + case cc::DrawQuad::SOLID_COLOR: + LogParam(*cc::SolidColorDrawQuad::MaterialCast(quad), l); + break; + case cc::DrawQuad::TILED_CONTENT: + LogParam(*cc::TileDrawQuad::MaterialCast(quad), l); + break; + case cc::DrawQuad::STREAM_VIDEO_CONTENT: + LogParam(*cc::StreamVideoDrawQuad::MaterialCast(quad), l); + break; + case cc::DrawQuad::YUV_VIDEO_CONTENT: + LogParam(*cc::YUVVideoDrawQuad::MaterialCast(quad), l); + break; + case cc::DrawQuad::INVALID: + break; + } + } + l->append("])"); +} + } // namespace IPC diff --git a/content/common/cc_messages.h b/content/common/cc_messages.h index 4e5d337..b896a2f 100644 --- a/content/common/cc_messages.h +++ b/content/common/cc_messages.h @@ -4,6 +4,19 @@ // // IPC Messages sent between compositor instances. +#include "cc/checkerboard_draw_quad.h" +#include "cc/debug_border_draw_quad.h" +#include "cc/draw_quad.h" +#include "cc/io_surface_draw_quad.h" +#include "cc/render_pass.h" +#include "cc/render_pass_draw_quad.h" +#include "cc/shared_quad_state.h" +#include "cc/solid_color_draw_quad.h" +#include "cc/stream_video_draw_quad.h" +#include "cc/texture_draw_quad.h" +#include "cc/tile_draw_quad.h" +#include "cc/video_layer_impl.h" +#include "cc/yuv_video_draw_quad.h" #include "content/common/content_export.h" #include "ipc/ipc_message_macros.h" #include "third_party/WebKit/Source/Platform/chromium/public/WebFilterOperation.h" @@ -51,6 +64,14 @@ struct ParamTraits<WebKit::WebTransformationMatrix> { static void Log(const param_type& p, std::string* l); }; +template <> +struct CONTENT_EXPORT ParamTraits<cc::RenderPass> { + typedef cc::RenderPass param_type; + static void Write(Message* m, const param_type& p); + static bool Read(const Message* m, PickleIterator* iter, param_type* r); + static void Log(const param_type& p, std::string* l); +}; + } // namespace IPC #endif // CONTENT_COMMON_CC_MESSAGES_H_ @@ -61,4 +82,102 @@ struct ParamTraits<WebKit::WebTransformationMatrix> { #undef IPC_MESSAGE_EXPORT #define IPC_MESSAGE_EXPORT CONTENT_EXPORT +IPC_ENUM_TRAITS(cc::DrawQuad::Material) +IPC_ENUM_TRAITS(cc::IOSurfaceDrawQuad::Orientation) IPC_ENUM_TRAITS(WebKit::WebFilterOperation::FilterType) + +IPC_STRUCT_TRAITS_BEGIN(cc::RenderPass::Id) + IPC_STRUCT_TRAITS_MEMBER(layer_id) + IPC_STRUCT_TRAITS_MEMBER(index) +IPC_STRUCT_TRAITS_END() + +IPC_STRUCT_TRAITS_BEGIN(cc::VideoLayerImpl::FramePlane) + IPC_STRUCT_TRAITS_MEMBER(resourceId) + IPC_STRUCT_TRAITS_MEMBER(size) + IPC_STRUCT_TRAITS_MEMBER(format) +IPC_STRUCT_TRAITS_END() + +IPC_STRUCT_TRAITS_BEGIN(cc::DrawQuad) + IPC_STRUCT_TRAITS_MEMBER(material) + IPC_STRUCT_TRAITS_MEMBER(rect) + IPC_STRUCT_TRAITS_MEMBER(opaque_rect) + IPC_STRUCT_TRAITS_MEMBER(visible_rect) + IPC_STRUCT_TRAITS_MEMBER(needs_blending) +IPC_STRUCT_TRAITS_END() + +IPC_STRUCT_TRAITS_BEGIN(cc::CheckerboardDrawQuad) + IPC_STRUCT_TRAITS_PARENT(cc::DrawQuad) + IPC_STRUCT_TRAITS_MEMBER(color) +IPC_STRUCT_TRAITS_END() + +IPC_STRUCT_TRAITS_BEGIN(cc::DebugBorderDrawQuad) + IPC_STRUCT_TRAITS_PARENT(cc::DrawQuad) + IPC_STRUCT_TRAITS_MEMBER(color) + IPC_STRUCT_TRAITS_MEMBER(width) +IPC_STRUCT_TRAITS_END() + +IPC_STRUCT_TRAITS_BEGIN(cc::IOSurfaceDrawQuad) + IPC_STRUCT_TRAITS_PARENT(cc::DrawQuad) + IPC_STRUCT_TRAITS_MEMBER(io_surface_size) + IPC_STRUCT_TRAITS_MEMBER(io_surface_texture_id) + IPC_STRUCT_TRAITS_MEMBER(orientation) +IPC_STRUCT_TRAITS_END() + +IPC_STRUCT_TRAITS_BEGIN(cc::RenderPassDrawQuad) + IPC_STRUCT_TRAITS_PARENT(cc::DrawQuad) + IPC_STRUCT_TRAITS_MEMBER(is_replica) + IPC_STRUCT_TRAITS_MEMBER(mask_resource_id) + IPC_STRUCT_TRAITS_MEMBER(contents_changed_since_last_frame) + IPC_STRUCT_TRAITS_MEMBER(mask_tex_coord_scale_x) + IPC_STRUCT_TRAITS_MEMBER(mask_tex_coord_scale_y) + IPC_STRUCT_TRAITS_MEMBER(mask_tex_coord_offset_x) + IPC_STRUCT_TRAITS_MEMBER(mask_tex_coord_offset_y) +IPC_STRUCT_TRAITS_END() + +IPC_STRUCT_TRAITS_BEGIN(cc::SolidColorDrawQuad) + IPC_STRUCT_TRAITS_PARENT(cc::DrawQuad) + IPC_STRUCT_TRAITS_MEMBER(color) +IPC_STRUCT_TRAITS_END() + +IPC_STRUCT_TRAITS_BEGIN(cc::StreamVideoDrawQuad) + IPC_STRUCT_TRAITS_PARENT(cc::DrawQuad) + IPC_STRUCT_TRAITS_MEMBER(texture_id) + IPC_STRUCT_TRAITS_MEMBER(matrix) +IPC_STRUCT_TRAITS_END() + +IPC_STRUCT_TRAITS_BEGIN(cc::TextureDrawQuad) + IPC_STRUCT_TRAITS_PARENT(cc::DrawQuad) + IPC_STRUCT_TRAITS_MEMBER(resource_id) + IPC_STRUCT_TRAITS_MEMBER(premultiplied_alpha) + IPC_STRUCT_TRAITS_MEMBER(uv_rect) + IPC_STRUCT_TRAITS_MEMBER(flipped) +IPC_STRUCT_TRAITS_END() + +IPC_STRUCT_TRAITS_BEGIN(cc::TileDrawQuad) + IPC_STRUCT_TRAITS_PARENT(cc::DrawQuad) + IPC_STRUCT_TRAITS_MEMBER(resource_id) + IPC_STRUCT_TRAITS_MEMBER(tex_coord_rect) + IPC_STRUCT_TRAITS_MEMBER(texture_size) + IPC_STRUCT_TRAITS_MEMBER(swizzle_contents) + IPC_STRUCT_TRAITS_MEMBER(left_edge_aa) + IPC_STRUCT_TRAITS_MEMBER(top_edge_aa) + IPC_STRUCT_TRAITS_MEMBER(right_edge_aa) + IPC_STRUCT_TRAITS_MEMBER(bottom_edge_aa) +IPC_STRUCT_TRAITS_END() + +IPC_STRUCT_TRAITS_BEGIN(cc::YUVVideoDrawQuad) + IPC_STRUCT_TRAITS_PARENT(cc::DrawQuad) + IPC_STRUCT_TRAITS_MEMBER(tex_scale) + IPC_STRUCT_TRAITS_MEMBER(y_plane) + IPC_STRUCT_TRAITS_MEMBER(u_plane) + IPC_STRUCT_TRAITS_MEMBER(v_plane) +IPC_STRUCT_TRAITS_END() + +IPC_STRUCT_TRAITS_BEGIN(cc::SharedQuadState) + IPC_STRUCT_TRAITS_MEMBER(content_to_target_transform) + IPC_STRUCT_TRAITS_MEMBER(visible_content_rect) + IPC_STRUCT_TRAITS_MEMBER(clipped_rect_in_target) + IPC_STRUCT_TRAITS_MEMBER(clip_rect) + IPC_STRUCT_TRAITS_MEMBER(is_clipped) + IPC_STRUCT_TRAITS_MEMBER(opacity) +IPC_STRUCT_TRAITS_END() diff --git a/content/common/cc_messages_unittest.cc b/content/common/cc_messages_unittest.cc new file mode 100644 index 0000000..7225b68 --- /dev/null +++ b/content/common/cc_messages_unittest.cc @@ -0,0 +1,431 @@ +// Copyright (c) 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. + +#include "content/common/cc_messages.h" + +#include <string.h> + +#include "ipc/ipc_message.h" +#include "testing/gtest/include/gtest/gtest.h" + +using cc::CheckerboardDrawQuad; +using cc::DebugBorderDrawQuad; +using cc::DrawQuad; +using cc::IOSurfaceDrawQuad; +using cc::RenderPass; +using cc::RenderPassDrawQuad; +using cc::ResourceProvider; +using cc::SharedQuadState; +using cc::SolidColorDrawQuad; +using cc::TextureDrawQuad; +using cc::TileDrawQuad; +using cc::StreamVideoDrawQuad; +using cc::VideoLayerImpl; +using cc::YUVVideoDrawQuad; +using WebKit::WebFilterOperation; +using WebKit::WebFilterOperations; +using WebKit::WebTransformationMatrix; + +class CCMessagesTest : public testing::Test { + protected: + void Compare(const RenderPass* a, const RenderPass* b) { + EXPECT_EQ(a->id, b->id); + EXPECT_EQ(a->output_rect.ToString(), b->output_rect.ToString()); + EXPECT_EQ(a->damage_rect.ToString(), b->damage_rect.ToString()); + EXPECT_EQ(a->transform_to_root_target, b->transform_to_root_target); + EXPECT_EQ(a->has_transparent_background, b->has_transparent_background); + EXPECT_EQ(a->has_occlusion_from_outside_target_surface, + b->has_occlusion_from_outside_target_surface); + EXPECT_EQ(a->filters, b->filters); + EXPECT_EQ(a->filter, b->filter); + EXPECT_EQ(a->background_filters, b->background_filters); + } + + void Compare(const SharedQuadState* a, const SharedQuadState* b) { + EXPECT_EQ(a->content_to_target_transform, b->content_to_target_transform); + EXPECT_EQ(a->visible_content_rect, b->visible_content_rect); + EXPECT_EQ(a->clipped_rect_in_target, b->clipped_rect_in_target); + EXPECT_EQ(a->clip_rect, b->clip_rect); + EXPECT_EQ(a->is_clipped, b->is_clipped); + EXPECT_EQ(a->opacity, b->opacity); + } + + void Compare(const DrawQuad* a, const DrawQuad* b) { + ASSERT_NE(DrawQuad::INVALID, a->material); + ASSERT_EQ(a->material, b->material); + EXPECT_EQ(a->rect.ToString(), b->rect.ToString()); + EXPECT_EQ(a->opaque_rect.ToString(), b->opaque_rect.ToString()); + EXPECT_EQ(a->visible_rect.ToString(), b->visible_rect.ToString()); + EXPECT_EQ(a->needs_blending, b->needs_blending); + + Compare(a->shared_quad_state, b->shared_quad_state); + + switch (a->material) { + case DrawQuad::CHECKERBOARD: + Compare(CheckerboardDrawQuad::MaterialCast(a), + CheckerboardDrawQuad::MaterialCast(b)); + break; + case DrawQuad::DEBUG_BORDER: + Compare(DebugBorderDrawQuad::MaterialCast(a), + DebugBorderDrawQuad::MaterialCast(b)); + break; + case DrawQuad::IO_SURFACE_CONTENT: + Compare(IOSurfaceDrawQuad::MaterialCast(a), + IOSurfaceDrawQuad::MaterialCast(b)); + break; + case DrawQuad::RENDER_PASS: + Compare(RenderPassDrawQuad::MaterialCast(a), + RenderPassDrawQuad::MaterialCast(b)); + break; + case DrawQuad::TEXTURE_CONTENT: + Compare(TextureDrawQuad::MaterialCast(a), + TextureDrawQuad::MaterialCast(b)); + break; + case DrawQuad::TILED_CONTENT: + Compare(TileDrawQuad::MaterialCast(a), + TileDrawQuad::MaterialCast(b)); + break; + case DrawQuad::SOLID_COLOR: + Compare(SolidColorDrawQuad::MaterialCast(a), + SolidColorDrawQuad::MaterialCast(b)); + break; + case DrawQuad::STREAM_VIDEO_CONTENT: + Compare(StreamVideoDrawQuad::MaterialCast(a), + StreamVideoDrawQuad::MaterialCast(b)); + break; + case DrawQuad::YUV_VIDEO_CONTENT: + Compare(YUVVideoDrawQuad::MaterialCast(a), + YUVVideoDrawQuad::MaterialCast(b)); + break; + case DrawQuad::INVALID: + break; + } + } + + void Compare(const CheckerboardDrawQuad* a, const CheckerboardDrawQuad* b) { + EXPECT_EQ(a->color, b->color); + } + + void Compare(const DebugBorderDrawQuad* a, const DebugBorderDrawQuad* b) { + EXPECT_EQ(a->color, b->color); + EXPECT_EQ(a->width, b->width); + } + + void Compare(const IOSurfaceDrawQuad* a, const IOSurfaceDrawQuad* b) { + EXPECT_EQ(a->io_surface_size.ToString(), b->io_surface_size.ToString()); + EXPECT_EQ(a->io_surface_texture_id, b->io_surface_texture_id); + EXPECT_EQ(a->orientation, b->orientation); + } + + void Compare(const RenderPassDrawQuad* a, const RenderPassDrawQuad* b) { + EXPECT_EQ(a->is_replica, b->is_replica); + EXPECT_EQ(a->mask_resource_id, b->mask_resource_id); + EXPECT_EQ(a->contents_changed_since_last_frame, + b->contents_changed_since_last_frame); + EXPECT_EQ(a->mask_tex_coord_scale_x, b->mask_tex_coord_scale_x); + EXPECT_EQ(a->mask_tex_coord_scale_y, b->mask_tex_coord_scale_y); + EXPECT_EQ(a->mask_tex_coord_offset_x, b->mask_tex_coord_offset_x); + EXPECT_EQ(a->mask_tex_coord_offset_y, b->mask_tex_coord_offset_y); + } + + void Compare(const SolidColorDrawQuad* a, const SolidColorDrawQuad* b) { + EXPECT_EQ(a->color, b->color); + } + + void Compare(const StreamVideoDrawQuad* a, const StreamVideoDrawQuad* b) { + EXPECT_EQ(a->texture_id, b->texture_id); + EXPECT_EQ(a->matrix, b->matrix); + } + + void Compare(const TextureDrawQuad* a, const TextureDrawQuad* b) { + EXPECT_EQ(a->resource_id, b->resource_id); + EXPECT_EQ(a->premultiplied_alpha, b->premultiplied_alpha); + EXPECT_EQ(a->uv_rect, b->uv_rect); + EXPECT_EQ(a->flipped, b->flipped); + } + + void Compare(const TileDrawQuad* a, const TileDrawQuad* b) { + EXPECT_EQ(a->resource_id, b->resource_id); + EXPECT_EQ(a->tex_coord_rect, b->tex_coord_rect); + EXPECT_EQ(a->texture_size, b->texture_size); + EXPECT_EQ(a->swizzle_contents, b->swizzle_contents); + EXPECT_EQ(a->left_edge_aa, b->left_edge_aa); + EXPECT_EQ(a->top_edge_aa, b->top_edge_aa); + EXPECT_EQ(a->right_edge_aa, b->right_edge_aa); + EXPECT_EQ(a->bottom_edge_aa, b->bottom_edge_aa); + } + + void Compare(const YUVVideoDrawQuad* a, const YUVVideoDrawQuad* b) { + EXPECT_EQ(a->tex_scale, b->tex_scale); + EXPECT_EQ(a->y_plane.resourceId, b->y_plane.resourceId); + EXPECT_EQ(a->y_plane.size.ToString(), b->y_plane.size.ToString()); + EXPECT_EQ(a->y_plane.format, b->y_plane.format); + EXPECT_EQ(a->u_plane.resourceId, b->u_plane.resourceId); + EXPECT_EQ(a->u_plane.size.ToString(), b->u_plane.size.ToString()); + EXPECT_EQ(a->u_plane.format, b->u_plane.format); + EXPECT_EQ(a->v_plane.resourceId, b->v_plane.resourceId); + EXPECT_EQ(a->v_plane.size.ToString(), b->v_plane.size.ToString()); + EXPECT_EQ(a->v_plane.format, b->v_plane.format); + } +}; + +TEST_F(CCMessagesTest, AllQuads) { + IPC::Message msg(1, 2, IPC::Message::PRIORITY_NORMAL); + + WebTransformationMatrix arbitrary_matrix; + arbitrary_matrix.scale(3); + arbitrary_matrix.translate(-5, 20); + arbitrary_matrix.rotate(15); + gfx::Rect arbitrary_rect1(-5, 9, 3, 15); + gfx::Rect arbitrary_rect2(40, 23, 11, 7); + gfx::Rect arbitrary_rect3(7, -53, 22, 19); + gfx::Size arbitrary_size1(15, 19); + gfx::Size arbitrary_size2(3, 99); + gfx::Size arbitrary_size3(75, 1281); + gfx::RectF arbitrary_rectf1(4.2f, -922.1f, 15.6f, 29.5f); + gfx::SizeF arbitrary_sizef1(15.2f, 104.6f); + float arbitrary_float1 = 0.7f; + float arbitrary_float2 = 0.3f; + float arbitrary_float3 = 0.9f; + float arbitrary_float4 = 0.1f; + bool arbitrary_bool1 = true; + bool arbitrary_bool2 = false; + int arbitrary_int = 5; + SkColor arbitrary_color = SkColorSetARGB(25, 36, 47, 58); + IOSurfaceDrawQuad::Orientation arbitrary_orientation = + IOSurfaceDrawQuad::UNFLIPPED; + RenderPass::Id arbitrary_id(10, 14); + ResourceProvider::ResourceId arbitrary_resourceid = 55; + + VideoLayerImpl::FramePlane arbitrary_plane1; + arbitrary_plane1.resourceId = arbitrary_resourceid; + arbitrary_plane1.size = arbitrary_size1; + arbitrary_plane1.format = arbitrary_int; + + VideoLayerImpl::FramePlane arbitrary_plane2; + arbitrary_plane2.resourceId = arbitrary_resourceid; + arbitrary_plane2.size = arbitrary_size2; + arbitrary_plane2.format = arbitrary_int; + + VideoLayerImpl::FramePlane arbitrary_plane3; + arbitrary_plane3.resourceId = arbitrary_resourceid; + arbitrary_plane3.size = arbitrary_size3; + arbitrary_plane3.format = arbitrary_int; + + WebFilterOperations arbitrary_filters1; + arbitrary_filters1.append(WebFilterOperation::createGrayscaleFilter( + arbitrary_float1)); + + WebFilterOperations arbitrary_filters2; + arbitrary_filters2.append(WebFilterOperation::createBrightnessFilter( + arbitrary_float2)); + + scoped_ptr<SharedQuadState> shared_state1_in = SharedQuadState::Create(); + shared_state1_in->SetAll(arbitrary_matrix, + arbitrary_rect1, + arbitrary_rect2, + arbitrary_rect3, + arbitrary_bool1, + arbitrary_float1); + scoped_ptr<SharedQuadState> shared_state1_cmp = shared_state1_in->Copy(); + + scoped_ptr<CheckerboardDrawQuad> checkerboard_in = + CheckerboardDrawQuad::Create(); + checkerboard_in->SetAll(shared_state1_in.get(), + arbitrary_rect1, + arbitrary_rect2, + arbitrary_rect3, + arbitrary_bool1, + arbitrary_color); + scoped_ptr<DrawQuad> checkerboard_cmp = checkerboard_in->Copy( + checkerboard_in->shared_quad_state); + + scoped_ptr<DebugBorderDrawQuad> debugborder_in = + DebugBorderDrawQuad::Create(); + debugborder_in->SetAll(shared_state1_in.get(), + arbitrary_rect3, + arbitrary_rect1, + arbitrary_rect2, + arbitrary_bool1, + arbitrary_color, + arbitrary_int); + scoped_ptr<DrawQuad> debugborder_cmp = debugborder_in->Copy( + debugborder_in->shared_quad_state); + + scoped_ptr<IOSurfaceDrawQuad> iosurface_in = + IOSurfaceDrawQuad::Create(); + iosurface_in->SetAll(shared_state1_in.get(), + arbitrary_rect2, + arbitrary_rect3, + arbitrary_rect1, + arbitrary_bool1, + arbitrary_size1, + arbitrary_int, + arbitrary_orientation); + scoped_ptr<DrawQuad> iosurface_cmp = iosurface_in->Copy( + iosurface_in->shared_quad_state); + + scoped_ptr<RenderPassDrawQuad> renderpass_in = + RenderPassDrawQuad::Create(); + renderpass_in->SetAll(shared_state1_in.get(), + arbitrary_rect1, + arbitrary_rect2, + arbitrary_rect3, + arbitrary_bool1, + arbitrary_id, + arbitrary_bool2, + arbitrary_resourceid, + arbitrary_rect1, + arbitrary_float1, + arbitrary_float2, + arbitrary_float3, + arbitrary_float4); + scoped_ptr<RenderPassDrawQuad> renderpass_cmp = renderpass_in->Copy( + renderpass_in->shared_quad_state, renderpass_in->render_pass_id); + + scoped_ptr<SharedQuadState> shared_state2_in = SharedQuadState::Create(); + shared_state2_in->SetAll(arbitrary_matrix, + arbitrary_rect2, + arbitrary_rect3, + arbitrary_rect1, + arbitrary_bool1, + arbitrary_float2); + scoped_ptr<SharedQuadState> shared_state2_cmp = shared_state2_in->Copy(); + + scoped_ptr<SharedQuadState> shared_state3_in = SharedQuadState::Create(); + shared_state3_in->SetAll(arbitrary_matrix, + arbitrary_rect3, + arbitrary_rect1, + arbitrary_rect2, + arbitrary_bool1, + arbitrary_float3); + scoped_ptr<SharedQuadState> shared_state3_cmp = shared_state3_in->Copy(); + + scoped_ptr<SolidColorDrawQuad> solidcolor_in = + SolidColorDrawQuad::Create(); + solidcolor_in->SetAll(shared_state1_in.get(), + arbitrary_rect3, + arbitrary_rect1, + arbitrary_rect2, + arbitrary_bool1, + arbitrary_color); + scoped_ptr<DrawQuad> solidcolor_cmp = solidcolor_in->Copy( + solidcolor_in->shared_quad_state); + + scoped_ptr<StreamVideoDrawQuad> streamvideo_in = + StreamVideoDrawQuad::Create(); + streamvideo_in->SetAll(shared_state1_in.get(), + arbitrary_rect2, + arbitrary_rect3, + arbitrary_rect1, + arbitrary_bool1, + arbitrary_int, + arbitrary_matrix); + scoped_ptr<DrawQuad> streamvideo_cmp = streamvideo_in->Copy( + streamvideo_in->shared_quad_state); + + scoped_ptr<YUVVideoDrawQuad> yuvvideo_in = + YUVVideoDrawQuad::Create(); + yuvvideo_in->SetAll(shared_state1_in.get(), + arbitrary_rect1, + arbitrary_rect2, + arbitrary_rect3, + arbitrary_bool1, + arbitrary_sizef1, + arbitrary_plane1, + arbitrary_plane2, + arbitrary_plane3); + scoped_ptr<DrawQuad> yuvvideo_cmp = yuvvideo_in->Copy( + yuvvideo_in->shared_quad_state); + + scoped_ptr<RenderPass> pass_in = RenderPass::Create(); + pass_in->SetAll(arbitrary_id, + arbitrary_rect1, + arbitrary_rectf1, + arbitrary_matrix, + arbitrary_bool1, + arbitrary_bool2, + arbitrary_filters1, + NULL, // TODO(danakj): filter is not serialized. + arbitrary_filters2); + + pass_in->shared_quad_state_list.append(shared_state1_in.Pass()); + pass_in->quad_list.append(checkerboard_in.PassAs<DrawQuad>()); + pass_in->quad_list.append(debugborder_in.PassAs<DrawQuad>()); + pass_in->quad_list.append(iosurface_in.PassAs<DrawQuad>()); + pass_in->quad_list.append(renderpass_in.PassAs<DrawQuad>()); + pass_in->shared_quad_state_list.append(shared_state2_in.Pass()); + pass_in->shared_quad_state_list.append(shared_state3_in.Pass()); + pass_in->quad_list.append(solidcolor_in.PassAs<DrawQuad>()); + pass_in->quad_list.append(streamvideo_in.PassAs<DrawQuad>()); + pass_in->quad_list.append(yuvvideo_in.PassAs<DrawQuad>()); + + scoped_ptr<RenderPass> pass_cmp = RenderPass::Create(); + pass_cmp->SetAll(arbitrary_id, + arbitrary_rect1, + arbitrary_rectf1, + arbitrary_matrix, + arbitrary_bool1, + arbitrary_bool2, + arbitrary_filters1, + NULL, // TODO(danakj): filter is not serialized. + arbitrary_filters2); + + pass_cmp->shared_quad_state_list.append(shared_state1_cmp.Pass()); + pass_cmp->quad_list.append(checkerboard_cmp.PassAs<DrawQuad>()); + pass_cmp->quad_list.append(debugborder_cmp.PassAs<DrawQuad>()); + pass_cmp->quad_list.append(iosurface_cmp.PassAs<DrawQuad>()); + pass_cmp->quad_list.append(renderpass_cmp.PassAs<DrawQuad>()); + pass_cmp->shared_quad_state_list.append(shared_state2_cmp.Pass()); + pass_cmp->shared_quad_state_list.append(shared_state3_cmp.Pass()); + pass_cmp->quad_list.append(solidcolor_cmp.PassAs<DrawQuad>()); + pass_cmp->quad_list.append(streamvideo_cmp.PassAs<DrawQuad>()); + pass_cmp->quad_list.append(yuvvideo_cmp.PassAs<DrawQuad>()); + + // Make sure the in and cmp RenderPasses match. + Compare(pass_cmp.get(), pass_in.get()); + ASSERT_EQ(3u, pass_in->shared_quad_state_list.size()); + ASSERT_EQ(7u, pass_in->quad_list.size()); + for (size_t i = 0; i < 3; ++i) { + Compare(pass_cmp->shared_quad_state_list[i], + pass_in->shared_quad_state_list[i]); + } + for (size_t i = 0; i < 7; ++i) + Compare(pass_cmp->quad_list[i], pass_in->quad_list[i]); + for (size_t i = 1; i < 7; ++i) { + bool same_shared_quad_state_cmp = + pass_cmp->quad_list[i]->shared_quad_state == + pass_cmp->quad_list[i - 1]->shared_quad_state; + bool same_shared_quad_state_in = + pass_in->quad_list[i]->shared_quad_state == + pass_in->quad_list[i - 1]->shared_quad_state; + EXPECT_EQ(same_shared_quad_state_cmp, same_shared_quad_state_in); + } + + IPC::ParamTraits<RenderPass>::Write(&msg, *pass_in); + + scoped_ptr<RenderPass> pass_out = RenderPass::Create(); + PickleIterator iter(msg); + EXPECT_TRUE(IPC::ParamTraits<RenderPass>::Read(&msg, &iter, pass_out.get())); + + // Make sure the out and cmp RenderPasses match. + Compare(pass_cmp.get(), pass_out.get()); + ASSERT_EQ(3u, pass_out->shared_quad_state_list.size()); + ASSERT_EQ(7u, pass_out->quad_list.size()); + for (size_t i = 0; i < 3; ++i) { + Compare(pass_cmp->shared_quad_state_list[i], + pass_out->shared_quad_state_list[i]); + } + for (size_t i = 0; i < 7; ++i) + Compare(pass_cmp->quad_list[i], pass_out->quad_list[i]); + for (size_t i = 1; i < 7; ++i) { + bool same_shared_quad_state_cmp = + pass_cmp->quad_list[i]->shared_quad_state == + pass_cmp->quad_list[i - 1]->shared_quad_state; + bool same_shared_quad_state_out = + pass_out->quad_list[i]->shared_quad_state == + pass_out->quad_list[i - 1]->shared_quad_state; + EXPECT_EQ(same_shared_quad_state_cmp, same_shared_quad_state_out); + } +} diff --git a/content/content_common.gypi b/content/content_common.gypi index 8d46684..40427d5 100644 --- a/content/content_common.gypi +++ b/content/content_common.gypi @@ -409,6 +409,7 @@ ], }, { # OS!="ios" 'dependencies': [ + '../cc/cc.gyp:cc', '../gpu/gpu.gyp:gles2_implementation', '../gpu/gpu.gyp:gpu_ipc', '../ipc/ipc.gyp:ipc', diff --git a/content/content_tests.gypi b/content/content_tests.gypi index 1ce3c41..4a5438b 100644 --- a/content/content_tests.gypi +++ b/content/content_tests.gypi @@ -339,6 +339,7 @@ 'browser/web_contents/web_drag_source_mac_unittest.mm', 'browser/webui/web_ui_message_handler_unittest.cc', 'common/android/address_parser_unittest.cc', + 'common/cc_messages_unittest.cc', 'common/mac/attributed_string_coder_unittest.mm', 'common/mac/font_descriptor_unittest.mm', 'common/gpu/gpu_info_unittest.cc', diff --git a/content/public/common/common_param_traits.cc b/content/public/common/common_param_traits.cc index 7a0200a..2b37363 100644 --- a/content/public/common/common_param_traits.cc +++ b/content/public/common/common_param_traits.cc @@ -151,6 +151,27 @@ void ParamTraits<gfx::Size>::Log(const gfx::Size& p, std::string* l) { l->append(base::StringPrintf("(%d, %d)", p.width(), p.height())); } +void ParamTraits<gfx::SizeF>::Write(Message* m, const gfx::SizeF& p) { + ParamTraits<float>::Write(m, p.width()); + ParamTraits<float>::Write(m, p.height()); +} + +bool ParamTraits<gfx::SizeF>::Read(const Message* m, + PickleIterator* iter, + gfx::SizeF* p) { + float w, h; + if (!ParamTraits<float>::Read(m, iter, &w) || + !ParamTraits<float>::Read(m, iter, &h)) + return false; + p->set_width(w); + p->set_height(h); + return true; +} + +void ParamTraits<gfx::SizeF>::Log(const gfx::SizeF& p, std::string* l) { + l->append(base::StringPrintf("(%f, %f)", p.width(), p.height())); +} + void ParamTraits<gfx::Vector2d>::Write(Message* m, const gfx::Vector2d& v) { m->WriteInt(v.x()); m->WriteInt(v.y()); diff --git a/content/public/common/common_param_traits.h b/content/public/common/common_param_traits.h index ce5a668..208af3f 100644 --- a/content/public/common/common_param_traits.h +++ b/content/public/common/common_param_traits.h @@ -83,6 +83,14 @@ struct CONTENT_EXPORT ParamTraits<gfx::Size> { }; template <> +struct CONTENT_EXPORT ParamTraits<gfx::SizeF> { + typedef gfx::SizeF param_type; + static void Write(Message* m, const param_type& p); + static bool Read(const Message* m, PickleIterator* iter, param_type* r); + static void Log(const param_type& p, std::string* l); +}; + +template <> struct CONTENT_EXPORT ParamTraits<gfx::Vector2d> { typedef gfx::Vector2d param_type; static void Write(Message* m, const param_type& p); |