diff options
Diffstat (limited to 'chromium/cc/output/renderer_pixeltest.cc')
| -rw-r--r-- | chromium/cc/output/renderer_pixeltest.cc | 1163 |
1 files changed, 668 insertions, 495 deletions
diff --git a/chromium/cc/output/renderer_pixeltest.cc b/chromium/cc/output/renderer_pixeltest.cc index 24c6126755e..2377043d45a 100644 --- a/chromium/cc/output/renderer_pixeltest.cc +++ b/chromium/cc/output/renderer_pixeltest.cc @@ -8,25 +8,30 @@ #include "cc/quads/draw_quad.h" #include "cc/quads/picture_draw_quad.h" #include "cc/quads/texture_draw_quad.h" +#include "cc/resources/video_resource_updater.h" #include "cc/test/fake_picture_pile_impl.h" #include "cc/test/pixel_test.h" #include "gpu/GLES2/gl2extchromium.h" -#include "third_party/WebKit/public/platform/WebGraphicsContext3D.h" +#include "gpu/command_buffer/client/gles2_interface.h" +#include "media/base/video_frame.h" +#include "third_party/skia/include/core/SkBitmapDevice.h" #include "third_party/skia/include/core/SkImageFilter.h" #include "third_party/skia/include/core/SkMatrix.h" #include "third_party/skia/include/effects/SkColorFilterImageFilter.h" #include "third_party/skia/include/effects/SkColorMatrixFilter.h" #include "ui/gfx/rect_conversions.h" +using gpu::gles2::GLES2Interface; + namespace cc { namespace { #if !defined(OS_ANDROID) scoped_ptr<RenderPass> CreateTestRootRenderPass(RenderPass::Id id, - gfx::Rect rect) { + const gfx::Rect& rect) { scoped_ptr<RenderPass> pass = RenderPass::Create(); const gfx::Rect output_rect = rect; - const gfx::RectF damage_rect = rect; + const gfx::Rect damage_rect = rect; const gfx::Transform transform_to_root_target; pass->SetNew(id, output_rect, damage_rect, transform_to_root_target); return pass.Pass(); @@ -34,59 +39,69 @@ scoped_ptr<RenderPass> CreateTestRootRenderPass(RenderPass::Id id, scoped_ptr<RenderPass> CreateTestRenderPass( RenderPass::Id id, - gfx::Rect rect, + const gfx::Rect& rect, const gfx::Transform& transform_to_root_target) { scoped_ptr<RenderPass> pass = RenderPass::Create(); const gfx::Rect output_rect = rect; - const gfx::RectF damage_rect = rect; + const gfx::Rect damage_rect = rect; pass->SetNew(id, output_rect, damage_rect, transform_to_root_target); return pass.Pass(); } -scoped_ptr<SharedQuadState> CreateTestSharedQuadState( - gfx::Transform content_to_target_transform, gfx::Rect rect) { +SharedQuadState* CreateTestSharedQuadState( + RenderPass* render_pass, + gfx::Transform content_to_target_transform, + const gfx::Rect& rect) { const gfx::Size content_bounds = rect.size(); const gfx::Rect visible_content_rect = rect; const gfx::Rect clip_rect = rect; const bool is_clipped = false; const float opacity = 1.0f; const SkXfermode::Mode blend_mode = SkXfermode::kSrcOver_Mode; - scoped_ptr<SharedQuadState> shared_state = SharedQuadState::Create(); + int sorting_context_id = 0; + SharedQuadState* shared_state = render_pass->CreateAndAppendSharedQuadState(); shared_state->SetAll(content_to_target_transform, content_bounds, visible_content_rect, clip_rect, is_clipped, opacity, - blend_mode); - return shared_state.Pass(); + blend_mode, + sorting_context_id); + return shared_state; } -scoped_ptr<SharedQuadState> CreateTestSharedQuadStateClipped( +SharedQuadState* CreateTestSharedQuadStateClipped( + RenderPass* render_pass, gfx::Transform content_to_target_transform, - gfx::Rect rect, - gfx::Rect clip_rect) { + const gfx::Rect& rect, + const gfx::Rect& clip_rect) { const gfx::Size content_bounds = rect.size(); const gfx::Rect visible_content_rect = clip_rect; const bool is_clipped = true; const float opacity = 1.0f; const SkXfermode::Mode blend_mode = SkXfermode::kSrcOver_Mode; - scoped_ptr<SharedQuadState> shared_state = SharedQuadState::Create(); + int sorting_context_id = 0; + SharedQuadState* shared_state = render_pass->CreateAndAppendSharedQuadState(); shared_state->SetAll(content_to_target_transform, content_bounds, visible_content_rect, clip_rect, is_clipped, opacity, - blend_mode); - return shared_state.Pass(); + blend_mode, + sorting_context_id); + return shared_state; } scoped_ptr<DrawQuad> CreateTestRenderPassDrawQuad( - SharedQuadState* shared_state, gfx::Rect rect, RenderPass::Id pass_id) { + SharedQuadState* shared_state, + const gfx::Rect& rect, + RenderPass::Id pass_id) { scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::Create(); quad->SetNew(shared_state, rect, + rect, pass_id, false, // is_replica 0, // mask_resource_id @@ -99,7 +114,7 @@ scoped_ptr<DrawQuad> CreateTestRenderPassDrawQuad( } scoped_ptr<TextureDrawQuad> CreateTestTextureDrawQuad( - gfx::Rect rect, + const gfx::Rect& rect, SkColor texel_color, SkColor background_color, bool premultiplied_alpha, @@ -131,6 +146,7 @@ scoped_ptr<TextureDrawQuad> CreateTestTextureDrawQuad( quad->SetNew(shared_state, rect, gfx::Rect(), + rect, resource, premultiplied_alpha, gfx::PointF(0.0f, 0.0f), // uv_top_left @@ -196,11 +212,11 @@ TYPED_TEST(RendererPixelTest, SimpleGreenRect) { RenderPass::Id id(1, 1); scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); - scoped_ptr<SharedQuadState> shared_state = - CreateTestSharedQuadState(gfx::Transform(), rect); + SharedQuadState* shared_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect); scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create(); - color_quad->SetNew(shared_state.get(), rect, SK_ColorGREEN, false); + color_quad->SetNew(shared_state, rect, rect, SK_ColorGREEN, false); pass->quad_list.push_back(color_quad.PassAs<DrawQuad>()); @@ -209,7 +225,6 @@ TYPED_TEST(RendererPixelTest, SimpleGreenRect) { EXPECT_TRUE(this->RunPixelTest( &pass_list, - PixelTest::NoOffscreenContext, base::FilePath(FILE_PATH_LITERAL("green.png")), ExactPixelComparator(true))); } @@ -222,24 +237,22 @@ TYPED_TEST(RendererPixelTest, SimpleGreenRect_NonRootRenderPass) { scoped_ptr<RenderPass> child_pass = CreateTestRenderPass(child_id, small_rect, gfx::Transform()); - scoped_ptr<SharedQuadState> child_shared_state = - CreateTestSharedQuadState(gfx::Transform(), small_rect); + SharedQuadState* child_shared_state = + CreateTestSharedQuadState(child_pass.get(), gfx::Transform(), small_rect); scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create(); - color_quad->SetNew(child_shared_state.get(), rect, SK_ColorGREEN, false); + color_quad->SetNew(child_shared_state, rect, rect, SK_ColorGREEN, false); child_pass->quad_list.push_back(color_quad.PassAs<DrawQuad>()); RenderPass::Id root_id(1, 1); scoped_ptr<RenderPass> root_pass = CreateTestRenderPass(root_id, rect, gfx::Transform()); - scoped_ptr<SharedQuadState> root_shared_state = - CreateTestSharedQuadState(gfx::Transform(), rect); + SharedQuadState* root_shared_state = + CreateTestSharedQuadState(root_pass.get(), gfx::Transform(), rect); scoped_ptr<DrawQuad> render_pass_quad = - CreateTestRenderPassDrawQuad(root_shared_state.get(), - small_rect, - child_id); + CreateTestRenderPassDrawQuad(root_shared_state, small_rect, child_id); root_pass->quad_list.push_back(render_pass_quad.PassAs<DrawQuad>()); RenderPass* child_pass_ptr = child_pass.get(); @@ -251,7 +264,6 @@ TYPED_TEST(RendererPixelTest, SimpleGreenRect_NonRootRenderPass) { EXPECT_TRUE(this->RunPixelTestWithReadbackTarget( &pass_list, child_pass_ptr, - PixelTest::NoOffscreenContext, base::FilePath(FILE_PATH_LITERAL("green_small.png")), ExactPixelComparator(true))); } @@ -262,20 +274,20 @@ TYPED_TEST(RendererPixelTest, PremultipliedTextureWithoutBackground) { RenderPass::Id id(1, 1); scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); - scoped_ptr<SharedQuadState> shared_state = - CreateTestSharedQuadState(gfx::Transform(), rect); + SharedQuadState* shared_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect); - scoped_ptr<TextureDrawQuad> texture_quad = CreateTestTextureDrawQuad( - gfx::Rect(this->device_viewport_size_), - SkColorSetARGB(128, 0, 255, 0), // Texel color. - SK_ColorTRANSPARENT, // Background color. - true, // Premultiplied alpha. - shared_state.get(), - this->resource_provider_.get()); + scoped_ptr<TextureDrawQuad> texture_quad = + CreateTestTextureDrawQuad(gfx::Rect(this->device_viewport_size_), + SkColorSetARGB(128, 0, 255, 0), // Texel color. + SK_ColorTRANSPARENT, // Background color. + true, // Premultiplied alpha. + shared_state, + this->resource_provider_.get()); pass->quad_list.push_back(texture_quad.PassAs<DrawQuad>()); scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create(); - color_quad->SetNew(shared_state.get(), rect, SK_ColorWHITE, false); + color_quad->SetNew(shared_state, rect, rect, SK_ColorWHITE, false); pass->quad_list.push_back(color_quad.PassAs<DrawQuad>()); RenderPassList pass_list; @@ -283,7 +295,6 @@ TYPED_TEST(RendererPixelTest, PremultipliedTextureWithoutBackground) { EXPECT_TRUE(this->RunPixelTest( &pass_list, - PixelTest::NoOffscreenContext, base::FilePath(FILE_PATH_LITERAL("green_alpha.png")), FuzzyPixelOffByOneComparator(true))); } @@ -294,23 +305,23 @@ TYPED_TEST(RendererPixelTest, PremultipliedTextureWithBackground) { RenderPass::Id id(1, 1); scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); - scoped_ptr<SharedQuadState> texture_quad_state = - CreateTestSharedQuadState(gfx::Transform(), rect); + SharedQuadState* texture_quad_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect); texture_quad_state->opacity = 0.8f; scoped_ptr<TextureDrawQuad> texture_quad = CreateTestTextureDrawQuad( gfx::Rect(this->device_viewport_size_), SkColorSetARGB(204, 120, 255, 120), // Texel color. - SK_ColorGREEN, // Background color. - true, // Premultiplied alpha. - texture_quad_state.get(), + SK_ColorGREEN, // Background color. + true, // Premultiplied alpha. + texture_quad_state, this->resource_provider_.get()); pass->quad_list.push_back(texture_quad.PassAs<DrawQuad>()); - scoped_ptr<SharedQuadState> color_quad_state = - CreateTestSharedQuadState(gfx::Transform(), rect); + SharedQuadState* color_quad_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect); scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create(); - color_quad->SetNew(color_quad_state.get(), rect, SK_ColorWHITE, false); + color_quad->SetNew(color_quad_state, rect, rect, SK_ColorWHITE, false); pass->quad_list.push_back(color_quad.PassAs<DrawQuad>()); RenderPassList pass_list; @@ -318,7 +329,6 @@ TYPED_TEST(RendererPixelTest, PremultipliedTextureWithBackground) { EXPECT_TRUE(this->RunPixelTest( &pass_list, - PixelTest::NoOffscreenContext, base::FilePath(FILE_PATH_LITERAL("green_alpha.png")), FuzzyPixelOffByOneComparator(true))); } @@ -330,20 +340,20 @@ TEST_F(GLRendererPixelTest, NonPremultipliedTextureWithoutBackground) { RenderPass::Id id(1, 1); scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); - scoped_ptr<SharedQuadState> shared_state = - CreateTestSharedQuadState(gfx::Transform(), rect); + SharedQuadState* shared_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect); - scoped_ptr<TextureDrawQuad> texture_quad = CreateTestTextureDrawQuad( - gfx::Rect(this->device_viewport_size_), - SkColorSetARGB(128, 0, 255, 0), // Texel color. - SK_ColorTRANSPARENT, // Background color. - false, // Premultiplied alpha. - shared_state.get(), - this->resource_provider_.get()); + scoped_ptr<TextureDrawQuad> texture_quad = + CreateTestTextureDrawQuad(gfx::Rect(this->device_viewport_size_), + SkColorSetARGB(128, 0, 255, 0), // Texel color. + SK_ColorTRANSPARENT, // Background color. + false, // Premultiplied alpha. + shared_state, + this->resource_provider_.get()); pass->quad_list.push_back(texture_quad.PassAs<DrawQuad>()); scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create(); - color_quad->SetNew(shared_state.get(), rect, SK_ColorWHITE, false); + color_quad->SetNew(shared_state, rect, rect, SK_ColorWHITE, false); pass->quad_list.push_back(color_quad.PassAs<DrawQuad>()); RenderPassList pass_list; @@ -351,7 +361,6 @@ TEST_F(GLRendererPixelTest, NonPremultipliedTextureWithoutBackground) { EXPECT_TRUE(this->RunPixelTest( &pass_list, - PixelTest::NoOffscreenContext, base::FilePath(FILE_PATH_LITERAL("green_alpha.png")), FuzzyPixelOffByOneComparator(true))); } @@ -363,23 +372,23 @@ TEST_F(GLRendererPixelTest, NonPremultipliedTextureWithBackground) { RenderPass::Id id(1, 1); scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); - scoped_ptr<SharedQuadState> texture_quad_state = - CreateTestSharedQuadState(gfx::Transform(), rect); + SharedQuadState* texture_quad_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect); texture_quad_state->opacity = 0.8f; scoped_ptr<TextureDrawQuad> texture_quad = CreateTestTextureDrawQuad( gfx::Rect(this->device_viewport_size_), SkColorSetARGB(204, 120, 255, 120), // Texel color. - SK_ColorGREEN, // Background color. - false, // Premultiplied alpha. - texture_quad_state.get(), + SK_ColorGREEN, // Background color. + false, // Premultiplied alpha. + texture_quad_state, this->resource_provider_.get()); pass->quad_list.push_back(texture_quad.PassAs<DrawQuad>()); - scoped_ptr<SharedQuadState> color_quad_state = - CreateTestSharedQuadState(gfx::Transform(), rect); + SharedQuadState* color_quad_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect); scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create(); - color_quad->SetNew(color_quad_state.get(), rect, SK_ColorWHITE, false); + color_quad->SetNew(color_quad_state, rect, rect, SK_ColorWHITE, false); pass->quad_list.push_back(color_quad.PassAs<DrawQuad>()); RenderPassList pass_list; @@ -387,79 +396,158 @@ TEST_F(GLRendererPixelTest, NonPremultipliedTextureWithBackground) { EXPECT_TRUE(this->RunPixelTest( &pass_list, - PixelTest::NoOffscreenContext, base::FilePath(FILE_PATH_LITERAL("green_alpha.png")), FuzzyPixelOffByOneComparator(true))); } class VideoGLRendererPixelTest : public GLRendererPixelTest { protected: - scoped_ptr<YUVVideoDrawQuad> CreateTestYUVVideoDrawQuad( - SharedQuadState* shared_state, bool with_alpha, bool is_transparent) { - gfx::Rect rect(this->device_viewport_size_); - gfx::Rect opaque_rect(0, 0, 0, 0); + scoped_ptr<YUVVideoDrawQuad> CreateTestYUVVideoDrawQuad_Striped( + SharedQuadState* shared_state, + media::VideoFrame::Format format, + bool is_transparent, + const gfx::RectF& tex_coord_rect) { + const gfx::Rect rect(this->device_viewport_size_); + + scoped_refptr<media::VideoFrame> video_frame = + media::VideoFrame::CreateFrame( + format, rect.size(), rect, rect.size(), base::TimeDelta()); + + // YUV values representing a striped pattern, for validating texture + // coordinates for sampling. + uint8_t y_value = 0; + uint8_t u_value = 0; + uint8_t v_value = 0; + for (int i = 0; i < video_frame->rows(media::VideoFrame::kYPlane); ++i) { + uint8_t* y_row = video_frame->data(media::VideoFrame::kYPlane) + + video_frame->stride(media::VideoFrame::kYPlane) * i; + for (int j = 0; j < video_frame->row_bytes(media::VideoFrame::kYPlane); + ++j) { + y_row[j] = (y_value += 1); + } + } + for (int i = 0; i < video_frame->rows(media::VideoFrame::kUPlane); ++i) { + uint8_t* u_row = video_frame->data(media::VideoFrame::kUPlane) + + video_frame->stride(media::VideoFrame::kUPlane) * i; + uint8_t* v_row = video_frame->data(media::VideoFrame::kVPlane) + + video_frame->stride(media::VideoFrame::kVPlane) * i; + for (int j = 0; j < video_frame->row_bytes(media::VideoFrame::kUPlane); + ++j) { + u_row[j] = (u_value += 3); + v_row[j] = (v_value += 5); + } + } + return CreateTestYUVVideoDrawQuad_FromVideoFrame( + shared_state, video_frame, is_transparent, tex_coord_rect); + } + + scoped_ptr<YUVVideoDrawQuad> CreateTestYUVVideoDrawQuad_Solid( + SharedQuadState* shared_state, + media::VideoFrame::Format format, + bool is_transparent, + const gfx::RectF& tex_coord_rect, + uint8 y, + uint8 u, + uint8 v) { + const gfx::Rect rect(this->device_viewport_size_); + + scoped_refptr<media::VideoFrame> video_frame = + media::VideoFrame::CreateFrame( + format, rect.size(), rect, rect.size(), base::TimeDelta()); + + // YUV values of a solid, constant, color. Useful for testing that color + // space/color range are being handled properly. + memset(video_frame->data(media::VideoFrame::kYPlane), + y, + video_frame->stride(media::VideoFrame::kYPlane) * + video_frame->rows(media::VideoFrame::kYPlane)); + memset(video_frame->data(media::VideoFrame::kUPlane), + u, + video_frame->stride(media::VideoFrame::kUPlane) * + video_frame->rows(media::VideoFrame::kUPlane)); + memset(video_frame->data(media::VideoFrame::kVPlane), + v, + video_frame->stride(media::VideoFrame::kVPlane) * + video_frame->rows(media::VideoFrame::kVPlane)); + + return CreateTestYUVVideoDrawQuad_FromVideoFrame( + shared_state, video_frame, is_transparent, tex_coord_rect); + } + + scoped_ptr<YUVVideoDrawQuad> CreateTestYUVVideoDrawQuad_FromVideoFrame( + SharedQuadState* shared_state, + scoped_refptr<media::VideoFrame> video_frame, + bool is_transparent, + const gfx::RectF& tex_coord_rect) { + const bool with_alpha = (video_frame->format() == media::VideoFrame::YV12A); + const YUVVideoDrawQuad::ColorSpace color_space = + (video_frame->format() == media::VideoFrame::YV12J + ? YUVVideoDrawQuad::REC_601_JPEG + : YUVVideoDrawQuad::REC_601); + const gfx::Rect rect(this->device_viewport_size_); + const gfx::Rect opaque_rect(0, 0, 0, 0); + + if (with_alpha) + memset(video_frame->data(media::VideoFrame::kAPlane), + is_transparent ? 0 : 128, + video_frame->stride(media::VideoFrame::kAPlane) * + video_frame->rows(media::VideoFrame::kAPlane)); + + VideoFrameExternalResources resources = + video_resource_updater_->CreateExternalResourcesFromVideoFrame( + video_frame); + + EXPECT_EQ(VideoFrameExternalResources::YUV_RESOURCE, resources.type); + EXPECT_EQ(media::VideoFrame::NumPlanes(video_frame->format()), + resources.mailboxes.size()); + EXPECT_EQ(media::VideoFrame::NumPlanes(video_frame->format()), + resources.release_callbacks.size()); ResourceProvider::ResourceId y_resource = - resource_provider_->CreateResource( - this->device_viewport_size_, - GL_CLAMP_TO_EDGE, - ResourceProvider::TextureUsageAny, - LUMINANCE_8); + resource_provider_->CreateResourceFromTextureMailbox( + resources.mailboxes[media::VideoFrame::kYPlane], + SingleReleaseCallback::Create( + resources.release_callbacks[media::VideoFrame::kYPlane])); ResourceProvider::ResourceId u_resource = - resource_provider_->CreateResource( - this->device_viewport_size_, - GL_CLAMP_TO_EDGE, - ResourceProvider::TextureUsageAny, - LUMINANCE_8); + resource_provider_->CreateResourceFromTextureMailbox( + resources.mailboxes[media::VideoFrame::kUPlane], + SingleReleaseCallback::Create( + resources.release_callbacks[media::VideoFrame::kUPlane])); ResourceProvider::ResourceId v_resource = - resource_provider_->CreateResource( - this->device_viewport_size_, - GL_CLAMP_TO_EDGE, - ResourceProvider::TextureUsageAny, - LUMINANCE_8); + resource_provider_->CreateResourceFromTextureMailbox( + resources.mailboxes[media::VideoFrame::kVPlane], + SingleReleaseCallback::Create( + resources.release_callbacks[media::VideoFrame::kVPlane])); ResourceProvider::ResourceId a_resource = 0; if (with_alpha) { - a_resource = resource_provider_->CreateResource( - this->device_viewport_size_, - GL_CLAMP_TO_EDGE, - ResourceProvider::TextureUsageAny, - LUMINANCE_8); - } - - int w = this->device_viewport_size_.width(); - int h = this->device_viewport_size_.height(); - const int y_plane_size = w * h; - gfx::Rect uv_rect((w + 1) / 2, (h + 1) / 2); - const int uv_plane_size = uv_rect.size().GetArea(); - scoped_ptr<uint8_t[]> y_plane(new uint8_t[y_plane_size]); - scoped_ptr<uint8_t[]> u_plane(new uint8_t[uv_plane_size]); - scoped_ptr<uint8_t[]> v_plane(new uint8_t[uv_plane_size]); - scoped_ptr<uint8_t[]> a_plane; - if (with_alpha) - a_plane.reset(new uint8_t[y_plane_size]); - // YUV values representing Green. - memset(y_plane.get(), 149, y_plane_size); - memset(u_plane.get(), 43, uv_plane_size); - memset(v_plane.get(), 21, uv_plane_size); - if (with_alpha) - memset(a_plane.get(), is_transparent ? 0 : 128, y_plane_size); - - resource_provider_->SetPixels(y_resource, y_plane.get(), rect, rect, - gfx::Vector2d()); - resource_provider_->SetPixels(u_resource, u_plane.get(), uv_rect, uv_rect, - gfx::Vector2d()); - resource_provider_->SetPixels(v_resource, v_plane.get(), uv_rect, uv_rect, - gfx::Vector2d()); - if (with_alpha) { - resource_provider_->SetPixels(a_resource, a_plane.get(), rect, rect, - gfx::Vector2d()); + a_resource = resource_provider_->CreateResourceFromTextureMailbox( + resources.mailboxes[media::VideoFrame::kAPlane], + SingleReleaseCallback::Create( + resources.release_callbacks[media::VideoFrame::kAPlane])); } scoped_ptr<YUVVideoDrawQuad> yuv_quad = YUVVideoDrawQuad::Create(); - yuv_quad->SetNew(shared_state, rect, opaque_rect, gfx::Size(), - y_resource, u_resource, v_resource, a_resource); + yuv_quad->SetNew(shared_state, + rect, + opaque_rect, + rect, + tex_coord_rect, + y_resource, + u_resource, + v_resource, + a_resource, + color_space); return yuv_quad.Pass(); } + + virtual void SetUp() OVERRIDE { + GLRendererPixelTest::SetUp(); + video_resource_updater_.reset(new VideoResourceUpdater( + output_surface_->context_provider().get(), resource_provider_.get())); + } + + private: + scoped_ptr<VideoResourceUpdater> video_resource_updater_; }; TEST_F(VideoGLRendererPixelTest, SimpleYUVRect) { @@ -468,11 +556,41 @@ TEST_F(VideoGLRendererPixelTest, SimpleYUVRect) { RenderPass::Id id(1, 1); scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); - scoped_ptr<SharedQuadState> shared_state = - CreateTestSharedQuadState(gfx::Transform(), rect); + SharedQuadState* shared_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect); scoped_ptr<YUVVideoDrawQuad> yuv_quad = - CreateTestYUVVideoDrawQuad(shared_state.get(), false, false); + CreateTestYUVVideoDrawQuad_Striped(shared_state, + media::VideoFrame::YV12, + false, + gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f)); + + pass->quad_list.push_back(yuv_quad.PassAs<DrawQuad>()); + + RenderPassList pass_list; + pass_list.push_back(pass.Pass()); + + EXPECT_TRUE( + this->RunPixelTest(&pass_list, + base::FilePath(FILE_PATH_LITERAL("yuv_stripes.png")), + FuzzyPixelOffByOneComparator(true))); +} + +TEST_F(VideoGLRendererPixelTest, OffsetYUVRect) { + gfx::Rect rect(this->device_viewport_size_); + + RenderPass::Id id(1, 1); + scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); + + SharedQuadState* shared_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect); + + // Intentionally sets frame format to I420 for testing coverage. + scoped_ptr<YUVVideoDrawQuad> yuv_quad = CreateTestYUVVideoDrawQuad_Striped( + shared_state, + media::VideoFrame::I420, + false, + gfx::RectF(0.125f, 0.25f, 0.75f, 0.5f)); pass->quad_list.push_back(yuv_quad.PassAs<DrawQuad>()); @@ -481,9 +599,98 @@ TEST_F(VideoGLRendererPixelTest, SimpleYUVRect) { EXPECT_TRUE(this->RunPixelTest( &pass_list, - PixelTest::NoOffscreenContext, - base::FilePath(FILE_PATH_LITERAL("green.png")), - ExactPixelComparator(true))); + base::FilePath(FILE_PATH_LITERAL("yuv_stripes_offset.png")), + FuzzyPixelOffByOneComparator(true))); +} + +TEST_F(VideoGLRendererPixelTest, SimpleYUVRectBlack) { + gfx::Rect rect(this->device_viewport_size_); + + RenderPass::Id id(1, 1); + scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); + + SharedQuadState* shared_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect); + + // In MPEG color range YUV values of (15,128,128) should produce black. + scoped_ptr<YUVVideoDrawQuad> yuv_quad = + CreateTestYUVVideoDrawQuad_Solid(shared_state, + media::VideoFrame::YV12, + false, + gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), + 15, + 128, + 128); + + pass->quad_list.push_back(yuv_quad.PassAs<DrawQuad>()); + + RenderPassList pass_list; + pass_list.push_back(pass.Pass()); + + // If we didn't get black out of the YUV values above, then we probably have a + // color range issue. + EXPECT_TRUE(this->RunPixelTest(&pass_list, + base::FilePath(FILE_PATH_LITERAL("black.png")), + FuzzyPixelOffByOneComparator(true))); +} + +TEST_F(VideoGLRendererPixelTest, SimpleYUVJRect) { + gfx::Rect rect(this->device_viewport_size_); + + RenderPass::Id id(1, 1); + scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); + + SharedQuadState* shared_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect); + + // YUV of (149,43,21) should be green (0,255,0) in RGB. + scoped_ptr<YUVVideoDrawQuad> yuv_quad = + CreateTestYUVVideoDrawQuad_Solid(shared_state, + media::VideoFrame::YV12J, + false, + gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), + 149, + 43, + 21); + + pass->quad_list.push_back(yuv_quad.PassAs<DrawQuad>()); + + RenderPassList pass_list; + pass_list.push_back(pass.Pass()); + + EXPECT_TRUE(this->RunPixelTest(&pass_list, + base::FilePath(FILE_PATH_LITERAL("green.png")), + FuzzyPixelOffByOneComparator(true))); +} + +TEST_F(VideoGLRendererPixelTest, SimpleYUVJRectGrey) { + gfx::Rect rect(this->device_viewport_size_); + + RenderPass::Id id(1, 1); + scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); + + SharedQuadState* shared_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect); + + // Dark grey in JPEG color range (in MPEG, this is black). + scoped_ptr<YUVVideoDrawQuad> yuv_quad = + CreateTestYUVVideoDrawQuad_Solid(shared_state, + media::VideoFrame::YV12J, + false, + gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), + 15, + 128, + 128); + + pass->quad_list.push_back(yuv_quad.PassAs<DrawQuad>()); + + RenderPassList pass_list; + pass_list.push_back(pass.Pass()); + + EXPECT_TRUE( + this->RunPixelTest(&pass_list, + base::FilePath(FILE_PATH_LITERAL("dark_grey.png")), + FuzzyPixelOffByOneComparator(true))); } TEST_F(VideoGLRendererPixelTest, SimpleYUVARect) { @@ -492,16 +699,19 @@ TEST_F(VideoGLRendererPixelTest, SimpleYUVARect) { RenderPass::Id id(1, 1); scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); - scoped_ptr<SharedQuadState> shared_state = - CreateTestSharedQuadState(gfx::Transform(), rect); + SharedQuadState* shared_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect); scoped_ptr<YUVVideoDrawQuad> yuv_quad = - CreateTestYUVVideoDrawQuad(shared_state.get(), true, false); + CreateTestYUVVideoDrawQuad_Striped(shared_state, + media::VideoFrame::YV12A, + false, + gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f)); pass->quad_list.push_back(yuv_quad.PassAs<DrawQuad>()); scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create(); - color_quad->SetNew(shared_state.get(), rect, SK_ColorWHITE, false); + color_quad->SetNew(shared_state, rect, rect, SK_ColorWHITE, false); pass->quad_list.push_back(color_quad.PassAs<DrawQuad>()); @@ -510,9 +720,8 @@ TEST_F(VideoGLRendererPixelTest, SimpleYUVARect) { EXPECT_TRUE(this->RunPixelTest( &pass_list, - PixelTest::NoOffscreenContext, - base::FilePath(FILE_PATH_LITERAL("green_alpha.png")), - ExactPixelComparator(true))); + base::FilePath(FILE_PATH_LITERAL("yuv_stripes_alpha.png")), + FuzzyPixelOffByOneComparator(true))); } TEST_F(VideoGLRendererPixelTest, FullyTransparentYUVARect) { @@ -521,16 +730,19 @@ TEST_F(VideoGLRendererPixelTest, FullyTransparentYUVARect) { RenderPass::Id id(1, 1); scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); - scoped_ptr<SharedQuadState> shared_state = - CreateTestSharedQuadState(gfx::Transform(), rect); + SharedQuadState* shared_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect); scoped_ptr<YUVVideoDrawQuad> yuv_quad = - CreateTestYUVVideoDrawQuad(shared_state.get(), true, true); + CreateTestYUVVideoDrawQuad_Striped(shared_state, + media::VideoFrame::YV12A, + true, + gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f)); pass->quad_list.push_back(yuv_quad.PassAs<DrawQuad>()); scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create(); - color_quad->SetNew(shared_state.get(), rect, SK_ColorBLACK, false); + color_quad->SetNew(shared_state, rect, rect, SK_ColorBLACK, false); pass->quad_list.push_back(color_quad.PassAs<DrawQuad>()); @@ -539,7 +751,6 @@ TEST_F(VideoGLRendererPixelTest, FullyTransparentYUVARect) { EXPECT_TRUE(this->RunPixelTest( &pass_list, - PixelTest::NoOffscreenContext, base::FilePath(FILE_PATH_LITERAL("black.png")), ExactPixelComparator(true))); } @@ -558,42 +769,36 @@ TYPED_TEST(RendererPixelTest, FastPassColorFilterAlpha) { CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root); gfx::Transform content_to_target_transform; - scoped_ptr<SharedQuadState> shared_state = - CreateTestSharedQuadState(content_to_target_transform, viewport_rect); + SharedQuadState* shared_state = CreateTestSharedQuadState( + child_pass.get(), content_to_target_transform, viewport_rect); shared_state->opacity = 0.5f; + gfx::Rect blue_rect(0, + 0, + this->device_viewport_size_.width(), + this->device_viewport_size_.height() / 2); scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create(); - blue->SetNew(shared_state.get(), - gfx::Rect(0, - 0, - this->device_viewport_size_.width(), - this->device_viewport_size_.height() / 2), - SK_ColorBLUE, - false); + blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false); + gfx::Rect yellow_rect(0, + this->device_viewport_size_.height() / 2, + this->device_viewport_size_.width(), + this->device_viewport_size_.height() / 2); scoped_ptr<SolidColorDrawQuad> yellow = SolidColorDrawQuad::Create(); - yellow->SetNew(shared_state.get(), - gfx::Rect(0, - this->device_viewport_size_.height() / 2, - this->device_viewport_size_.width(), - this->device_viewport_size_.height() / 2), - SK_ColorYELLOW, - false); + yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false); - scoped_ptr<SharedQuadState> blank_state = - CreateTestSharedQuadState(content_to_target_transform, viewport_rect); + SharedQuadState* blank_state = CreateTestSharedQuadState( + child_pass.get(), content_to_target_transform, viewport_rect); scoped_ptr<SolidColorDrawQuad> white = SolidColorDrawQuad::Create(); - white->SetNew(blank_state.get(), - viewport_rect, - SK_ColorWHITE, - false); + white->SetNew( + blank_state, viewport_rect, viewport_rect, SK_ColorWHITE, false); child_pass->quad_list.push_back(blue.PassAs<DrawQuad>()); child_pass->quad_list.push_back(yellow.PassAs<DrawQuad>()); child_pass->quad_list.push_back(white.PassAs<DrawQuad>()); - scoped_ptr<SharedQuadState> pass_shared_state = - CreateTestSharedQuadState(gfx::Transform(), pass_rect); + SharedQuadState* pass_shared_state = + CreateTestSharedQuadState(root_pass.get(), gfx::Transform(), pass_rect); SkScalar matrix[20]; float amount = 0.5f; @@ -611,8 +816,8 @@ TYPED_TEST(RendererPixelTest, FastPassColorFilterAlpha) { matrix[13] = matrix[14] = 0; matrix[15] = matrix[16] = matrix[17] = matrix[19] = 0; matrix[18] = 1; - skia::RefPtr<SkColorFilter> colorFilter(skia::AdoptRef( - new SkColorMatrixFilter(matrix))); + skia::RefPtr<SkColorFilter> colorFilter( + skia::AdoptRef(SkColorMatrixFilter::Create(matrix))); skia::RefPtr<SkImageFilter> filter = skia::AdoptRef(SkColorFilterImageFilter::Create(colorFilter.get(), NULL)); FilterOperations filters; @@ -620,7 +825,8 @@ TYPED_TEST(RendererPixelTest, FastPassColorFilterAlpha) { scoped_ptr<RenderPassDrawQuad> render_pass_quad = RenderPassDrawQuad::Create(); - render_pass_quad->SetNew(pass_shared_state.get(), + render_pass_quad->SetNew(pass_shared_state, + pass_rect, pass_rect, child_pass_id, false, @@ -640,7 +846,6 @@ TYPED_TEST(RendererPixelTest, FastPassColorFilterAlpha) { // renderer so use a fuzzy comparator. EXPECT_TRUE(this->RunPixelTest( &pass_list, - PixelTest::NoOffscreenContext, base::FilePath(FILE_PATH_LITERAL("blue_yellow_alpha.png")), FuzzyForSoftwareOnlyPixelComparator<TypeParam>(false))); } @@ -659,49 +864,44 @@ TYPED_TEST(RendererPixelTest, FastPassSaturateFilter) { CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root); gfx::Transform content_to_target_transform; - scoped_ptr<SharedQuadState> shared_state = - CreateTestSharedQuadState(content_to_target_transform, viewport_rect); + SharedQuadState* shared_state = CreateTestSharedQuadState( + child_pass.get(), content_to_target_transform, viewport_rect); shared_state->opacity = 0.5f; + gfx::Rect blue_rect(0, + 0, + this->device_viewport_size_.width(), + this->device_viewport_size_.height() / 2); scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create(); - blue->SetNew(shared_state.get(), - gfx::Rect(0, - 0, - this->device_viewport_size_.width(), - this->device_viewport_size_.height() / 2), - SK_ColorBLUE, - false); + blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false); + gfx::Rect yellow_rect(0, + this->device_viewport_size_.height() / 2, + this->device_viewport_size_.width(), + this->device_viewport_size_.height() / 2); scoped_ptr<SolidColorDrawQuad> yellow = SolidColorDrawQuad::Create(); - yellow->SetNew(shared_state.get(), - gfx::Rect(0, - this->device_viewport_size_.height() / 2, - this->device_viewport_size_.width(), - this->device_viewport_size_.height() / 2), - SK_ColorYELLOW, - false); + yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false); - scoped_ptr<SharedQuadState> blank_state = - CreateTestSharedQuadState(content_to_target_transform, viewport_rect); + SharedQuadState* blank_state = CreateTestSharedQuadState( + child_pass.get(), content_to_target_transform, viewport_rect); scoped_ptr<SolidColorDrawQuad> white = SolidColorDrawQuad::Create(); - white->SetNew(blank_state.get(), - viewport_rect, - SK_ColorWHITE, - false); + white->SetNew( + blank_state, viewport_rect, viewport_rect, SK_ColorWHITE, false); child_pass->quad_list.push_back(blue.PassAs<DrawQuad>()); child_pass->quad_list.push_back(yellow.PassAs<DrawQuad>()); child_pass->quad_list.push_back(white.PassAs<DrawQuad>()); - scoped_ptr<SharedQuadState> pass_shared_state = - CreateTestSharedQuadState(gfx::Transform(), pass_rect); + SharedQuadState* pass_shared_state = + CreateTestSharedQuadState(root_pass.get(), gfx::Transform(), pass_rect); FilterOperations filters; filters.Append(FilterOperation::CreateSaturateFilter(0.5f)); scoped_ptr<RenderPassDrawQuad> render_pass_quad = RenderPassDrawQuad::Create(); - render_pass_quad->SetNew(pass_shared_state.get(), + render_pass_quad->SetNew(pass_shared_state, + pass_rect, pass_rect, child_pass_id, false, @@ -719,7 +919,6 @@ TYPED_TEST(RendererPixelTest, FastPassSaturateFilter) { EXPECT_TRUE(this->RunPixelTest( &pass_list, - PixelTest::NoOffscreenContext, base::FilePath(FILE_PATH_LITERAL("blue_yellow_alpha.png")), ExactPixelComparator(true))); } @@ -738,42 +937,36 @@ TYPED_TEST(RendererPixelTest, FastPassFilterChain) { CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root); gfx::Transform content_to_target_transform; - scoped_ptr<SharedQuadState> shared_state = - CreateTestSharedQuadState(content_to_target_transform, viewport_rect); + SharedQuadState* shared_state = CreateTestSharedQuadState( + child_pass.get(), content_to_target_transform, viewport_rect); shared_state->opacity = 0.5f; + gfx::Rect blue_rect(0, + 0, + this->device_viewport_size_.width(), + this->device_viewport_size_.height() / 2); scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create(); - blue->SetNew(shared_state.get(), - gfx::Rect(0, - 0, - this->device_viewport_size_.width(), - this->device_viewport_size_.height() / 2), - SK_ColorBLUE, - false); + blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false); + gfx::Rect yellow_rect(0, + this->device_viewport_size_.height() / 2, + this->device_viewport_size_.width(), + this->device_viewport_size_.height() / 2); scoped_ptr<SolidColorDrawQuad> yellow = SolidColorDrawQuad::Create(); - yellow->SetNew(shared_state.get(), - gfx::Rect(0, - this->device_viewport_size_.height() / 2, - this->device_viewport_size_.width(), - this->device_viewport_size_.height() / 2), - SK_ColorYELLOW, - false); + yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false); - scoped_ptr<SharedQuadState> blank_state = - CreateTestSharedQuadState(content_to_target_transform, viewport_rect); + SharedQuadState* blank_state = CreateTestSharedQuadState( + child_pass.get(), content_to_target_transform, viewport_rect); scoped_ptr<SolidColorDrawQuad> white = SolidColorDrawQuad::Create(); - white->SetNew(blank_state.get(), - viewport_rect, - SK_ColorWHITE, - false); + white->SetNew( + blank_state, viewport_rect, viewport_rect, SK_ColorWHITE, false); child_pass->quad_list.push_back(blue.PassAs<DrawQuad>()); child_pass->quad_list.push_back(yellow.PassAs<DrawQuad>()); child_pass->quad_list.push_back(white.PassAs<DrawQuad>()); - scoped_ptr<SharedQuadState> pass_shared_state = - CreateTestSharedQuadState(gfx::Transform(), pass_rect); + SharedQuadState* pass_shared_state = + CreateTestSharedQuadState(root_pass.get(), gfx::Transform(), pass_rect); FilterOperations filters; filters.Append(FilterOperation::CreateGrayscaleFilter(1.f)); @@ -781,7 +974,8 @@ TYPED_TEST(RendererPixelTest, FastPassFilterChain) { scoped_ptr<RenderPassDrawQuad> render_pass_quad = RenderPassDrawQuad::Create(); - render_pass_quad->SetNew(pass_shared_state.get(), + render_pass_quad->SetNew(pass_shared_state, + pass_rect, pass_rect, child_pass_id, false, @@ -799,7 +993,6 @@ TYPED_TEST(RendererPixelTest, FastPassFilterChain) { EXPECT_TRUE(this->RunPixelTest( &pass_list, - PixelTest::NoOffscreenContext, base::FilePath(FILE_PATH_LITERAL("blue_yellow_filter_chain.png")), ExactPixelComparator(true))); } @@ -818,42 +1011,36 @@ TYPED_TEST(RendererPixelTest, FastPassColorFilterAlphaTranslation) { CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root); gfx::Transform content_to_target_transform; - scoped_ptr<SharedQuadState> shared_state = - CreateTestSharedQuadState(content_to_target_transform, viewport_rect); + SharedQuadState* shared_state = CreateTestSharedQuadState( + child_pass.get(), content_to_target_transform, viewport_rect); shared_state->opacity = 0.5f; + gfx::Rect blue_rect(0, + 0, + this->device_viewport_size_.width(), + this->device_viewport_size_.height() / 2); scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create(); - blue->SetNew(shared_state.get(), - gfx::Rect(0, - 0, - this->device_viewport_size_.width(), - this->device_viewport_size_.height() / 2), - SK_ColorBLUE, - false); + blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false); + gfx::Rect yellow_rect(0, + this->device_viewport_size_.height() / 2, + this->device_viewport_size_.width(), + this->device_viewport_size_.height() / 2); scoped_ptr<SolidColorDrawQuad> yellow = SolidColorDrawQuad::Create(); - yellow->SetNew(shared_state.get(), - gfx::Rect(0, - this->device_viewport_size_.height() / 2, - this->device_viewport_size_.width(), - this->device_viewport_size_.height() / 2), - SK_ColorYELLOW, - false); + yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false); - scoped_ptr<SharedQuadState> blank_state = - CreateTestSharedQuadState(content_to_target_transform, viewport_rect); + SharedQuadState* blank_state = CreateTestSharedQuadState( + child_pass.get(), content_to_target_transform, viewport_rect); scoped_ptr<SolidColorDrawQuad> white = SolidColorDrawQuad::Create(); - white->SetNew(blank_state.get(), - viewport_rect, - SK_ColorWHITE, - false); + white->SetNew( + blank_state, viewport_rect, viewport_rect, SK_ColorWHITE, false); child_pass->quad_list.push_back(blue.PassAs<DrawQuad>()); child_pass->quad_list.push_back(yellow.PassAs<DrawQuad>()); child_pass->quad_list.push_back(white.PassAs<DrawQuad>()); - scoped_ptr<SharedQuadState> pass_shared_state = - CreateTestSharedQuadState(gfx::Transform(), pass_rect); + SharedQuadState* pass_shared_state = + CreateTestSharedQuadState(root_pass.get(), gfx::Transform(), pass_rect); SkScalar matrix[20]; float amount = 0.5f; @@ -874,8 +1061,8 @@ TYPED_TEST(RendererPixelTest, FastPassColorFilterAlphaTranslation) { matrix[14] = 1.5f; matrix[15] = matrix[16] = matrix[17] = matrix[19] = 0; matrix[18] = 1; - skia::RefPtr<SkColorFilter> colorFilter(skia::AdoptRef( - new SkColorMatrixFilter(matrix))); + skia::RefPtr<SkColorFilter> colorFilter( + skia::AdoptRef(SkColorMatrixFilter::Create(matrix))); skia::RefPtr<SkImageFilter> filter = skia::AdoptRef(SkColorFilterImageFilter::Create(colorFilter.get(), NULL)); FilterOperations filters; @@ -883,7 +1070,8 @@ TYPED_TEST(RendererPixelTest, FastPassColorFilterAlphaTranslation) { scoped_ptr<RenderPassDrawQuad> render_pass_quad = RenderPassDrawQuad::Create(); - render_pass_quad->SetNew(pass_shared_state.get(), + render_pass_quad->SetNew(pass_shared_state, + pass_rect, pass_rect, child_pass_id, false, @@ -903,7 +1091,6 @@ TYPED_TEST(RendererPixelTest, FastPassColorFilterAlphaTranslation) { // renderer so use a fuzzy comparator. EXPECT_TRUE(this->RunPixelTest( &pass_list, - PixelTest::NoOffscreenContext, base::FilePath(FILE_PATH_LITERAL("blue_yellow_alpha_translate.png")), FuzzyForSoftwareOnlyPixelComparator<TypeParam>(false))); } @@ -922,35 +1109,29 @@ TYPED_TEST(RendererPixelTest, EnlargedRenderPassTexture) { CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root); gfx::Transform content_to_target_transform; - scoped_ptr<SharedQuadState> shared_state = - CreateTestSharedQuadState(content_to_target_transform, viewport_rect); + SharedQuadState* shared_state = CreateTestSharedQuadState( + child_pass.get(), content_to_target_transform, viewport_rect); + gfx::Rect blue_rect(0, + 0, + this->device_viewport_size_.width(), + this->device_viewport_size_.height() / 2); scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create(); - blue->SetNew(shared_state.get(), - gfx::Rect(0, - 0, - this->device_viewport_size_.width(), - this->device_viewport_size_.height() / 2), - SK_ColorBLUE, - false); + blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false); + gfx::Rect yellow_rect(0, + this->device_viewport_size_.height() / 2, + this->device_viewport_size_.width(), + this->device_viewport_size_.height() / 2); scoped_ptr<SolidColorDrawQuad> yellow = SolidColorDrawQuad::Create(); - yellow->SetNew(shared_state.get(), - gfx::Rect(0, - this->device_viewport_size_.height() / 2, - this->device_viewport_size_.width(), - this->device_viewport_size_.height() / 2), - SK_ColorYELLOW, - false); + yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false); child_pass->quad_list.push_back(blue.PassAs<DrawQuad>()); child_pass->quad_list.push_back(yellow.PassAs<DrawQuad>()); - scoped_ptr<SharedQuadState> pass_shared_state = - CreateTestSharedQuadState(gfx::Transform(), pass_rect); - root_pass->quad_list.push_back( - CreateTestRenderPassDrawQuad(pass_shared_state.get(), - pass_rect, - child_pass_id)); + SharedQuadState* pass_shared_state = + CreateTestSharedQuadState(root_pass.get(), gfx::Transform(), pass_rect); + root_pass->quad_list.push_back(CreateTestRenderPassDrawQuad( + pass_shared_state, pass_rect, child_pass_id)); RenderPassList pass_list; pass_list.push_back(child_pass.Pass()); @@ -960,7 +1141,6 @@ TYPED_TEST(RendererPixelTest, EnlargedRenderPassTexture) { EXPECT_TRUE(this->RunPixelTest( &pass_list, - PixelTest::NoOffscreenContext, base::FilePath(FILE_PATH_LITERAL("blue_yellow.png")), ExactPixelComparator(true))); } @@ -979,25 +1159,21 @@ TYPED_TEST(RendererPixelTest, EnlargedRenderPassTextureWithAntiAliasing) { CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root); gfx::Transform content_to_target_transform; - scoped_ptr<SharedQuadState> shared_state = - CreateTestSharedQuadState(content_to_target_transform, viewport_rect); + SharedQuadState* shared_state = CreateTestSharedQuadState( + child_pass.get(), content_to_target_transform, viewport_rect); + gfx::Rect blue_rect(0, + 0, + this->device_viewport_size_.width(), + this->device_viewport_size_.height() / 2); scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create(); - blue->SetNew(shared_state.get(), - gfx::Rect(0, - 0, - this->device_viewport_size_.width(), - this->device_viewport_size_.height() / 2), - SK_ColorBLUE, - false); + blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false); + gfx::Rect yellow_rect(0, + this->device_viewport_size_.height() / 2, + this->device_viewport_size_.width(), + this->device_viewport_size_.height() / 2); scoped_ptr<SolidColorDrawQuad> yellow = SolidColorDrawQuad::Create(); - yellow->SetNew(shared_state.get(), - gfx::Rect(0, - this->device_viewport_size_.height() / 2, - this->device_viewport_size_.width(), - this->device_viewport_size_.height() / 2), - SK_ColorYELLOW, - false); + yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false); child_pass->quad_list.push_back(blue.PassAs<DrawQuad>()); child_pass->quad_list.push_back(yellow.PassAs<DrawQuad>()); @@ -1005,17 +1181,16 @@ TYPED_TEST(RendererPixelTest, EnlargedRenderPassTextureWithAntiAliasing) { gfx::Transform aa_transform; aa_transform.Translate(0.5, 0.0); - scoped_ptr<SharedQuadState> pass_shared_state = - CreateTestSharedQuadState(aa_transform, pass_rect); - root_pass->quad_list.push_back( - CreateTestRenderPassDrawQuad(pass_shared_state.get(), - pass_rect, - child_pass_id)); + SharedQuadState* pass_shared_state = + CreateTestSharedQuadState(root_pass.get(), aa_transform, pass_rect); + root_pass->quad_list.push_back(CreateTestRenderPassDrawQuad( + pass_shared_state, pass_rect, child_pass_id)); - scoped_ptr<SharedQuadState> root_shared_state = - CreateTestSharedQuadState(gfx::Transform(), viewport_rect); + SharedQuadState* root_shared_state = CreateTestSharedQuadState( + root_pass.get(), gfx::Transform(), viewport_rect); scoped_ptr<SolidColorDrawQuad> background = SolidColorDrawQuad::Create(); - background->SetNew(root_shared_state.get(), + background->SetNew(root_shared_state, + gfx::Rect(this->device_viewport_size_), gfx::Rect(this->device_viewport_size_), SK_ColorWHITE, false); @@ -1029,7 +1204,6 @@ TYPED_TEST(RendererPixelTest, EnlargedRenderPassTextureWithAntiAliasing) { EXPECT_TRUE(this->RunPixelTest( &pass_list, - PixelTest::NoOffscreenContext, base::FilePath(FILE_PATH_LITERAL("blue_yellow_anti_aliasing.png")), FuzzyPixelOffByOneComparator(true))); } @@ -1042,39 +1216,38 @@ TYPED_TEST(RendererPixelTest, RenderPassAndMaskWithPartialQuad) { RenderPass::Id root_pass_id(1, 1); scoped_ptr<RenderPass> root_pass = CreateTestRootRenderPass(root_pass_id, viewport_rect); - scoped_ptr<SharedQuadState> root_pass_shared_state = - CreateTestSharedQuadState(gfx::Transform(), viewport_rect); + SharedQuadState* root_pass_shared_state = CreateTestSharedQuadState( + root_pass.get(), gfx::Transform(), viewport_rect); RenderPass::Id child_pass_id(2, 2); gfx::Transform transform_to_root; scoped_ptr<RenderPass> child_pass = CreateTestRenderPass(child_pass_id, viewport_rect, transform_to_root); - scoped_ptr<SharedQuadState> child_pass_shared_state = - CreateTestSharedQuadState(gfx::Transform(), viewport_rect); + SharedQuadState* child_pass_shared_state = CreateTestSharedQuadState( + child_pass.get(), gfx::Transform(), viewport_rect); // The child render pass is just a green box. static const SkColor kCSSGreen = 0xff008000; scoped_ptr<SolidColorDrawQuad> green = SolidColorDrawQuad::Create(); - green->SetNew(child_pass_shared_state.get(), viewport_rect, kCSSGreen, false); + green->SetNew( + child_pass_shared_state, viewport_rect, viewport_rect, kCSSGreen, false); child_pass->quad_list.push_back(green.PassAs<DrawQuad>()); // Make a mask. gfx::Rect mask_rect = viewport_rect; SkBitmap bitmap; - bitmap.setConfig( - SkBitmap::kARGB_8888_Config, mask_rect.width(), mask_rect.height()); - bitmap.allocPixels(); - SkBitmapDevice bitmap_device(bitmap); - skia::RefPtr<SkCanvas> canvas = skia::AdoptRef(new SkCanvas(&bitmap_device)); + bitmap.allocPixels( + SkImageInfo::MakeN32Premul(mask_rect.width(), mask_rect.height())); + SkCanvas canvas(bitmap); SkPaint paint; paint.setStyle(SkPaint::kStroke_Style); paint.setStrokeWidth(SkIntToScalar(4)); paint.setColor(SK_ColorWHITE); - canvas->clear(SK_ColorTRANSPARENT); + canvas.clear(SK_ColorTRANSPARENT); gfx::Rect rect = mask_rect; while (!rect.IsEmpty()) { rect.Inset(6, 6, 4, 4); - canvas->drawRect( + canvas.drawRect( SkRect::MakeXYWH(rect.x(), rect.y(), rect.width(), rect.height()), paint); rect.Inset(6, 6, 4, 4); @@ -1107,7 +1280,8 @@ TYPED_TEST(RendererPixelTest, RenderPassAndMaskWithPartialQuad) { // Set up a mask on the RenderPassDrawQuad. scoped_ptr<RenderPassDrawQuad> mask_quad = RenderPassDrawQuad::Create(); - mask_quad->SetNew(root_pass_shared_state.get(), + mask_quad->SetNew(root_pass_shared_state, + sub_rect, sub_rect, child_pass_id, false, // is_replica @@ -1120,8 +1294,11 @@ TYPED_TEST(RendererPixelTest, RenderPassAndMaskWithPartialQuad) { // White background behind the masked render pass. scoped_ptr<SolidColorDrawQuad> white = SolidColorDrawQuad::Create(); - white->SetNew( - root_pass_shared_state.get(), viewport_rect, SK_ColorWHITE, false); + white->SetNew(root_pass_shared_state, + viewport_rect, + viewport_rect, + SK_ColorWHITE, + false); root_pass->quad_list.push_back(white.PassAs<DrawQuad>()); RenderPassList pass_list; @@ -1130,7 +1307,6 @@ TYPED_TEST(RendererPixelTest, RenderPassAndMaskWithPartialQuad) { EXPECT_TRUE(this->RunPixelTest( &pass_list, - PixelTest::NoOffscreenContext, base::FilePath(FILE_PATH_LITERAL("image_mask_of_layer.png")), ExactPixelComparator(true))); } @@ -1158,87 +1334,87 @@ class RendererPixelTestWithBackgroundFilter // A non-visible quad in the filtering render pass. { - scoped_ptr<SharedQuadState> shared_state = - CreateTestSharedQuadState(identity_content_to_target_transform, + SharedQuadState* shared_state = + CreateTestSharedQuadState(filter_pass.get(), + identity_content_to_target_transform, filter_pass_content_rect_); scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create(); - color_quad->SetNew(shared_state.get(), + color_quad->SetNew(shared_state, + filter_pass_content_rect_, filter_pass_content_rect_, SK_ColorTRANSPARENT, false); filter_pass->quad_list.push_back(color_quad.PassAs<DrawQuad>()); - filter_pass->shared_quad_state_list.push_back(shared_state.Pass()); } { - scoped_ptr<SharedQuadState> shared_state = - CreateTestSharedQuadState(filter_pass_to_target_transform_, + SharedQuadState* shared_state = + CreateTestSharedQuadState(filter_pass.get(), + filter_pass_to_target_transform_, filter_pass_content_rect_); scoped_ptr<RenderPassDrawQuad> filter_pass_quad = RenderPassDrawQuad::Create(); filter_pass_quad->SetNew( - shared_state.get(), + shared_state, + filter_pass_content_rect_, filter_pass_content_rect_, filter_pass_id, - false, // is_replica - 0, // mask_resource_id + false, // is_replica + 0, // mask_resource_id filter_pass_content_rect_, // contents_changed_since_last_frame - gfx::RectF(), // mask_uv_rect - FilterOperations(), // filters + gfx::RectF(), // mask_uv_rect + FilterOperations(), // filters this->background_filters_); root_pass->quad_list.push_back(filter_pass_quad.PassAs<DrawQuad>()); - root_pass->shared_quad_state_list.push_back(shared_state.Pass()); } const int kColumnWidth = device_viewport_rect.width() / 3; gfx::Rect left_rect = gfx::Rect(0, 0, kColumnWidth, 20); for (int i = 0; left_rect.y() < device_viewport_rect.height(); ++i) { - scoped_ptr<SharedQuadState> shared_state = - CreateTestSharedQuadState(identity_content_to_target_transform, - left_rect); + SharedQuadState* shared_state = CreateTestSharedQuadState( + root_pass.get(), identity_content_to_target_transform, left_rect); scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create(); - color_quad->SetNew(shared_state.get(), left_rect, SK_ColorGREEN, false); + color_quad->SetNew( + shared_state, left_rect, left_rect, SK_ColorGREEN, false); root_pass->quad_list.push_back(color_quad.PassAs<DrawQuad>()); - root_pass->shared_quad_state_list.push_back(shared_state.Pass()); left_rect += gfx::Vector2d(0, left_rect.height() + 1); } gfx::Rect middle_rect = gfx::Rect(kColumnWidth+1, 0, kColumnWidth, 20); for (int i = 0; middle_rect.y() < device_viewport_rect.height(); ++i) { - scoped_ptr<SharedQuadState> shared_state = - CreateTestSharedQuadState(identity_content_to_target_transform, - middle_rect); + SharedQuadState* shared_state = CreateTestSharedQuadState( + root_pass.get(), identity_content_to_target_transform, middle_rect); scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create(); - color_quad->SetNew(shared_state.get(), middle_rect, SK_ColorRED, false); + color_quad->SetNew( + shared_state, middle_rect, middle_rect, SK_ColorRED, false); root_pass->quad_list.push_back(color_quad.PassAs<DrawQuad>()); - root_pass->shared_quad_state_list.push_back(shared_state.Pass()); middle_rect += gfx::Vector2d(0, middle_rect.height() + 1); } gfx::Rect right_rect = gfx::Rect((kColumnWidth+1)*2, 0, kColumnWidth, 20); for (int i = 0; right_rect.y() < device_viewport_rect.height(); ++i) { - scoped_ptr<SharedQuadState> shared_state = - CreateTestSharedQuadState(identity_content_to_target_transform, - right_rect); + SharedQuadState* shared_state = CreateTestSharedQuadState( + root_pass.get(), identity_content_to_target_transform, right_rect); scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create(); - color_quad->SetNew(shared_state.get(), right_rect, SK_ColorBLUE, false); + color_quad->SetNew( + shared_state, right_rect, right_rect, SK_ColorBLUE, false); root_pass->quad_list.push_back(color_quad.PassAs<DrawQuad>()); - root_pass->shared_quad_state_list.push_back(shared_state.Pass()); right_rect += gfx::Vector2d(0, right_rect.height() + 1); } - scoped_ptr<SharedQuadState> shared_state = - CreateTestSharedQuadState(identity_content_to_target_transform, + SharedQuadState* shared_state = + CreateTestSharedQuadState(root_pass.get(), + identity_content_to_target_transform, device_viewport_rect); scoped_ptr<SolidColorDrawQuad> background_quad = SolidColorDrawQuad::Create(); - background_quad->SetNew(shared_state.get(), + background_quad->SetNew(shared_state, + device_viewport_rect, device_viewport_rect, SK_ColorWHITE, false); root_pass->quad_list.push_back(background_quad.PassAs<DrawQuad>()); - root_pass->shared_quad_state_list.push_back(shared_state.Pass()); pass_list_.push_back(filter_pass.Pass()); pass_list_.push_back(root_pass.Pass()); @@ -1269,7 +1445,6 @@ TEST_F(GLRendererPixelTestWithBackgroundFilter, InvertFilter) { this->SetUpRenderPassList(); EXPECT_TRUE(this->RunPixelTest( &this->pass_list_, - PixelTest::WithOffscreenContext, base::FilePath(FILE_PATH_LITERAL("background_filter.png")), ExactPixelComparator(true))); } @@ -1277,35 +1452,32 @@ TEST_F(GLRendererPixelTestWithBackgroundFilter, InvertFilter) { class ExternalStencilPixelTest : public GLRendererPixelTest { protected: void ClearBackgroundToGreen() { - blink::WebGraphicsContext3D* context3d = - output_surface_->context_provider()->Context3d(); + GLES2Interface* gl = output_surface_->context_provider()->ContextGL(); output_surface_->EnsureBackbuffer(); output_surface_->Reshape(device_viewport_size_, 1); - context3d->clearColor(0.f, 1.f, 0.f, 1.f); - context3d->clear(GL_COLOR_BUFFER_BIT); + gl->ClearColor(0.f, 1.f, 0.f, 1.f); + gl->Clear(GL_COLOR_BUFFER_BIT); } void PopulateStencilBuffer() { // Set two quadrants of the stencil buffer to 1. - blink::WebGraphicsContext3D* context3d = - output_surface_->context_provider()->Context3d(); - ASSERT_TRUE(context3d->getContextAttributes().stencil); + GLES2Interface* gl = output_surface_->context_provider()->ContextGL(); output_surface_->EnsureBackbuffer(); output_surface_->Reshape(device_viewport_size_, 1); - context3d->clearStencil(0); - context3d->clear(GL_STENCIL_BUFFER_BIT); - context3d->enable(GL_SCISSOR_TEST); - context3d->clearStencil(1); - context3d->scissor(0, - 0, - device_viewport_size_.width() / 2, - device_viewport_size_.height() / 2); - context3d->clear(GL_STENCIL_BUFFER_BIT); - context3d->scissor(device_viewport_size_.width() / 2, - device_viewport_size_.height() / 2, - device_viewport_size_.width(), - device_viewport_size_.height()); - context3d->clear(GL_STENCIL_BUFFER_BIT); + gl->ClearStencil(0); + gl->Clear(GL_STENCIL_BUFFER_BIT); + gl->Enable(GL_SCISSOR_TEST); + gl->ClearStencil(1); + gl->Scissor(0, + 0, + device_viewport_size_.width() / 2, + device_viewport_size_.height() / 2); + gl->Clear(GL_STENCIL_BUFFER_BIT); + gl->Scissor(device_viewport_size_.width() / 2, + device_viewport_size_.height() / 2, + device_viewport_size_.width(), + device_viewport_size_.height()); + gl->Clear(GL_STENCIL_BUFFER_BIT); } }; @@ -1319,10 +1491,10 @@ TEST_F(ExternalStencilPixelTest, StencilTestEnabled) { gfx::Rect rect(this->device_viewport_size_); RenderPass::Id id(1, 1); scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); - scoped_ptr<SharedQuadState> blue_shared_state = - CreateTestSharedQuadState(gfx::Transform(), rect); + SharedQuadState* blue_shared_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect); scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create(); - blue->SetNew(blue_shared_state.get(), rect, SK_ColorBLUE, false); + blue->SetNew(blue_shared_state, rect, rect, SK_ColorBLUE, false); pass->quad_list.push_back(blue.PassAs<DrawQuad>()); pass->has_transparent_background = false; RenderPassList pass_list; @@ -1330,7 +1502,6 @@ TEST_F(ExternalStencilPixelTest, StencilTestEnabled) { EXPECT_TRUE(this->RunPixelTest( &pass_list, - PixelTest::NoOffscreenContext, base::FilePath(FILE_PATH_LITERAL("four_blue_green_checkers.png")), ExactPixelComparator(true))); } @@ -1343,17 +1514,16 @@ TEST_F(ExternalStencilPixelTest, StencilTestDisabled) { gfx::Rect rect(this->device_viewport_size_); RenderPass::Id id(1, 1); scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); - scoped_ptr<SharedQuadState> green_shared_state = - CreateTestSharedQuadState(gfx::Transform(), rect); + SharedQuadState* green_shared_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect); scoped_ptr<SolidColorDrawQuad> green = SolidColorDrawQuad::Create(); - green->SetNew(green_shared_state.get(), rect, SK_ColorGREEN, false); + green->SetNew(green_shared_state, rect, rect, SK_ColorGREEN, false); pass->quad_list.push_back(green.PassAs<DrawQuad>()); RenderPassList pass_list; pass_list.push_back(pass.Pass()); EXPECT_TRUE(this->RunPixelTest( &pass_list, - PixelTest::NoOffscreenContext, base::FilePath(FILE_PATH_LITERAL("green.png")), ExactPixelComparator(true))); } @@ -1378,32 +1548,27 @@ TEST_F(ExternalStencilPixelTest, RenderSurfacesIgnoreStencil) { CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root); gfx::Transform content_to_target_transform; - scoped_ptr<SharedQuadState> shared_state = - CreateTestSharedQuadState(content_to_target_transform, viewport_rect); + SharedQuadState* shared_state = CreateTestSharedQuadState( + child_pass.get(), content_to_target_transform, viewport_rect); + gfx::Rect blue_rect(0, + 0, + this->device_viewport_size_.width(), + this->device_viewport_size_.height()); scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create(); - blue->SetNew(shared_state.get(), - gfx::Rect(0, - 0, - this->device_viewport_size_.width(), - this->device_viewport_size_.height()), - SK_ColorBLUE, - false); + blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false); child_pass->quad_list.push_back(blue.PassAs<DrawQuad>()); - scoped_ptr<SharedQuadState> pass_shared_state = - CreateTestSharedQuadState(gfx::Transform(), pass_rect); - root_pass->quad_list.push_back( - CreateTestRenderPassDrawQuad(pass_shared_state.get(), - pass_rect, - child_pass_id)); + SharedQuadState* pass_shared_state = + CreateTestSharedQuadState(root_pass.get(), gfx::Transform(), pass_rect); + root_pass->quad_list.push_back(CreateTestRenderPassDrawQuad( + pass_shared_state, pass_rect, child_pass_id)); RenderPassList pass_list; pass_list.push_back(child_pass.Pass()); pass_list.push_back(root_pass.Pass()); EXPECT_TRUE(this->RunPixelTest( &pass_list, - PixelTest::NoOffscreenContext, base::FilePath(FILE_PATH_LITERAL("four_blue_green_checkers.png")), ExactPixelComparator(true))); } @@ -1418,17 +1583,16 @@ TEST_F(ExternalStencilPixelTest, DeviceClip) { gfx::Rect rect(this->device_viewport_size_); RenderPass::Id id(1, 1); scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); - scoped_ptr<SharedQuadState> blue_shared_state = - CreateTestSharedQuadState(gfx::Transform(), rect); + SharedQuadState* blue_shared_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect); scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create(); - blue->SetNew(blue_shared_state.get(), rect, SK_ColorBLUE, false); + blue->SetNew(blue_shared_state, rect, rect, SK_ColorBLUE, false); pass->quad_list.push_back(blue.PassAs<DrawQuad>()); RenderPassList pass_list; pass_list.push_back(pass.Pass()); EXPECT_TRUE(this->RunPixelTest( &pass_list, - PixelTest::NoOffscreenContext, base::FilePath(FILE_PATH_LITERAL("green_with_blue_corner.png")), ExactPixelComparator(true))); } @@ -1442,30 +1606,30 @@ TEST_F(GLRendererPixelTest, AntiAliasing) { gfx::Transform red_content_to_target_transform; red_content_to_target_transform.Rotate(10); - scoped_ptr<SharedQuadState> red_shared_state = - CreateTestSharedQuadState(red_content_to_target_transform, rect); + SharedQuadState* red_shared_state = CreateTestSharedQuadState( + pass.get(), red_content_to_target_transform, rect); scoped_ptr<SolidColorDrawQuad> red = SolidColorDrawQuad::Create(); - red->SetNew(red_shared_state.get(), rect, SK_ColorRED, false); + red->SetNew(red_shared_state, rect, rect, SK_ColorRED, false); pass->quad_list.push_back(red.PassAs<DrawQuad>()); gfx::Transform yellow_content_to_target_transform; yellow_content_to_target_transform.Rotate(5); - scoped_ptr<SharedQuadState> yellow_shared_state = - CreateTestSharedQuadState(yellow_content_to_target_transform, rect); + SharedQuadState* yellow_shared_state = CreateTestSharedQuadState( + pass.get(), yellow_content_to_target_transform, rect); scoped_ptr<SolidColorDrawQuad> yellow = SolidColorDrawQuad::Create(); - yellow->SetNew(yellow_shared_state.get(), rect, SK_ColorYELLOW, false); + yellow->SetNew(yellow_shared_state, rect, rect, SK_ColorYELLOW, false); pass->quad_list.push_back(yellow.PassAs<DrawQuad>()); gfx::Transform blue_content_to_target_transform; - scoped_ptr<SharedQuadState> blue_shared_state = - CreateTestSharedQuadState(blue_content_to_target_transform, rect); + SharedQuadState* blue_shared_state = CreateTestSharedQuadState( + pass.get(), blue_content_to_target_transform, rect); scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create(); - blue->SetNew(blue_shared_state.get(), rect, SK_ColorBLUE, false); + blue->SetNew(blue_shared_state, rect, rect, SK_ColorBLUE, false); pass->quad_list.push_back(blue.PassAs<DrawQuad>()); @@ -1474,7 +1638,6 @@ TEST_F(GLRendererPixelTest, AntiAliasing) { EXPECT_TRUE(this->RunPixelTest( &pass_list, - PixelTest::NoOffscreenContext, base::FilePath(FILE_PATH_LITERAL("anti_aliasing.png")), FuzzyPixelOffByOneComparator(true))); } @@ -1494,31 +1657,31 @@ TEST_F(GLRendererPixelTest, AxisAligned) { red_content_to_target_transform.Scale( 0.5f + 1.0f / (rect.width() * 2.0f), 0.5f + 1.0f / (rect.height() * 2.0f)); - scoped_ptr<SharedQuadState> red_shared_state = - CreateTestSharedQuadState(red_content_to_target_transform, rect); + SharedQuadState* red_shared_state = CreateTestSharedQuadState( + pass.get(), red_content_to_target_transform, rect); scoped_ptr<SolidColorDrawQuad> red = SolidColorDrawQuad::Create(); - red->SetNew(red_shared_state.get(), rect, SK_ColorRED, false); + red->SetNew(red_shared_state, rect, rect, SK_ColorRED, false); pass->quad_list.push_back(red.PassAs<DrawQuad>()); gfx::Transform yellow_content_to_target_transform; yellow_content_to_target_transform.Translate(25.5f, 25.5f); yellow_content_to_target_transform.Scale(0.5f, 0.5f); - scoped_ptr<SharedQuadState> yellow_shared_state = - CreateTestSharedQuadState(yellow_content_to_target_transform, rect); + SharedQuadState* yellow_shared_state = CreateTestSharedQuadState( + pass.get(), yellow_content_to_target_transform, rect); scoped_ptr<SolidColorDrawQuad> yellow = SolidColorDrawQuad::Create(); - yellow->SetNew(yellow_shared_state.get(), rect, SK_ColorYELLOW, false); + yellow->SetNew(yellow_shared_state, rect, rect, SK_ColorYELLOW, false); pass->quad_list.push_back(yellow.PassAs<DrawQuad>()); gfx::Transform blue_content_to_target_transform; - scoped_ptr<SharedQuadState> blue_shared_state = - CreateTestSharedQuadState(blue_content_to_target_transform, rect); + SharedQuadState* blue_shared_state = CreateTestSharedQuadState( + pass.get(), blue_content_to_target_transform, rect); scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create(); - blue->SetNew(blue_shared_state.get(), rect, SK_ColorBLUE, false); + blue->SetNew(blue_shared_state, rect, rect, SK_ColorBLUE, false); pass->quad_list.push_back(blue.PassAs<DrawQuad>()); @@ -1527,7 +1690,6 @@ TEST_F(GLRendererPixelTest, AxisAligned) { EXPECT_TRUE(this->RunPixelTest( &pass_list, - PixelTest::NoOffscreenContext, base::FilePath(FILE_PATH_LITERAL("axis_aligned.png")), ExactPixelComparator(true))); } @@ -1547,20 +1709,20 @@ TEST_F(GLRendererPixelTest, ForceAntiAliasingOff) { hole_content_to_target_transform.Scale( 0.5f + 1.0f / (rect.width() * 2.0f), 0.5f + 1.0f / (rect.height() * 2.0f)); - scoped_ptr<SharedQuadState> hole_shared_state = - CreateTestSharedQuadState(hole_content_to_target_transform, rect); + SharedQuadState* hole_shared_state = CreateTestSharedQuadState( + pass.get(), hole_content_to_target_transform, rect); scoped_ptr<SolidColorDrawQuad> hole = SolidColorDrawQuad::Create(); - hole->SetAll(hole_shared_state.get(), rect, rect, rect, false, - SK_ColorTRANSPARENT, true); + hole->SetAll( + hole_shared_state, rect, rect, rect, false, SK_ColorTRANSPARENT, true); pass->quad_list.push_back(hole.PassAs<DrawQuad>()); gfx::Transform green_content_to_target_transform; - scoped_ptr<SharedQuadState> green_shared_state = - CreateTestSharedQuadState(green_content_to_target_transform, rect); + SharedQuadState* green_shared_state = CreateTestSharedQuadState( + pass.get(), green_content_to_target_transform, rect); scoped_ptr<SolidColorDrawQuad> green = SolidColorDrawQuad::Create(); - green->SetNew(green_shared_state.get(), rect, SK_ColorGREEN, false); + green->SetNew(green_shared_state, rect, rect, SK_ColorGREEN, false); pass->quad_list.push_back(green.PassAs<DrawQuad>()); @@ -1569,7 +1731,6 @@ TEST_F(GLRendererPixelTest, ForceAntiAliasingOff) { EXPECT_TRUE(this->RunPixelTest( &pass_list, - PixelTest::NoOffscreenContext, base::FilePath(FILE_PATH_LITERAL("force_anti_aliasing_off.png")), ExactPixelComparator(false))); } @@ -1586,23 +1747,24 @@ TEST_F(GLRendererPixelTest, AntiAliasingPerspective) { 0.0f, 0.3528f, 5.9737f, 9.5f, 0.0f, -0.2250f, -0.9744f, 0.0f, 0.0f, 0.0225f, 0.0974f, 1.0f); - scoped_ptr<SharedQuadState> red_shared_state = - CreateTestSharedQuadState(red_content_to_target_transform, red_rect); + SharedQuadState* red_shared_state = CreateTestSharedQuadState( + pass.get(), red_content_to_target_transform, red_rect); scoped_ptr<SolidColorDrawQuad> red = SolidColorDrawQuad::Create(); - red->SetNew(red_shared_state.get(), red_rect, SK_ColorRED, false); + red->SetNew(red_shared_state, red_rect, red_rect, SK_ColorRED, false); pass->quad_list.push_back(red.PassAs<DrawQuad>()); gfx::Rect green_rect(19, 7, 180, 10); - scoped_ptr<SharedQuadState> green_shared_state = - CreateTestSharedQuadState(gfx::Transform(), green_rect); + SharedQuadState* green_shared_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), green_rect); scoped_ptr<SolidColorDrawQuad> green = SolidColorDrawQuad::Create(); - green->SetNew(green_shared_state.get(), green_rect, SK_ColorGREEN, false); + green->SetNew( + green_shared_state, green_rect, green_rect, SK_ColorGREEN, false); pass->quad_list.push_back(green.PassAs<DrawQuad>()); - scoped_ptr<SharedQuadState> blue_shared_state = - CreateTestSharedQuadState(gfx::Transform(), rect); + SharedQuadState* blue_shared_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect); scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create(); - blue->SetNew(blue_shared_state.get(), rect, SK_ColorBLUE, false); + blue->SetNew(blue_shared_state, rect, rect, SK_ColorBLUE, false); pass->quad_list.push_back(blue.PassAs<DrawQuad>()); RenderPassList pass_list; @@ -1610,7 +1772,6 @@ TEST_F(GLRendererPixelTest, AntiAliasingPerspective) { EXPECT_TRUE(this->RunPixelTest( &pass_list, - PixelTest::NoOffscreenContext, base::FilePath(FILE_PATH_LITERAL("anti_aliasing_perspective.png")), FuzzyPixelOffByOneComparator(true))); } @@ -1645,22 +1806,24 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadIdentityScale) { blue_content_to_target_transform.Translate(offset.x(), offset.y()); gfx::RectF blue_scissor_rect = blue_clip_rect; blue_content_to_target_transform.TransformRect(&blue_scissor_rect); - scoped_ptr<SharedQuadState> blue_shared_state = - CreateTestSharedQuadStateClipped(blue_content_to_target_transform, + SharedQuadState* blue_shared_state = + CreateTestSharedQuadStateClipped(pass.get(), + blue_content_to_target_transform, blue_rect, gfx::ToEnclosingRect(blue_scissor_rect)); scoped_ptr<PictureDrawQuad> blue_quad = PictureDrawQuad::Create(); - blue_quad->SetNew(blue_shared_state.get(), + blue_quad->SetNew(blue_shared_state, viewport, // Intentionally bigger than clip. gfx::Rect(), viewport, + gfx::RectF(viewport), viewport.size(), texture_format, viewport, 1.f, - blue_pile); + PicturePileImpl::CreateFromOther(blue_pile)); pass->quad_list.push_back(blue_quad.PassAs<DrawQuad>()); // One viewport-filling green quad. @@ -1672,19 +1835,20 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadIdentityScale) { green_pile->RerecordPile(); gfx::Transform green_content_to_target_transform; - scoped_ptr<SharedQuadState> green_shared_state = - CreateTestSharedQuadState(green_content_to_target_transform, viewport); + SharedQuadState* green_shared_state = CreateTestSharedQuadState( + pass.get(), green_content_to_target_transform, viewport); scoped_ptr<PictureDrawQuad> green_quad = PictureDrawQuad::Create(); - green_quad->SetNew(green_shared_state.get(), + green_quad->SetNew(green_shared_state, viewport, gfx::Rect(), + viewport, gfx::RectF(0.f, 0.f, 1.f, 1.f), viewport.size(), texture_format, viewport, 1.f, - green_pile); + PicturePileImpl::CreateFromOther(green_pile)); pass->quad_list.push_back(green_quad.PassAs<DrawQuad>()); RenderPassList pass_list; @@ -1692,7 +1856,6 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadIdentityScale) { EXPECT_TRUE(this->RunPixelTest( &pass_list, - PixelTest::NoOffscreenContext, base::FilePath(FILE_PATH_LITERAL("green_with_blue_corner.png")), ExactPixelComparator(true))); } @@ -1717,20 +1880,21 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadOpacity) { green_pile->RerecordPile(); gfx::Transform green_content_to_target_transform; - scoped_ptr<SharedQuadState> green_shared_state = - CreateTestSharedQuadState(green_content_to_target_transform, viewport); + SharedQuadState* green_shared_state = CreateTestSharedQuadState( + pass.get(), green_content_to_target_transform, viewport); green_shared_state->opacity = 0.5f; scoped_ptr<PictureDrawQuad> green_quad = PictureDrawQuad::Create(); - green_quad->SetNew(green_shared_state.get(), + green_quad->SetNew(green_shared_state, viewport, gfx::Rect(), + viewport, gfx::RectF(0, 0, 1, 1), viewport.size(), texture_format, viewport, 1.f, - green_pile); + PicturePileImpl::CreateFromOther(green_pile)); pass->quad_list.push_back(green_quad.PassAs<DrawQuad>()); // One viewport-filling white quad. @@ -1742,19 +1906,20 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadOpacity) { white_pile->RerecordPile(); gfx::Transform white_content_to_target_transform; - scoped_ptr<SharedQuadState> white_shared_state = - CreateTestSharedQuadState(white_content_to_target_transform, viewport); + SharedQuadState* white_shared_state = CreateTestSharedQuadState( + pass.get(), white_content_to_target_transform, viewport); scoped_ptr<PictureDrawQuad> white_quad = PictureDrawQuad::Create(); - white_quad->SetNew(white_shared_state.get(), + white_quad->SetNew(white_shared_state, viewport, gfx::Rect(), + viewport, gfx::RectF(0, 0, 1, 1), viewport.size(), texture_format, viewport, 1.f, - white_pile); + PicturePileImpl::CreateFromOther(white_pile)); pass->quad_list.push_back(white_quad.PassAs<DrawQuad>()); RenderPassList pass_list; @@ -1762,7 +1927,6 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadOpacity) { EXPECT_TRUE(this->RunPixelTest( &pass_list, - PixelTest::NoOffscreenContext, base::FilePath(FILE_PATH_LITERAL("green_alpha.png")), FuzzyPixelOffByOneComparator(true))); } @@ -1799,8 +1963,7 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadDisableImageFiltering) { CreateTestRenderPass(id, viewport, transform_to_root); SkBitmap bitmap; - bitmap.setConfig(SkBitmap::kARGB_8888_Config, 2, 2); - bitmap.allocPixels(); + bitmap.allocN32Pixels(2, 2); { SkAutoLockPixels lock(bitmap); SkCanvas canvas(bitmap); @@ -1818,19 +1981,20 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadDisableImageFiltering) { pile->RerecordPile(); gfx::Transform content_to_target_transform; - scoped_ptr<SharedQuadState> shared_state = - CreateTestSharedQuadState(content_to_target_transform, viewport); + SharedQuadState* shared_state = CreateTestSharedQuadState( + pass.get(), content_to_target_transform, viewport); scoped_ptr<PictureDrawQuad> quad = PictureDrawQuad::Create(); - quad->SetNew(shared_state.get(), - viewport, - gfx::Rect(), - gfx::RectF(0, 0, 2, 2), - viewport.size(), - texture_format, - viewport, - 1.f, - pile); + quad->SetNew(shared_state, + viewport, + gfx::Rect(), + viewport, + gfx::RectF(0, 0, 2, 2), + viewport.size(), + texture_format, + viewport, + 1.f, + PicturePileImpl::CreateFromOther(pile)); pass->quad_list.push_back(quad.PassAs<DrawQuad>()); RenderPassList pass_list; @@ -1840,7 +2004,6 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadDisableImageFiltering) { EXPECT_TRUE(this->RunPixelTest( &pass_list, - PixelTest::NoOffscreenContext, base::FilePath(FILE_PATH_LITERAL("four_blue_green_checkers.png")), ExactPixelComparator(true))); } @@ -1874,31 +2037,34 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadNonIdentityScale) { green_pile->add_draw_rect_with_paint(green_rect2, green_paint); green_pile->RerecordPile(); - scoped_ptr<SharedQuadState> top_right_green_shared_quad_state = - CreateTestSharedQuadState(green_content_to_target_transform, viewport); + SharedQuadState* top_right_green_shared_quad_state = + CreateTestSharedQuadState( + pass.get(), green_content_to_target_transform, viewport); scoped_ptr<PictureDrawQuad> green_quad1 = PictureDrawQuad::Create(); - green_quad1->SetNew(top_right_green_shared_quad_state.get(), + green_quad1->SetNew(top_right_green_shared_quad_state, green_rect1, gfx::Rect(), + green_rect1, gfx::RectF(green_rect1.size()), green_rect1.size(), texture_format, green_rect1, 1.f, - green_pile); + PicturePileImpl::CreateFromOther(green_pile)); pass->quad_list.push_back(green_quad1.PassAs<DrawQuad>()); scoped_ptr<PictureDrawQuad> green_quad2 = PictureDrawQuad::Create(); - green_quad2->SetNew(top_right_green_shared_quad_state.get(), + green_quad2->SetNew(top_right_green_shared_quad_state, green_rect2, gfx::Rect(), + green_rect2, gfx::RectF(green_rect2.size()), green_rect2.size(), texture_format, green_rect2, 1.f, - green_pile); + PicturePileImpl::CreateFromOther(green_pile)); pass->quad_list.push_back(green_quad2.PassAs<DrawQuad>()); // Add a green clipped checkerboard in the bottom right to help test @@ -1906,13 +2072,18 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadNonIdentityScale) { gfx::Rect bottom_right_rect( gfx::Point(viewport.width() / 2, viewport.height() / 2), gfx::Size(viewport.width() / 2, viewport.height() / 2)); - scoped_ptr<SharedQuadState> bottom_right_green_shared_state = - CreateTestSharedQuadStateClipped( - green_content_to_target_transform, viewport, bottom_right_rect); + SharedQuadState* bottom_right_green_shared_state = + CreateTestSharedQuadStateClipped(pass.get(), + green_content_to_target_transform, + viewport, + bottom_right_rect); scoped_ptr<SolidColorDrawQuad> bottom_right_color_quad = SolidColorDrawQuad::Create(); - bottom_right_color_quad->SetNew( - bottom_right_green_shared_state.get(), viewport, SK_ColorGREEN, false); + bottom_right_color_quad->SetNew(bottom_right_green_shared_state, + viewport, + viewport, + SK_ColorGREEN, + false); pass->quad_list.push_back(bottom_right_color_quad.PassAs<DrawQuad>()); // Add two blue checkerboards taking up the bottom left and top right, @@ -1957,30 +2128,33 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadNonIdentityScale) { gfx::Transform content_to_target_transform; content_to_target_transform.Scale(10.0, 10.0); gfx::Rect quad_content_rect(gfx::Size(20, 20)); - scoped_ptr<SharedQuadState> blue_shared_state = - CreateTestSharedQuadState(content_to_target_transform, quad_content_rect); + SharedQuadState* blue_shared_state = CreateTestSharedQuadState( + pass.get(), content_to_target_transform, quad_content_rect); scoped_ptr<PictureDrawQuad> blue_quad = PictureDrawQuad::Create(); - blue_quad->SetNew(blue_shared_state.get(), + blue_quad->SetNew(blue_shared_state, quad_content_rect, gfx::Rect(), quad_content_rect, + gfx::RectF(quad_content_rect), content_union_rect.size(), texture_format, content_union_rect, contents_scale, - pile); + PicturePileImpl::CreateFromOther(pile)); pass->quad_list.push_back(blue_quad.PassAs<DrawQuad>()); // Fill left half of viewport with green. gfx::Transform half_green_content_to_target_transform; gfx::Rect half_green_rect(gfx::Size(viewport.width() / 2, viewport.height())); - scoped_ptr<SharedQuadState> half_green_shared_state = - CreateTestSharedQuadState(half_green_content_to_target_transform, - half_green_rect); + SharedQuadState* half_green_shared_state = CreateTestSharedQuadState( + pass.get(), half_green_content_to_target_transform, half_green_rect); scoped_ptr<SolidColorDrawQuad> half_color_quad = SolidColorDrawQuad::Create(); - half_color_quad->SetNew( - half_green_shared_state.get(), half_green_rect, SK_ColorGREEN, false); + half_color_quad->SetNew(half_green_shared_state, + half_green_rect, + half_green_rect, + SK_ColorGREEN, + false); pass->quad_list.push_back(half_color_quad.PassAs<DrawQuad>()); RenderPassList pass_list; @@ -1988,7 +2162,6 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadNonIdentityScale) { EXPECT_TRUE(this->RunPixelTest( &pass_list, - PixelTest::NoOffscreenContext, base::FilePath(FILE_PATH_LITERAL("four_blue_green_checkers.png")), ExactPixelComparator(true))); } @@ -1999,8 +2172,8 @@ TYPED_TEST(RendererPixelTest, WrapModeRepeat) { RenderPass::Id id(1, 1); scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); - scoped_ptr<SharedQuadState> shared_state = - CreateTestSharedQuadState(gfx::Transform(), rect); + SharedQuadState* shared_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect); gfx::Rect texture_rect(4, 4); SkPMColor colors[4] = { @@ -2031,13 +2204,14 @@ TYPED_TEST(RendererPixelTest, WrapModeRepeat) { float vertex_opacity[4] = {1.0f, 1.0f, 1.0f, 1.0f}; scoped_ptr<TextureDrawQuad> texture_quad = TextureDrawQuad::Create(); texture_quad->SetNew( - shared_state.get(), + shared_state, gfx::Rect(this->device_viewport_size_), gfx::Rect(), + gfx::Rect(this->device_viewport_size_), resource, - true, // premultiplied_alpha + true, // premultiplied_alpha gfx::PointF(0.0f, 0.0f), // uv_top_left - gfx::PointF( // uv_bottom_right + gfx::PointF( // uv_bottom_right this->device_viewport_size_.width() / texture_rect.width(), this->device_viewport_size_.height() / texture_rect.height()), SK_ColorWHITE, @@ -2050,7 +2224,6 @@ TYPED_TEST(RendererPixelTest, WrapModeRepeat) { EXPECT_TRUE(this->RunPixelTest( &pass_list, - PixelTest::NoOffscreenContext, base::FilePath(FILE_PATH_LITERAL("wrap_mode_repeat.png")), FuzzyPixelOffByOneComparator(true))); } |