| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "cc/gl_renderer.h" | |
| 6 | |
| 7 #include "cc/draw_quad.h" | |
| 8 #include "cc/test/pixel_test.h" | |
| 9 | |
| 10 namespace cc { | |
| 11 namespace { | |
| 12 | |
| 13 class GLRendererPixelTest : public PixelTest {}; | |
| 14 | |
| 15 scoped_ptr<RenderPass> CreateTestRootRenderPass(RenderPass::Id id, | |
| 16 gfx::Rect rect) { | |
| 17 scoped_ptr<RenderPass> pass = RenderPass::Create(); | |
| 18 const gfx::Rect output_rect = rect; | |
| 19 const gfx::RectF damage_rect = rect; | |
| 20 const gfx::Transform transform_to_root_target; | |
| 21 pass->SetNew(id, output_rect, damage_rect, transform_to_root_target); | |
| 22 return pass.Pass(); | |
| 23 } | |
| 24 | |
| 25 scoped_ptr<RenderPass> CreateTestRenderPass( | |
| 26 RenderPass::Id id, | |
| 27 gfx::Rect rect, | |
| 28 const gfx::Transform& transform_to_root_target) { | |
| 29 scoped_ptr<RenderPass> pass = RenderPass::Create(); | |
| 30 const gfx::Rect output_rect = rect; | |
| 31 const gfx::RectF damage_rect = rect; | |
| 32 pass->SetNew(id, output_rect, damage_rect, transform_to_root_target); | |
| 33 return pass.Pass(); | |
| 34 } | |
| 35 | |
| 36 scoped_ptr<SharedQuadState> CreateTestSharedQuadState( | |
| 37 gfx::Transform content_to_target_transform, gfx::Rect rect) { | |
| 38 const gfx::Size content_bounds = rect.size(); | |
| 39 const gfx::Rect visible_content_rect = rect; | |
| 40 const gfx::Rect clip_rect = rect; | |
| 41 const bool is_clipped = false; | |
| 42 const float opacity = 1.0f; | |
| 43 scoped_ptr<SharedQuadState> shared_state = SharedQuadState::Create(); | |
| 44 shared_state->SetAll(content_to_target_transform, | |
| 45 content_bounds, | |
| 46 visible_content_rect, | |
| 47 clip_rect, | |
| 48 is_clipped, | |
| 49 opacity); | |
| 50 return shared_state.Pass(); | |
| 51 } | |
| 52 | |
| 53 scoped_ptr<DrawQuad> CreateTestRenderPassDrawQuad( | |
| 54 SharedQuadState* shared_state, gfx::Rect rect, RenderPass::Id pass_id) { | |
| 55 scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::Create(); | |
| 56 quad->SetNew(shared_state, | |
| 57 rect, | |
| 58 pass_id, | |
| 59 false, // is_replica | |
| 60 0, // mask_resource_id | |
| 61 rect, // contents_changed_since_last_frame | |
| 62 gfx::RectF(), // mask_uv_rect | |
| 63 WebKit::WebFilterOperations(), // foreground filters | |
| 64 skia::RefPtr<SkImageFilter>(), // foreground filter | |
| 65 WebKit::WebFilterOperations()); // background filters | |
| 66 | |
| 67 return quad.PassAs<DrawQuad>(); | |
| 68 } | |
| 69 | |
| 70 | |
| 71 #if !defined(OS_ANDROID) | |
| 72 TEST_F(GLRendererPixelTest, simpleGreenRect) { | |
| 73 gfx::Rect rect(device_viewport_size_); | |
| 74 | |
| 75 RenderPass::Id id(1, 1); | |
| 76 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | |
| 77 | |
| 78 gfx::Transform content_to_target_transform; | |
| 79 scoped_ptr<SharedQuadState> shared_state = | |
| 80 CreateTestSharedQuadState(content_to_target_transform, rect); | |
| 81 | |
| 82 scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create(); | |
| 83 color_quad->SetNew(shared_state.get(), rect, SK_ColorGREEN); | |
| 84 | |
| 85 pass->quad_list.push_back(color_quad.PassAs<DrawQuad>()); | |
| 86 | |
| 87 RenderPassList pass_list; | |
| 88 pass_list.push_back(pass.Pass()); | |
| 89 | |
| 90 renderer_->DrawFrame(pass_list); | |
| 91 | |
| 92 EXPECT_TRUE(PixelsMatchReference( | |
| 93 base::FilePath(FILE_PATH_LITERAL("green.png")))); | |
| 94 } | |
| 95 | |
| 96 TEST_F(GLRendererPixelTest, RenderPassChangesSize) { | |
| 97 gfx::Rect viewport_rect(device_viewport_size_); | |
| 98 | |
| 99 RenderPass::Id root_pass_id(1, 1); | |
| 100 scoped_ptr<RenderPass> root_pass = | |
| 101 CreateTestRootRenderPass(root_pass_id, viewport_rect); | |
| 102 | |
| 103 RenderPass::Id child_pass_id(2, 2); | |
| 104 gfx::Rect pass_rect(device_viewport_size_); | |
| 105 gfx::Transform transform_to_root; | |
| 106 scoped_ptr<RenderPass> child_pass = | |
| 107 CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root); | |
| 108 | |
| 109 gfx::Transform content_to_target_transform; | |
| 110 scoped_ptr<SharedQuadState> shared_state = | |
| 111 CreateTestSharedQuadState(content_to_target_transform, viewport_rect); | |
| 112 | |
| 113 scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create(); | |
| 114 blue->SetNew(shared_state.get(), | |
| 115 gfx::Rect(0, | |
| 116 0, | |
| 117 device_viewport_size_.width() / 2, | |
| 118 device_viewport_size_.height()), | |
| 119 SK_ColorBLUE); | |
| 120 scoped_ptr<SolidColorDrawQuad> yellow = SolidColorDrawQuad::Create(); | |
| 121 yellow->SetNew(shared_state.get(), | |
| 122 gfx::Rect(device_viewport_size_.width() / 2, | |
| 123 0, | |
| 124 device_viewport_size_.width() / 2, | |
| 125 device_viewport_size_.height()), | |
| 126 SK_ColorYELLOW); | |
| 127 | |
| 128 child_pass->quad_list.push_back(blue.PassAs<DrawQuad>()); | |
| 129 child_pass->quad_list.push_back(yellow.PassAs<DrawQuad>()); | |
| 130 | |
| 131 scoped_ptr<SharedQuadState> pass_shared_state = | |
| 132 CreateTestSharedQuadState(gfx::Transform(), pass_rect); | |
| 133 root_pass->quad_list.push_back( | |
| 134 CreateTestRenderPassDrawQuad(pass_shared_state.get(), | |
| 135 pass_rect, | |
| 136 child_pass_id)); | |
| 137 | |
| 138 RenderPassList pass_list; | |
| 139 pass_list.push_back(child_pass.Pass()); | |
| 140 pass_list.push_back(root_pass.Pass()); | |
| 141 | |
| 142 renderer_->SetEnlargePassTextureAmountForTesting(gfx::Vector2d(50, 75)); | |
| 143 renderer_->DecideRenderPassAllocationsForFrame(pass_list); | |
| 144 renderer_->DrawFrame(pass_list); | |
| 145 | |
| 146 EXPECT_TRUE(PixelsMatchReference( | |
| 147 base::FilePath(FILE_PATH_LITERAL("blue_yellow.png")))); | |
| 148 } | |
| 149 | |
| 150 class GLRendererPixelTestWithBackgroundFilter : public GLRendererPixelTest { | |
| 151 protected: | |
| 152 void DrawFrame() { | |
| 153 gfx::Rect device_viewport_rect(device_viewport_size_); | |
| 154 | |
| 155 RenderPass::Id root_id(1, 1); | |
| 156 scoped_ptr<RenderPass> root_pass = | |
| 157 CreateTestRootRenderPass(root_id, device_viewport_rect); | |
| 158 root_pass->has_transparent_background = false; | |
| 159 | |
| 160 gfx::Transform identity_content_to_target_transform; | |
| 161 | |
| 162 RenderPass::Id filter_pass_id(2, 1); | |
| 163 gfx::Transform transform_to_root; | |
| 164 scoped_ptr<RenderPass> filter_pass = | |
| 165 CreateTestRenderPass(filter_pass_id, | |
| 166 filter_pass_content_rect_, | |
| 167 transform_to_root); | |
| 168 | |
| 169 // A non-visible quad in the filtering render pass. | |
| 170 { | |
| 171 scoped_ptr<SharedQuadState> shared_state = | |
| 172 CreateTestSharedQuadState(identity_content_to_target_transform, | |
| 173 filter_pass_content_rect_); | |
| 174 scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create(); | |
| 175 color_quad->SetNew(shared_state.get(), | |
| 176 filter_pass_content_rect_, | |
| 177 SK_ColorTRANSPARENT); | |
| 178 filter_pass->quad_list.push_back(color_quad.PassAs<DrawQuad>()); | |
| 179 filter_pass->shared_quad_state_list.push_back(shared_state.Pass()); | |
| 180 } | |
| 181 | |
| 182 { | |
| 183 scoped_ptr<SharedQuadState> shared_state = | |
| 184 CreateTestSharedQuadState(filter_pass_to_target_transform_, | |
| 185 filter_pass_content_rect_); | |
| 186 scoped_ptr<RenderPassDrawQuad> filter_pass_quad = | |
| 187 RenderPassDrawQuad::Create(); | |
| 188 filter_pass_quad->SetNew( | |
| 189 shared_state.get(), | |
| 190 filter_pass_content_rect_, | |
| 191 filter_pass_id, | |
| 192 false, // is_replica | |
| 193 0, // mask_resource_id | |
| 194 filter_pass_content_rect_, // contents_changed_since_last_frame | |
| 195 gfx::RectF(), // mask_uv_rect | |
| 196 WebKit::WebFilterOperations(), // filters | |
| 197 skia::RefPtr<SkImageFilter>(), // filter | |
| 198 background_filters_); | |
| 199 root_pass->quad_list.push_back(filter_pass_quad.PassAs<DrawQuad>()); | |
| 200 root_pass->shared_quad_state_list.push_back(shared_state.Pass()); | |
| 201 } | |
| 202 | |
| 203 const int kColumnWidth = device_viewport_rect.width() / 3; | |
| 204 | |
| 205 gfx::Rect left_rect = gfx::Rect(0, 0, kColumnWidth, 20); | |
| 206 for (int i = 0; left_rect.y() < device_viewport_rect.height(); ++i) { | |
| 207 scoped_ptr<SharedQuadState> shared_state = | |
| 208 CreateTestSharedQuadState(identity_content_to_target_transform, | |
| 209 left_rect); | |
| 210 scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create(); | |
| 211 color_quad->SetNew(shared_state.get(), left_rect, SK_ColorGREEN); | |
| 212 root_pass->quad_list.push_back(color_quad.PassAs<DrawQuad>()); | |
| 213 root_pass->shared_quad_state_list.push_back(shared_state.Pass()); | |
| 214 left_rect += gfx::Vector2d(0, left_rect.height() + 1); | |
| 215 } | |
| 216 | |
| 217 gfx::Rect middle_rect = gfx::Rect(kColumnWidth+1, 0, kColumnWidth, 20); | |
| 218 for (int i = 0; middle_rect.y() < device_viewport_rect.height(); ++i) { | |
| 219 scoped_ptr<SharedQuadState> shared_state = | |
| 220 CreateTestSharedQuadState(identity_content_to_target_transform, | |
| 221 middle_rect); | |
| 222 scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create(); | |
| 223 color_quad->SetNew(shared_state.get(), middle_rect, SK_ColorRED); | |
| 224 root_pass->quad_list.push_back(color_quad.PassAs<DrawQuad>()); | |
| 225 root_pass->shared_quad_state_list.push_back(shared_state.Pass()); | |
| 226 middle_rect += gfx::Vector2d(0, middle_rect.height() + 1); | |
| 227 } | |
| 228 | |
| 229 gfx::Rect right_rect = gfx::Rect((kColumnWidth+1)*2, 0, kColumnWidth, 20); | |
| 230 for (int i = 0; right_rect.y() < device_viewport_rect.height(); ++i) { | |
| 231 scoped_ptr<SharedQuadState> shared_state = | |
| 232 CreateTestSharedQuadState(identity_content_to_target_transform, | |
| 233 right_rect); | |
| 234 scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create(); | |
| 235 color_quad->SetNew(shared_state.get(), right_rect, SK_ColorBLUE); | |
| 236 root_pass->quad_list.push_back(color_quad.PassAs<DrawQuad>()); | |
| 237 root_pass->shared_quad_state_list.push_back(shared_state.Pass()); | |
| 238 right_rect += gfx::Vector2d(0, right_rect.height() + 1); | |
| 239 } | |
| 240 | |
| 241 scoped_ptr<SharedQuadState> shared_state = | |
| 242 CreateTestSharedQuadState(identity_content_to_target_transform, | |
| 243 device_viewport_rect); | |
| 244 scoped_ptr<SolidColorDrawQuad> background_quad = | |
| 245 SolidColorDrawQuad::Create(); | |
| 246 background_quad->SetNew(shared_state.get(), | |
| 247 device_viewport_rect, | |
| 248 SK_ColorWHITE); | |
| 249 root_pass->quad_list.push_back(background_quad.PassAs<DrawQuad>()); | |
| 250 root_pass->shared_quad_state_list.push_back(shared_state.Pass()); | |
| 251 | |
| 252 RenderPassList pass_list; | |
| 253 pass_list.push_back(filter_pass.Pass()); | |
| 254 pass_list.push_back(root_pass.Pass()); | |
| 255 | |
| 256 renderer_->DecideRenderPassAllocationsForFrame(pass_list); | |
| 257 renderer_->DrawFrame(pass_list); | |
| 258 } | |
| 259 | |
| 260 WebKit::WebFilterOperations background_filters_; | |
| 261 gfx::Transform filter_pass_to_target_transform_; | |
| 262 gfx::Rect filter_pass_content_rect_; | |
| 263 }; | |
| 264 | |
| 265 TEST_F(GLRendererPixelTestWithBackgroundFilter, InvertFilter) { | |
| 266 background_filters_.append( | |
| 267 WebKit::WebFilterOperation::createInvertFilter(1.f)); | |
| 268 | |
| 269 filter_pass_content_rect_ = gfx::Rect(device_viewport_size_); | |
| 270 filter_pass_content_rect_.Inset(12, 14, 16, 18); | |
| 271 | |
| 272 DrawFrame(); | |
| 273 EXPECT_TRUE(PixelsMatchReference( | |
| 274 base::FilePath(FILE_PATH_LITERAL("background_filter.png")))); | |
| 275 } | |
| 276 | |
| 277 TEST_F(GLRendererPixelTest, AntiAliasing) { | |
| 278 gfx::Rect rect(0, 0, 200, 200); | |
| 279 | |
| 280 RenderPass::Id id(1, 1); | |
| 281 gfx::Transform transform_to_root; | |
| 282 scoped_ptr<RenderPass> pass = | |
| 283 CreateTestRenderPass(id, rect, transform_to_root); | |
| 284 | |
| 285 gfx::Transform red_content_to_target_transform; | |
| 286 red_content_to_target_transform.Rotate(10); | |
| 287 scoped_ptr<SharedQuadState> red_shared_state = | |
| 288 CreateTestSharedQuadState(red_content_to_target_transform, rect); | |
| 289 | |
| 290 scoped_ptr<SolidColorDrawQuad> red = SolidColorDrawQuad::Create(); | |
| 291 red->SetNew(red_shared_state.get(), rect, SK_ColorRED); | |
| 292 | |
| 293 pass->quad_list.push_back(red.PassAs<DrawQuad>()); | |
| 294 | |
| 295 gfx::Transform yellow_content_to_target_transform; | |
| 296 yellow_content_to_target_transform.Rotate(5); | |
| 297 scoped_ptr<SharedQuadState> yellow_shared_state = | |
| 298 CreateTestSharedQuadState(yellow_content_to_target_transform, rect); | |
| 299 | |
| 300 scoped_ptr<SolidColorDrawQuad> yellow = SolidColorDrawQuad::Create(); | |
| 301 yellow->SetNew(yellow_shared_state.get(), rect, SK_ColorYELLOW); | |
| 302 | |
| 303 pass->quad_list.push_back(yellow.PassAs<DrawQuad>()); | |
| 304 | |
| 305 gfx::Transform blue_content_to_target_transform; | |
| 306 scoped_ptr<SharedQuadState> blue_shared_state = | |
| 307 CreateTestSharedQuadState(blue_content_to_target_transform, rect); | |
| 308 | |
| 309 scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create(); | |
| 310 blue->SetNew(blue_shared_state.get(), rect, SK_ColorBLUE); | |
| 311 | |
| 312 pass->quad_list.push_back(blue.PassAs<DrawQuad>()); | |
| 313 | |
| 314 RenderPassList pass_list; | |
| 315 pass_list.push_back(pass.Pass()); | |
| 316 | |
| 317 renderer_->DrawFrame(pass_list); | |
| 318 | |
| 319 EXPECT_TRUE(PixelsMatchReference( | |
| 320 base::FilePath(FILE_PATH_LITERAL("anti_aliasing.png")))); | |
| 321 } | |
| 322 #endif | |
| 323 | |
| 324 } // namespace | |
| 325 } // namespace cc | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 12912006:
Part 4 of cc/ directory shuffles: output (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src