| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2013 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/test/layer_tree_pixel_test.h" | |
| 6 | |
| 7 #include "base/command_line.h" | |
| 8 #include "base/path_service.h" | |
| 9 #include "cc/base/switches.h" | |
| 10 #include "cc/layers/solid_color_layer.h" | |
| 11 #include "cc/layers/texture_layer.h" | |
| 12 #include "cc/output/copy_output_request.h" | |
| 13 #include "cc/output/copy_output_result.h" | |
| 14 #include "cc/output/direct_renderer.h" | |
| 15 #include "cc/resources/texture_mailbox.h" | |
| 16 #include "cc/test/paths.h" | |
| 17 #include "cc/test/pixel_comparator.h" | |
| 18 #include "cc/test/pixel_test_output_surface.h" | |
| 19 #include "cc/test/pixel_test_software_output_device.h" | |
| 20 #include "cc/test/pixel_test_utils.h" | |
| 21 #include "cc/test/test_in_process_context_provider.h" | |
| 22 #include "cc/trees/layer_tree_impl.h" | |
| 23 #include "gpu/command_buffer/client/gl_in_process_context.h" | |
| 24 #include "gpu/command_buffer/client/gles2_implementation.h" | |
| 25 | |
| 26 using gpu::gles2::GLES2Interface; | |
| 27 | |
| 28 namespace cc { | |
| 29 | |
| 30 LayerTreePixelTest::LayerTreePixelTest() | |
| 31 : pixel_comparator_(new ExactPixelComparator(true)), | |
| 32 test_type_(PIXEL_TEST_GL), | |
| 33 pending_texture_mailbox_callbacks_(0), | |
| 34 impl_side_painting_(true) { | |
| 35 } | |
| 36 | |
| 37 LayerTreePixelTest::~LayerTreePixelTest() {} | |
| 38 | |
| 39 scoped_ptr<OutputSurface> LayerTreePixelTest::CreateOutputSurface() { | |
| 40 gfx::Size surface_expansion_size(40, 60); | |
| 41 scoped_ptr<PixelTestOutputSurface> output_surface; | |
| 42 | |
| 43 switch (test_type_) { | |
| 44 case PIXEL_TEST_SOFTWARE: { | |
| 45 scoped_ptr<PixelTestSoftwareOutputDevice> software_output_device( | |
| 46 new PixelTestSoftwareOutputDevice); | |
| 47 software_output_device->set_surface_expansion_size( | |
| 48 surface_expansion_size); | |
| 49 output_surface = make_scoped_ptr( | |
| 50 new PixelTestOutputSurface(software_output_device.Pass())); | |
| 51 break; | |
| 52 } | |
| 53 case PIXEL_TEST_GL: { | |
| 54 bool flipped_output_surface = false; | |
| 55 output_surface = make_scoped_ptr(new PixelTestOutputSurface( | |
| 56 new TestInProcessContextProvider, new TestInProcessContextProvider, | |
| 57 flipped_output_surface)); | |
| 58 break; | |
| 59 } | |
| 60 } | |
| 61 | |
| 62 output_surface->set_surface_expansion_size(surface_expansion_size); | |
| 63 return output_surface.Pass(); | |
| 64 } | |
| 65 | |
| 66 void LayerTreePixelTest::WillActivateTreeOnThread(LayerTreeHostImpl* impl) { | |
| 67 if (impl->sync_tree()->source_frame_number() != 0) | |
| 68 return; | |
| 69 | |
| 70 DirectRenderer* renderer = static_cast<DirectRenderer*>(impl->renderer()); | |
| 71 renderer->SetEnlargePassTextureAmountForTesting(enlarge_texture_amount_); | |
| 72 | |
| 73 gfx::Rect viewport = impl->DeviceViewport(); | |
| 74 // The viewport has a 0,0 origin without external influence. | |
| 75 EXPECT_EQ(gfx::Point().ToString(), viewport.origin().ToString()); | |
| 76 // Be that influence! | |
| 77 viewport += gfx::Vector2d(20, 10); | |
| 78 bool resourceless_software_draw = false; | |
| 79 gfx::Transform identity = gfx::Transform(); | |
| 80 impl->SetExternalDrawConstraints(identity, | |
| 81 viewport, | |
| 82 viewport, | |
| 83 viewport, | |
| 84 identity, | |
| 85 resourceless_software_draw); | |
| 86 EXPECT_EQ(viewport.ToString(), impl->DeviceViewport().ToString()); | |
| 87 } | |
| 88 | |
| 89 scoped_ptr<CopyOutputRequest> LayerTreePixelTest::CreateCopyOutputRequest() { | |
| 90 return CopyOutputRequest::CreateBitmapRequest( | |
| 91 base::Bind(&LayerTreePixelTest::ReadbackResult, base::Unretained(this))); | |
| 92 } | |
| 93 | |
| 94 void LayerTreePixelTest::ReadbackResult(scoped_ptr<CopyOutputResult> result) { | |
| 95 ASSERT_TRUE(result->HasBitmap()); | |
| 96 result_bitmap_ = result->TakeBitmap().Pass(); | |
| 97 EndTest(); | |
| 98 } | |
| 99 | |
| 100 void LayerTreePixelTest::BeginTest() { | |
| 101 Layer* target = readback_target_ ? readback_target_ | |
| 102 : layer_tree_host()->root_layer(); | |
| 103 target->RequestCopyOfOutput(CreateCopyOutputRequest().Pass()); | |
| 104 PostSetNeedsCommitToMainThread(); | |
| 105 } | |
| 106 | |
| 107 void LayerTreePixelTest::AfterTest() { | |
| 108 base::FilePath test_data_dir; | |
| 109 EXPECT_TRUE(PathService::Get(CCPaths::DIR_TEST_DATA, &test_data_dir)); | |
| 110 base::FilePath ref_file_path = test_data_dir.Append(ref_file_); | |
| 111 | |
| 112 base::CommandLine* cmd = base::CommandLine::ForCurrentProcess(); | |
| 113 if (cmd->HasSwitch(switches::kCCRebaselinePixeltests)) | |
| 114 EXPECT_TRUE(WritePNGFile(*result_bitmap_, ref_file_path, true)); | |
| 115 EXPECT_TRUE(MatchesPNGFile(*result_bitmap_, | |
| 116 ref_file_path, | |
| 117 *pixel_comparator_)); | |
| 118 } | |
| 119 | |
| 120 scoped_refptr<SolidColorLayer> LayerTreePixelTest::CreateSolidColorLayer( | |
| 121 const gfx::Rect& rect, SkColor color) { | |
| 122 scoped_refptr<SolidColorLayer> layer = SolidColorLayer::Create(); | |
| 123 layer->SetIsDrawable(true); | |
| 124 layer->SetBounds(rect.size()); | |
| 125 layer->SetPosition(rect.origin()); | |
| 126 layer->SetBackgroundColor(color); | |
| 127 return layer; | |
| 128 } | |
| 129 | |
| 130 void LayerTreePixelTest::EndTest() { | |
| 131 // Drop TextureMailboxes on the main thread so that they can be cleaned up and | |
| 132 // the pending callbacks will fire. | |
| 133 for (size_t i = 0; i < texture_layers_.size(); ++i) { | |
| 134 texture_layers_[i]->SetTextureMailbox(TextureMailbox(), nullptr); | |
| 135 } | |
| 136 | |
| 137 TryEndTest(); | |
| 138 } | |
| 139 | |
| 140 void LayerTreePixelTest::TryEndTest() { | |
| 141 if (!result_bitmap_) | |
| 142 return; | |
| 143 if (pending_texture_mailbox_callbacks_) | |
| 144 return; | |
| 145 LayerTreeTest::EndTest(); | |
| 146 } | |
| 147 | |
| 148 scoped_refptr<SolidColorLayer> LayerTreePixelTest:: | |
| 149 CreateSolidColorLayerWithBorder( | |
| 150 const gfx::Rect& rect, SkColor color, | |
| 151 int border_width, SkColor border_color) { | |
| 152 scoped_refptr<SolidColorLayer> layer = CreateSolidColorLayer(rect, color); | |
| 153 scoped_refptr<SolidColorLayer> border_top = CreateSolidColorLayer( | |
| 154 gfx::Rect(0, 0, rect.width(), border_width), border_color); | |
| 155 scoped_refptr<SolidColorLayer> border_left = CreateSolidColorLayer( | |
| 156 gfx::Rect(0, | |
| 157 border_width, | |
| 158 border_width, | |
| 159 rect.height() - border_width * 2), | |
| 160 border_color); | |
| 161 scoped_refptr<SolidColorLayer> border_right = | |
| 162 CreateSolidColorLayer(gfx::Rect(rect.width() - border_width, | |
| 163 border_width, | |
| 164 border_width, | |
| 165 rect.height() - border_width * 2), | |
| 166 border_color); | |
| 167 scoped_refptr<SolidColorLayer> border_bottom = CreateSolidColorLayer( | |
| 168 gfx::Rect(0, rect.height() - border_width, rect.width(), border_width), | |
| 169 border_color); | |
| 170 layer->AddChild(border_top); | |
| 171 layer->AddChild(border_left); | |
| 172 layer->AddChild(border_right); | |
| 173 layer->AddChild(border_bottom); | |
| 174 return layer; | |
| 175 } | |
| 176 | |
| 177 scoped_refptr<TextureLayer> LayerTreePixelTest::CreateTextureLayer( | |
| 178 const gfx::Rect& rect, const SkBitmap& bitmap) { | |
| 179 scoped_refptr<TextureLayer> layer = TextureLayer::CreateForMailbox(NULL); | |
| 180 layer->SetIsDrawable(true); | |
| 181 layer->SetBounds(rect.size()); | |
| 182 layer->SetPosition(rect.origin()); | |
| 183 | |
| 184 TextureMailbox texture_mailbox; | |
| 185 scoped_ptr<SingleReleaseCallback> release_callback; | |
| 186 CopyBitmapToTextureMailboxAsTexture( | |
| 187 bitmap, &texture_mailbox, &release_callback); | |
| 188 layer->SetTextureMailbox(texture_mailbox, release_callback.Pass()); | |
| 189 | |
| 190 texture_layers_.push_back(layer); | |
| 191 pending_texture_mailbox_callbacks_++; | |
| 192 return layer; | |
| 193 } | |
| 194 | |
| 195 void LayerTreePixelTest::RunPixelTest( | |
| 196 PixelTestType test_type, | |
| 197 scoped_refptr<Layer> content_root, | |
| 198 base::FilePath file_name) { | |
| 199 test_type_ = test_type; | |
| 200 content_root_ = content_root; | |
| 201 readback_target_ = NULL; | |
| 202 ref_file_ = file_name; | |
| 203 bool threaded = true; | |
| 204 RunTest(threaded, false, impl_side_painting_); | |
| 205 } | |
| 206 | |
| 207 void LayerTreePixelTest::RunSingleThreadedPixelTest( | |
| 208 PixelTestType test_type, | |
| 209 scoped_refptr<Layer> content_root, | |
| 210 base::FilePath file_name) { | |
| 211 test_type_ = test_type; | |
| 212 content_root_ = content_root; | |
| 213 readback_target_ = NULL; | |
| 214 ref_file_ = file_name; | |
| 215 bool threaded = false; | |
| 216 RunTest(threaded, false, impl_side_painting_); | |
| 217 } | |
| 218 | |
| 219 void LayerTreePixelTest::RunPixelTestWithReadbackTarget( | |
| 220 PixelTestType test_type, | |
| 221 scoped_refptr<Layer> content_root, | |
| 222 Layer* target, | |
| 223 base::FilePath file_name) { | |
| 224 test_type_ = test_type; | |
| 225 content_root_ = content_root; | |
| 226 readback_target_ = target; | |
| 227 ref_file_ = file_name; | |
| 228 RunTest(true, false, impl_side_painting_); | |
| 229 } | |
| 230 | |
| 231 void LayerTreePixelTest::SetupTree() { | |
| 232 scoped_refptr<Layer> root = Layer::Create(); | |
| 233 root->SetBounds(content_root_->bounds()); | |
| 234 root->AddChild(content_root_); | |
| 235 layer_tree_host()->SetRootLayer(root); | |
| 236 LayerTreeTest::SetupTree(); | |
| 237 } | |
| 238 | |
| 239 scoped_ptr<SkBitmap> LayerTreePixelTest::CopyTextureMailboxToBitmap( | |
| 240 const gfx::Size& size, | |
| 241 const TextureMailbox& texture_mailbox) { | |
| 242 DCHECK(texture_mailbox.IsTexture()); | |
| 243 if (!texture_mailbox.IsTexture()) | |
| 244 return nullptr; | |
| 245 | |
| 246 scoped_ptr<gpu::GLInProcessContext> context = CreateTestInProcessContext(); | |
| 247 GLES2Interface* gl = context->GetImplementation(); | |
| 248 | |
| 249 if (texture_mailbox.sync_point()) | |
| 250 gl->WaitSyncPointCHROMIUM(texture_mailbox.sync_point()); | |
| 251 | |
| 252 GLuint texture_id = 0; | |
| 253 gl->GenTextures(1, &texture_id); | |
| 254 gl->BindTexture(GL_TEXTURE_2D, texture_id); | |
| 255 gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); | |
| 256 gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); | |
| 257 gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); | |
| 258 gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); | |
| 259 gl->ConsumeTextureCHROMIUM(texture_mailbox.target(), texture_mailbox.name()); | |
| 260 gl->BindTexture(GL_TEXTURE_2D, 0); | |
| 261 | |
| 262 GLuint fbo = 0; | |
| 263 gl->GenFramebuffers(1, &fbo); | |
| 264 gl->BindFramebuffer(GL_FRAMEBUFFER, fbo); | |
| 265 gl->FramebufferTexture2D( | |
| 266 GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture_id, 0); | |
| 267 EXPECT_EQ(static_cast<unsigned>(GL_FRAMEBUFFER_COMPLETE), | |
| 268 gl->CheckFramebufferStatus(GL_FRAMEBUFFER)); | |
| 269 | |
| 270 scoped_ptr<uint8[]> pixels(new uint8[size.GetArea() * 4]); | |
| 271 gl->ReadPixels(0, | |
| 272 0, | |
| 273 size.width(), | |
| 274 size.height(), | |
| 275 GL_RGBA, | |
| 276 GL_UNSIGNED_BYTE, | |
| 277 pixels.get()); | |
| 278 | |
| 279 gl->DeleteFramebuffers(1, &fbo); | |
| 280 gl->DeleteTextures(1, &texture_id); | |
| 281 | |
| 282 scoped_ptr<SkBitmap> bitmap(new SkBitmap); | |
| 283 bitmap->allocN32Pixels(size.width(), size.height()); | |
| 284 | |
| 285 uint8* out_pixels = static_cast<uint8*>(bitmap->getPixels()); | |
| 286 | |
| 287 size_t row_bytes = size.width() * 4; | |
| 288 size_t total_bytes = size.height() * row_bytes; | |
| 289 for (size_t dest_y = 0; dest_y < total_bytes; dest_y += row_bytes) { | |
| 290 // Flip Y axis. | |
| 291 size_t src_y = total_bytes - dest_y - row_bytes; | |
| 292 // Swizzle OpenGL -> Skia byte order. | |
| 293 for (size_t x = 0; x < row_bytes; x += 4) { | |
| 294 out_pixels[dest_y + x + SK_R32_SHIFT/8] = pixels.get()[src_y + x + 0]; | |
| 295 out_pixels[dest_y + x + SK_G32_SHIFT/8] = pixels.get()[src_y + x + 1]; | |
| 296 out_pixels[dest_y + x + SK_B32_SHIFT/8] = pixels.get()[src_y + x + 2]; | |
| 297 out_pixels[dest_y + x + SK_A32_SHIFT/8] = pixels.get()[src_y + x + 3]; | |
| 298 } | |
| 299 } | |
| 300 | |
| 301 return bitmap.Pass(); | |
| 302 } | |
| 303 | |
| 304 void LayerTreePixelTest::ReleaseTextureMailbox( | |
| 305 scoped_ptr<gpu::GLInProcessContext> context, | |
| 306 uint32 texture, | |
| 307 uint32 sync_point, | |
| 308 bool lost_resource) { | |
| 309 GLES2Interface* gl = context->GetImplementation(); | |
| 310 if (sync_point) | |
| 311 gl->WaitSyncPointCHROMIUM(sync_point); | |
| 312 gl->DeleteTextures(1, &texture); | |
| 313 pending_texture_mailbox_callbacks_--; | |
| 314 TryEndTest(); | |
| 315 } | |
| 316 | |
| 317 void LayerTreePixelTest::CopyBitmapToTextureMailboxAsTexture( | |
| 318 const SkBitmap& bitmap, | |
| 319 TextureMailbox* texture_mailbox, | |
| 320 scoped_ptr<SingleReleaseCallback>* release_callback) { | |
| 321 DCHECK_GT(bitmap.width(), 0); | |
| 322 DCHECK_GT(bitmap.height(), 0); | |
| 323 | |
| 324 scoped_ptr<gpu::GLInProcessContext> context = CreateTestInProcessContext(); | |
| 325 GLES2Interface* gl = context->GetImplementation(); | |
| 326 | |
| 327 GLuint texture_id = 0; | |
| 328 gl->GenTextures(1, &texture_id); | |
| 329 gl->BindTexture(GL_TEXTURE_2D, texture_id); | |
| 330 gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); | |
| 331 gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); | |
| 332 gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); | |
| 333 gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); | |
| 334 | |
| 335 DCHECK_EQ(kN32_SkColorType, bitmap.colorType()); | |
| 336 | |
| 337 { | |
| 338 SkAutoLockPixels lock(bitmap); | |
| 339 | |
| 340 size_t row_bytes = bitmap.width() * 4; | |
| 341 size_t total_bytes = bitmap.height() * row_bytes; | |
| 342 | |
| 343 scoped_ptr<uint8[]> gl_pixels(new uint8[total_bytes]); | |
| 344 uint8* bitmap_pixels = static_cast<uint8*>(bitmap.getPixels()); | |
| 345 | |
| 346 for (size_t y = 0; y < total_bytes; y += row_bytes) { | |
| 347 // Flip Y axis. | |
| 348 size_t src_y = total_bytes - y - row_bytes; | |
| 349 // Swizzle Skia -> OpenGL byte order. | |
| 350 for (size_t x = 0; x < row_bytes; x += 4) { | |
| 351 gl_pixels.get()[y + x + 0] = bitmap_pixels[src_y + x + SK_R32_SHIFT/8]; | |
| 352 gl_pixels.get()[y + x + 1] = bitmap_pixels[src_y + x + SK_G32_SHIFT/8]; | |
| 353 gl_pixels.get()[y + x + 2] = bitmap_pixels[src_y + x + SK_B32_SHIFT/8]; | |
| 354 gl_pixels.get()[y + x + 3] = bitmap_pixels[src_y + x + SK_A32_SHIFT/8]; | |
| 355 } | |
| 356 } | |
| 357 | |
| 358 gl->TexImage2D(GL_TEXTURE_2D, | |
| 359 0, | |
| 360 GL_RGBA, | |
| 361 bitmap.width(), | |
| 362 bitmap.height(), | |
| 363 0, | |
| 364 GL_RGBA, | |
| 365 GL_UNSIGNED_BYTE, | |
| 366 gl_pixels.get()); | |
| 367 } | |
| 368 | |
| 369 gpu::Mailbox mailbox; | |
| 370 gl->GenMailboxCHROMIUM(mailbox.name); | |
| 371 gl->ProduceTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name); | |
| 372 gl->BindTexture(GL_TEXTURE_2D, 0); | |
| 373 uint32 sync_point = gl->InsertSyncPointCHROMIUM(); | |
| 374 | |
| 375 *texture_mailbox = TextureMailbox(mailbox, GL_TEXTURE_2D, sync_point); | |
| 376 *release_callback = SingleReleaseCallback::Create( | |
| 377 base::Bind(&LayerTreePixelTest::ReleaseTextureMailbox, | |
| 378 base::Unretained(this), | |
| 379 base::Passed(&context), | |
| 380 texture_id)); | |
| 381 } | |
| 382 | |
| 383 } // namespace cc | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1057283003:
Remove parts of //cc we aren't using (Closed)
Base URL: git@github.com:domokit/mojo.git@master