diff options
45 files changed, 1220 insertions, 646 deletions
diff --git a/cc/checkerboard_draw_quad.cc b/cc/checkerboard_draw_quad.cc index 892d2bd..9dca587 100644 --- a/cc/checkerboard_draw_quad.cc +++ b/cc/checkerboard_draw_quad.cc @@ -8,24 +8,38 @@ namespace cc { -scoped_ptr<CheckerboardDrawQuad> CheckerboardDrawQuad::create(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, SkColor color) -{ - return make_scoped_ptr(new CheckerboardDrawQuad(sharedQuadState, quadRect, color)); +CheckerboardDrawQuad::CheckerboardDrawQuad() : color(0) {} + +scoped_ptr<CheckerboardDrawQuad> CheckerboardDrawQuad::Create() { + return make_scoped_ptr(new CheckerboardDrawQuad); +} + +void CheckerboardDrawQuad::SetNew(const SharedQuadState* shared_quad_state, + gfx::Rect rect, + SkColor color) { + gfx::Rect opaque_rect = SkColorGetA(color) == 255 ? rect : gfx::Rect(); + gfx::Rect visible_rect = rect; + bool needs_blending = false; + DrawQuad::SetAll(shared_quad_state, DrawQuad::CHECKERBOARD, rect, opaque_rect, + visible_rect, needs_blending); + this->color = color; } -CheckerboardDrawQuad::CheckerboardDrawQuad(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, SkColor color) - : m_color(color) -{ - gfx::Rect opaqueRect = SkColorGetA(m_color) == 255 ? quadRect : gfx::Rect(); - gfx::Rect visibleRect = quadRect; - bool needsBlending = false; - DrawQuad::SetAll(sharedQuadState, DrawQuad::CHECKERBOARD, quadRect, opaqueRect, visibleRect, needsBlending); +void CheckerboardDrawQuad::SetAll(const SharedQuadState* shared_quad_state, + gfx::Rect rect, + gfx::Rect opaque_rect, + gfx::Rect visible_rect, + bool needs_blending, + SkColor color) { + DrawQuad::SetAll(shared_quad_state, DrawQuad::CHECKERBOARD, rect, opaque_rect, + visible_rect, needs_blending); + this->color = color; } -const CheckerboardDrawQuad* CheckerboardDrawQuad::materialCast(const DrawQuad* quad) -{ - DCHECK(quad->material == DrawQuad::CHECKERBOARD); - return static_cast<const CheckerboardDrawQuad*>(quad); +const CheckerboardDrawQuad* CheckerboardDrawQuad::MaterialCast( + const DrawQuad* quad) { + DCHECK(quad->material == DrawQuad::CHECKERBOARD); + return static_cast<const CheckerboardDrawQuad*>(quad); } } // namespace cc diff --git a/cc/checkerboard_draw_quad.h b/cc/checkerboard_draw_quad.h index 2306c1c..5f1c83e 100644 --- a/cc/checkerboard_draw_quad.h +++ b/cc/checkerboard_draw_quad.h @@ -13,16 +13,25 @@ namespace cc { class CC_EXPORT CheckerboardDrawQuad : public DrawQuad { -public: - static scoped_ptr<CheckerboardDrawQuad> create(const SharedQuadState*, const gfx::Rect&, SkColor); + public: + static scoped_ptr<CheckerboardDrawQuad> Create(); - SkColor color() const { return m_color; }; + void SetNew(const SharedQuadState* shared_quad_state, + gfx::Rect rect, + SkColor color); - static const CheckerboardDrawQuad* materialCast(const DrawQuad*); -private: - CheckerboardDrawQuad(const SharedQuadState*, const gfx::Rect&, SkColor); + void SetAll(const SharedQuadState* shared_quad_state, + gfx::Rect rect, + gfx::Rect opaque_rect, + gfx::Rect visible_rect, + bool needs_blending, + SkColor color); - SkColor m_color; + SkColor color; + + static const CheckerboardDrawQuad* MaterialCast(const DrawQuad*); + private: + CheckerboardDrawQuad(); }; } diff --git a/cc/debug_border_draw_quad.cc b/cc/debug_border_draw_quad.cc index 8009128..fba8b92 100644 --- a/cc/debug_border_draw_quad.cc +++ b/cc/debug_border_draw_quad.cc @@ -8,25 +8,45 @@ namespace cc { -scoped_ptr<DebugBorderDrawQuad> DebugBorderDrawQuad::create(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, SkColor color, int width) -{ - return make_scoped_ptr(new DebugBorderDrawQuad(sharedQuadState, quadRect, color, width)); +DebugBorderDrawQuad::DebugBorderDrawQuad() + : color(0), + width(0) { } -DebugBorderDrawQuad::DebugBorderDrawQuad(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, SkColor color, int width) - : m_color(color) - , m_width(width) -{ - gfx::Rect opaqueRect; - gfx::Rect visibleRect = quadRect; - bool needsBlending = SkColorGetA(m_color) < 255; - DrawQuad::SetAll(sharedQuadState, DrawQuad::DEBUG_BORDER, quadRect, opaqueRect, visibleRect, needsBlending); +scoped_ptr<DebugBorderDrawQuad> DebugBorderDrawQuad::Create() { + return make_scoped_ptr(new DebugBorderDrawQuad); } -const DebugBorderDrawQuad* DebugBorderDrawQuad::materialCast(const DrawQuad* quad) -{ - DCHECK(quad->material == DrawQuad::DEBUG_BORDER); - return static_cast<const DebugBorderDrawQuad*>(quad); +void DebugBorderDrawQuad::SetNew(const SharedQuadState* shared_quad_state, + gfx::Rect rect, + SkColor color, + int width) { + gfx::Rect opaque_rect; + gfx::Rect visible_rect = rect; + bool needs_blending = SkColorGetA(color) < 255; + DrawQuad::SetAll(shared_quad_state, DrawQuad::DEBUG_BORDER, rect, opaque_rect, + visible_rect, needs_blending); + this->color = color; + this->width = width; +} + +void DebugBorderDrawQuad::SetAll(const SharedQuadState* shared_quad_state, + gfx::Rect rect, + gfx::Rect opaque_rect, + gfx::Rect visible_rect, + bool needs_blending, + SkColor color, + int width) { + DrawQuad::SetAll(shared_quad_state, DrawQuad::DEBUG_BORDER, rect, opaque_rect, + visible_rect, needs_blending); + this->color = color; + this->width = width; +} + +const DebugBorderDrawQuad* DebugBorderDrawQuad::MaterialCast( + const DrawQuad* quad) { + DCHECK(quad->material == DrawQuad::DEBUG_BORDER); + return static_cast<const DebugBorderDrawQuad*>(quad); } } // namespace cc diff --git a/cc/debug_border_draw_quad.h b/cc/debug_border_draw_quad.h index daee5b0..96dcec3 100644 --- a/cc/debug_border_draw_quad.h +++ b/cc/debug_border_draw_quad.h @@ -13,18 +13,28 @@ namespace cc { class CC_EXPORT DebugBorderDrawQuad : public DrawQuad { -public: - static scoped_ptr<DebugBorderDrawQuad> create(const SharedQuadState*, const gfx::Rect&, SkColor, int width); - - SkColor color() const { return m_color; }; - int width() const { return m_width; } - - static const DebugBorderDrawQuad* materialCast(const DrawQuad*); -private: - DebugBorderDrawQuad(const SharedQuadState*, const gfx::Rect&, SkColor, int width); - - SkColor m_color; - int m_width; + public: + static scoped_ptr<DebugBorderDrawQuad> Create(); + + void SetNew(const SharedQuadState* shared_quad_state, + gfx::Rect rect, + SkColor color, + int width); + + void SetAll(const SharedQuadState* shared_quad_state, + gfx::Rect rect, + gfx::Rect opaque_rect, + gfx::Rect visible_rect, + bool needs_blending, + SkColor color, + int width); + + SkColor color; + int width; + + static const DebugBorderDrawQuad* MaterialCast(const DrawQuad*); + private: + DebugBorderDrawQuad(); }; } diff --git a/cc/delegated_renderer_layer_impl.cc b/cc/delegated_renderer_layer_impl.cc index e8d3b06..38a4c54 100644 --- a/cc/delegated_renderer_layer_impl.cc +++ b/cc/delegated_renderer_layer_impl.cc @@ -163,11 +163,11 @@ void DelegatedRendererLayerImpl::appendRenderPassQuads(QuadSink& quadSink, Appen if (quad->material != DrawQuad::RENDER_PASS) copyQuad = quad->Copy(copiedSharedQuadState); else { - RenderPass::Id contributingDelegatedRenderPassId = RenderPassDrawQuad::materialCast(quad)->renderPassId(); + RenderPass::Id contributingDelegatedRenderPassId = RenderPassDrawQuad::MaterialCast(quad)->render_pass_id; RenderPass::Id contributingRenderPassId = convertDelegatedRenderPassId(contributingDelegatedRenderPassId); DCHECK(contributingRenderPassId != appendQuadsData.renderPassId); - copyQuad = RenderPassDrawQuad::materialCast(quad)->copy(copiedSharedQuadState, contributingRenderPassId).PassAs<DrawQuad>(); + copyQuad = RenderPassDrawQuad::MaterialCast(quad)->Copy(copiedSharedQuadState, contributingRenderPassId).PassAs<DrawQuad>(); } DCHECK(copyQuad.get()); diff --git a/cc/delegated_renderer_layer_impl_unittest.cc b/cc/delegated_renderer_layer_impl_unittest.cc index 3240101..63816f20 100644 --- a/cc/delegated_renderer_layer_impl_unittest.cc +++ b/cc/delegated_renderer_layer_impl_unittest.cc @@ -79,7 +79,8 @@ static SolidColorDrawQuad* addQuad(TestRenderPass* pass, gfx::Rect rect, SkColor MockQuadCuller quadSink(pass->quadList(), pass->sharedQuadStateList()); AppendQuadsData data(pass->id()); SharedQuadState* sharedState = quadSink.useSharedQuadState(SharedQuadState::create(WebTransformationMatrix(), rect, rect, 1)); - scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::create(sharedState, rect, color); + scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create(); + quad->SetNew(sharedState, rect, color); SolidColorDrawQuad* quadPtr = quad.get(); quadSink.append(quad.PassAs<DrawQuad>(), data); return quadPtr; @@ -91,7 +92,8 @@ static void addRenderPassQuad(TestRenderPass* toPass, TestRenderPass* contributi AppendQuadsData data(toPass->id()); gfx::Rect outputRect = contributingPass->outputRect(); SharedQuadState* sharedState = quadSink.useSharedQuadState(SharedQuadState::create(WebTransformationMatrix(), outputRect, outputRect, 1)); - scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::create(sharedState, outputRect, contributingPass->id(), false, 0, outputRect, 0, 0, 0, 0); + scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::Create(); + quad->SetNew(sharedState, outputRect, contributingPass->id(), false, 0, outputRect, 0, 0, 0, 0); quadSink.append(quad.PassAs<DrawQuad>(), data); } @@ -403,10 +405,24 @@ public: MockQuadCuller quadSink(pass->quadList(), pass->sharedQuadStateList()); AppendQuadsData data(pass->id()); SharedQuadState* sharedState = quadSink.useSharedQuadState(SharedQuadState::create(WebTransformationMatrix(), passRect, passRect, 1)); - quadSink.append(SolidColorDrawQuad::create(sharedState, gfx::Rect(0, 0, 10, 10), 1u).PassAs<DrawQuad>(), data); - quadSink.append(SolidColorDrawQuad::create(sharedState, gfx::Rect(0, 10, 10, 10), 2u).PassAs<DrawQuad>(), data); - quadSink.append(SolidColorDrawQuad::create(sharedState, gfx::Rect(10, 0, 10, 10), 3u).PassAs<DrawQuad>(), data); - quadSink.append(SolidColorDrawQuad::create(sharedState, gfx::Rect(10, 10, 10, 10), 4u).PassAs<DrawQuad>(), data); + scoped_ptr<SolidColorDrawQuad> colorQuad; + + colorQuad = SolidColorDrawQuad::Create(); + colorQuad->SetNew(sharedState, gfx::Rect(0, 0, 10, 10), 1u); + quadSink.append(colorQuad.PassAs<DrawQuad>(), data); + + colorQuad = SolidColorDrawQuad::Create(); + colorQuad->SetNew(sharedState, gfx::Rect(0, 10, 10, 10), 2u); + quadSink.append(colorQuad.PassAs<DrawQuad>(), data); + + colorQuad = SolidColorDrawQuad::Create(); + colorQuad->SetNew(sharedState, gfx::Rect(10, 0, 10, 10), 3u); + quadSink.append(colorQuad.PassAs<DrawQuad>(), data); + + colorQuad = SolidColorDrawQuad::Create(); + colorQuad->SetNew(sharedState, gfx::Rect(10, 10, 10, 10), 4u); + quadSink.append(colorQuad.PassAs<DrawQuad>(), data); + delegatedRendererLayer->setRenderPasses(delegatedRenderPasses); // The RenderPasses should be taken by the layer. diff --git a/cc/draw_quad.cc b/cc/draw_quad.cc index c052748..47f9aa0 100644 --- a/cc/draw_quad.cc +++ b/cc/draw_quad.cc @@ -18,7 +18,7 @@ namespace { template<typename T> T* TypedCopy(const cc::DrawQuad* other) { - return new T(*T::materialCast(other)); + return new T(*T::MaterialCast(other)); } } diff --git a/cc/draw_quad_unittest.cc b/cc/draw_quad_unittest.cc index 94b7ad5..f0544e4 100644 --- a/cc/draw_quad_unittest.cc +++ b/cc/draw_quad_unittest.cc @@ -71,82 +71,162 @@ void compareDrawQuad(DrawQuad* quad, DrawQuad* copy, SharedQuadState* copyShared #define QUAD_DATA \ gfx::Rect quadRect(30, 40, 50, 60); \ - gfx::Rect quadVisibleRect(40, 50, 30, 20); - -#define SETUP_AND_COPY_QUAD(Type, quad) \ - quad->visible_rect = quadVisibleRect; \ - scoped_ptr<DrawQuad> copy(quad->Copy(copySharedState.get())); \ - compareDrawQuad(quad.get(), copy.get(), copySharedState.get()); \ - const Type* copyQuad = Type::materialCast(copy.get()); - -#define SETUP_AND_COPY_QUAD_1(Type, quad, a) \ - quad->visible_rect = quadVisibleRect; \ - scoped_ptr<DrawQuad> copy(quad->copy(copySharedState.get(), a)); \ - compareDrawQuad(quad.get(), copy.get(), copySharedState.get()); \ - const Type* copyQuad = Type::materialCast(copy.get()); - -#define CREATE_QUAD_0(Type) \ - QUAD_DATA \ - scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect)); \ - SETUP_AND_COPY_QUAD(Type, quad); \ - UNUSED_PARAM(copyQuad); - -#define CREATE_QUAD_1(Type, a) \ - QUAD_DATA \ - scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a)); \ - SETUP_AND_COPY_QUAD(Type, quad); - -#define CREATE_QUAD_2(Type, a, b) \ - QUAD_DATA \ - scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b)); \ - SETUP_AND_COPY_QUAD(Type, quad); - -#define CREATE_QUAD_3(Type, a, b, c) \ - QUAD_DATA \ - scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c)); \ - SETUP_AND_COPY_QUAD(Type, quad); - -#define CREATE_QUAD_4(Type, a, b, c, d) \ - QUAD_DATA \ - scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d)); \ - SETUP_AND_COPY_QUAD(Type, quad); - -#define CREATE_QUAD_5(Type, a, b, c, d, e) \ - QUAD_DATA \ - scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d, e)); \ - SETUP_AND_COPY_QUAD(Type, quad); - -#define CREATE_QUAD_6(Type, a, b, c, d, e, f) \ - QUAD_DATA \ - scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d, e, f)); \ - SETUP_AND_COPY_QUAD(Type, quad); - -#define CREATE_QUAD_7(Type, a, b, c, d, e, f, g) \ - QUAD_DATA \ - scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d, e, f, g)); \ - SETUP_AND_COPY_QUAD(Type, quad); - -#define CREATE_QUAD_8(Type, a, b, c, d, e, f, g, h) \ - QUAD_DATA \ - scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d, e, f, g, h)); \ - SETUP_AND_COPY_QUAD(Type, quad); - -#define CREATE_QUAD_8_1(Type, a, b, c, d, e, f, g, h, copyA) \ - QUAD_DATA \ - scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d, e, f, g, h)); \ - SETUP_AND_COPY_QUAD_1(Type, quad, copyA); - -#define CREATE_QUAD_9(Type, a, b, c, d, e, f, g, h, i) \ - QUAD_DATA \ - scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d, e, f, g, h, i)); \ - SETUP_AND_COPY_QUAD(Type, quad); + gfx::Rect quadVisibleRect(40, 50, 30, 20); \ + gfx::Rect quadOpaqueRect(60, 55, 10, 10); \ + bool needsBlending = true; + +#define SETUP_AND_COPY_QUAD_NEW(Type, quad) \ + scoped_ptr<DrawQuad> copyNew(quadNew->Copy(copySharedState.get())); \ + compareDrawQuad(quadNew.get(), copyNew.get(), copySharedState.get()); \ + const Type* copyQuad = Type::MaterialCast(copyNew.get()); + +#define SETUP_AND_COPY_QUAD_ALL(Type, quad) \ + scoped_ptr<DrawQuad> copyAll(quadAll->Copy(copySharedState.get())); \ + compareDrawQuad(quadAll.get(), copyAll.get(), copySharedState.get()); \ + copyQuad = Type::MaterialCast(copyAll.get()); + +#define SETUP_AND_COPY_QUAD_NEW_1(Type, quad, a) \ + scoped_ptr<DrawQuad> copyNew(quadNew->Copy(copySharedState.get(), a)); \ + compareDrawQuad(quadNew.get(), copyNew.get(), copySharedState.get()); \ + const Type* copyQuad = Type::MaterialCast(copyNew.get()); + +#define SETUP_AND_COPY_QUAD_ALL_1(Type, quad, a) \ + scoped_ptr<DrawQuad> copyAll(quadAll->Copy(copySharedState.get(), a)); \ + compareDrawQuad(quadAll.get(), copyAll.get(), copySharedState.get()); \ + copyQuad = Type::MaterialCast(copyAll.get()); + +#define CREATE_QUAD_1_NEW(Type, a) \ + scoped_ptr<Type> quadNew(Type::Create()); \ + { QUAD_DATA \ + quadNew->SetNew(sharedState.get(), quadRect, a); } \ + SETUP_AND_COPY_QUAD_NEW(Type, quadNew); + +#define CREATE_QUAD_1_ALL(Type, a) \ + scoped_ptr<Type> quadAll(Type::Create()); \ + { QUAD_DATA \ + quadAll->SetAll(sharedState.get(), quadRect, quadOpaqueRect, quadVisibleRect, needsBlending, a); } \ + SETUP_AND_COPY_QUAD_ALL(Type, quadAll); + +#define CREATE_QUAD_2_NEW(Type, a, b) \ + scoped_ptr<Type> quadNew(Type::Create()); \ + { QUAD_DATA \ + quadNew->SetNew(sharedState.get(), quadRect, a, b); } \ + SETUP_AND_COPY_QUAD_NEW(Type, quadNew); + +#define CREATE_QUAD_2_ALL(Type, a, b) \ + scoped_ptr<Type> quadAll(Type::Create()); \ + { QUAD_DATA \ + quadAll->SetAll(sharedState.get(), quadRect, quadOpaqueRect, quadVisibleRect, needsBlending, a, b); } \ + SETUP_AND_COPY_QUAD_ALL(Type, quadAll); + +#define CREATE_QUAD_3_NEW(Type, a, b, c) \ + scoped_ptr<Type> quadNew(Type::Create()); \ + { QUAD_DATA \ + quadNew->SetNew(sharedState.get(), quadRect, a, b, c); } \ + SETUP_AND_COPY_QUAD_NEW(Type, quadNew); + +#define CREATE_QUAD_3_ALL(Type, a, b, c) \ + scoped_ptr<Type> quadAll(Type::Create()); \ + { QUAD_DATA \ + quadAll->SetAll(sharedState.get(), quadRect, quadOpaqueRect, quadVisibleRect, needsBlending, a, b, c); } \ + SETUP_AND_COPY_QUAD_ALL(Type, quadAll); + +#define CREATE_QUAD_4_NEW(Type, a, b, c, d) \ + scoped_ptr<Type> quadNew(Type::Create()); \ + { QUAD_DATA \ + quadNew->SetNew(sharedState.get(), quadRect, a, b, c, d); } \ + SETUP_AND_COPY_QUAD_NEW(Type, quadNew); + +#define CREATE_QUAD_4_ALL(Type, a, b, c, d) \ + scoped_ptr<Type> quadAll(Type::Create()); \ + { QUAD_DATA \ + quadAll->SetAll(sharedState.get(), quadRect, quadOpaqueRect, quadVisibleRect, needsBlending, a, b, c, d); } \ + SETUP_AND_COPY_QUAD_ALL(Type, quadAll); + +#define CREATE_QUAD_5_NEW(Type, a, b, c, d, e) \ + scoped_ptr<Type> quadNew(Type::Create()); \ + { QUAD_DATA \ + quadNew->SetNew(sharedState.get(), quadRect, a, b, c, d, e); } \ + SETUP_AND_COPY_QUAD_NEW(Type, quadNew); + +#define CREATE_QUAD_5_ALL(Type, a, b, c, d, e) \ + scoped_ptr<Type> quadAll(Type::Create()); \ + { QUAD_DATA \ + quadAll->SetAll(sharedState.get(), quadRect, quadOpaqueRect, quadVisibleRect, needsBlending, a, b, c, d, e); } \ + SETUP_AND_COPY_QUAD_ALL(Type, quadAll); + +#define CREATE_QUAD_6_NEW(Type, a, b, c, d, e, f) \ + scoped_ptr<Type> quadNew(Type::Create()); \ + { QUAD_DATA \ + quadNew->SetNew(sharedState.get(), quadRect, a, b, c, d, e, f); } \ + SETUP_AND_COPY_QUAD_NEW(Type, quadNew); + +#define CREATE_QUAD_6_ALL(Type, a, b, c, d, e, f) \ + scoped_ptr<Type> quadAll(Type::Create()); \ + { QUAD_DATA \ + quadAll->SetAll(sharedState.get(), quadRect, quadOpaqueRect, quadVisibleRect, needsBlending, a, b, c, d, e, f); } \ + SETUP_AND_COPY_QUAD_ALL(Type, quadAll); + +#define CREATE_QUAD_7_NEW(Type, a, b, c, d, e, f, g) \ + scoped_ptr<Type> quadNew(Type::Create()); \ + { QUAD_DATA \ + quadNew->SetNew(sharedState.get(), quadRect, a, b, c, d, e, f, g); } \ + SETUP_AND_COPY_QUAD_NEW(Type, quadNew); + +#define CREATE_QUAD_7_ALL(Type, a, b, c, d, e, f, g) \ + scoped_ptr<Type> quadAll(Type::Create()); \ + { QUAD_DATA \ + quadAll->SetAll(sharedState.get(), quadRect, quadOpaqueRect, quadVisibleRect, needsBlending, a, b, c, d, e, f, g); } \ + SETUP_AND_COPY_QUAD_ALL(Type, quadAll); + +#define CREATE_QUAD_8_NEW(Type, a, b, c, d, e, f, g, h) \ + scoped_ptr<Type> quadNew(Type::Create()); \ + { QUAD_DATA \ + quadNew->SetNew(sharedState.get(), quadRect, a, b, c, d, e, f, g, h); } \ + SETUP_AND_COPY_QUAD_NEW(Type, quadNew); + +#define CREATE_QUAD_8_ALL(Type, a, b, c, d, e, f, g, h) \ + scoped_ptr<Type> quadAll(Type::Create()); \ + { QUAD_DATA \ + quadAll->SetAll(sharedState.get(), quadRect, quadOpaqueRect, quadVisibleRect, needsBlending, a, b, c, d, e, f, g, h); } \ + SETUP_AND_COPY_QUAD_ALL(Type, quadAll); + +#define CREATE_QUAD_8_NEW_1(Type, a, b, c, d, e, f, g, h, copyA) \ + scoped_ptr<Type> quadNew(Type::Create()); \ + { QUAD_DATA \ + quadNew->SetNew(sharedState.get(), quadRect, a, b, c, d, e, f, g, h); } \ + SETUP_AND_COPY_QUAD_NEW_1(Type, quadNew, copyA); + +#define CREATE_QUAD_8_ALL_1(Type, a, b, c, d, e, f, g, h, copyA) \ + scoped_ptr<Type> quadAll(Type::Create()); \ + { QUAD_DATA \ + quadAll->SetAll(sharedState.get(), quadRect, quadOpaqueRect, quadVisibleRect, needsBlending, a, b, c, d, e, f, g, h); } \ + SETUP_AND_COPY_QUAD_ALL_1(Type, quadAll, copyA); + +#define CREATE_QUAD_9_NEW(Type, a, b, c, d, e, f, g, h, i) \ + scoped_ptr<Type> quadNew(Type::Create()); \ + { QUAD_DATA \ + quadNew->SetNew(sharedState.get(), quadRect, a, b, c, d, e, f, g, h, i); } \ + SETUP_AND_COPY_QUAD_NEW(Type, quadNew); + +#define CREATE_QUAD_9_ALL(Type, a, b, c, d, e, f, g, h, i) \ + scoped_ptr<Type> quadAll(Type::Create()); \ + { QUAD_DATA \ + quadAll->SetAll(sharedState.get(), quadRect, quadOpaqueRect, quadVisibleRect, needsBlending, a, b, c, d, e, f, g, h, i); } \ + SETUP_AND_COPY_QUAD_ALL(Type, quadAll); TEST(DrawQuadTest, copyCheckerboardDrawQuad) { SkColor color = 0xfabb0011; CREATE_SHARED_STATE(); - CREATE_QUAD_1(CheckerboardDrawQuad, color); - EXPECT_EQ(color, copyQuad->color()); + + CREATE_QUAD_1_NEW(CheckerboardDrawQuad, color); + EXPECT_EQ(DrawQuad::CHECKERBOARD, copyQuad->material); + EXPECT_EQ(color, copyQuad->color); + + CREATE_QUAD_1_ALL(CheckerboardDrawQuad, color); + EXPECT_EQ(DrawQuad::CHECKERBOARD, copyQuad->material); + EXPECT_EQ(color, copyQuad->color); } TEST(DrawQuadTest, copyDebugBorderDrawQuad) @@ -154,9 +234,16 @@ TEST(DrawQuadTest, copyDebugBorderDrawQuad) SkColor color = 0xfabb0011; int width = 99; CREATE_SHARED_STATE(); - CREATE_QUAD_2(DebugBorderDrawQuad, color, width); - EXPECT_EQ(color, copyQuad->color()); - EXPECT_EQ(width, copyQuad->width()); + + CREATE_QUAD_2_NEW(DebugBorderDrawQuad, color, width); + EXPECT_EQ(DrawQuad::DEBUG_BORDER, copyQuad->material); + EXPECT_EQ(color, copyQuad->color); + EXPECT_EQ(width, copyQuad->width); + + CREATE_QUAD_2_ALL(DebugBorderDrawQuad, color, width); + EXPECT_EQ(DrawQuad::DEBUG_BORDER, copyQuad->material); + EXPECT_EQ(color, copyQuad->color); + EXPECT_EQ(width, copyQuad->width); } TEST(DrawQuadTest, copyIOSurfaceDrawQuad) @@ -164,14 +251,21 @@ TEST(DrawQuadTest, copyIOSurfaceDrawQuad) gfx::Rect opaqueRect(3, 7, 10, 12); gfx::Size size(58, 95); unsigned textureId = 72; - IOSurfaceDrawQuad::Orientation orientation = IOSurfaceDrawQuad::Unflipped; - + IOSurfaceDrawQuad::Orientation orientation = IOSurfaceDrawQuad::UNFLIPPED; CREATE_SHARED_STATE(); - CREATE_QUAD_4(IOSurfaceDrawQuad, opaqueRect, size, textureId, orientation); + + CREATE_QUAD_4_NEW(IOSurfaceDrawQuad, opaqueRect, size, textureId, orientation); + EXPECT_EQ(DrawQuad::IO_SURFACE_CONTENT, copyQuad->material); EXPECT_RECT_EQ(opaqueRect, copyQuad->opaque_rect); - EXPECT_EQ(size, copyQuad->ioSurfaceSize()); - EXPECT_EQ(textureId, copyQuad->ioSurfaceTextureId()); - EXPECT_EQ(orientation, copyQuad->orientation()); + EXPECT_EQ(size, copyQuad->io_surface_size); + EXPECT_EQ(textureId, copyQuad->io_surface_texture_id); + EXPECT_EQ(orientation, copyQuad->orientation); + + CREATE_QUAD_3_ALL(IOSurfaceDrawQuad, size, textureId, orientation); + EXPECT_EQ(DrawQuad::IO_SURFACE_CONTENT, copyQuad->material); + EXPECT_EQ(size, copyQuad->io_surface_size); + EXPECT_EQ(textureId, copyQuad->io_surface_texture_id); + EXPECT_EQ(orientation, copyQuad->orientation); } TEST(DrawQuadTest, copyRenderPassDrawQuad) @@ -186,26 +280,43 @@ TEST(DrawQuadTest, copyRenderPassDrawQuad) float maskTexCoordOffsetY = -21; RenderPass::Id copiedRenderPassId(235, 11); - CREATE_SHARED_STATE(); - CREATE_QUAD_8_1(RenderPassDrawQuad, renderPassId, isReplica, maskResourceId, contentsChangedSinceLastFrame, maskTexCoordScaleX, maskTexCoordScaleY, maskTexCoordOffsetX, maskTexCoordOffsetY, copiedRenderPassId); - EXPECT_EQ(copiedRenderPassId, copyQuad->renderPassId()); - EXPECT_EQ(isReplica, copyQuad->isReplica()); - EXPECT_EQ(maskResourceId, copyQuad->maskResourceId()); - EXPECT_RECT_EQ(contentsChangedSinceLastFrame, copyQuad->contentsChangedSinceLastFrame()); - EXPECT_EQ(maskTexCoordScaleX, copyQuad->maskTexCoordScaleX()); - EXPECT_EQ(maskTexCoordScaleY, copyQuad->maskTexCoordScaleY()); - EXPECT_EQ(maskTexCoordOffsetX, copyQuad->maskTexCoordOffsetX()); - EXPECT_EQ(maskTexCoordOffsetY, copyQuad->maskTexCoordOffsetY()); + + CREATE_QUAD_8_NEW_1(RenderPassDrawQuad, renderPassId, isReplica, maskResourceId, contentsChangedSinceLastFrame, maskTexCoordScaleX, maskTexCoordScaleY, maskTexCoordOffsetX, maskTexCoordOffsetY, copiedRenderPassId); + EXPECT_EQ(DrawQuad::RENDER_PASS, copyQuad->material); + EXPECT_EQ(copiedRenderPassId, copyQuad->render_pass_id); + EXPECT_EQ(isReplica, copyQuad->is_replica); + EXPECT_EQ(maskResourceId, copyQuad->mask_resource_id); + EXPECT_RECT_EQ(contentsChangedSinceLastFrame, copyQuad->contents_changed_since_last_frame); + EXPECT_EQ(maskTexCoordScaleX, copyQuad->mask_tex_coord_scale_x); + EXPECT_EQ(maskTexCoordScaleY, copyQuad->mask_tex_coord_scale_y); + EXPECT_EQ(maskTexCoordOffsetX, copyQuad->mask_tex_coord_offset_x); + EXPECT_EQ(maskTexCoordOffsetY, copyQuad->mask_tex_coord_offset_y); + + CREATE_QUAD_8_ALL_1(RenderPassDrawQuad, renderPassId, isReplica, maskResourceId, contentsChangedSinceLastFrame, maskTexCoordScaleX, maskTexCoordScaleY, maskTexCoordOffsetX, maskTexCoordOffsetY, copiedRenderPassId); + EXPECT_EQ(DrawQuad::RENDER_PASS, copyQuad->material); + EXPECT_EQ(copiedRenderPassId, copyQuad->render_pass_id); + EXPECT_EQ(isReplica, copyQuad->is_replica); + EXPECT_EQ(maskResourceId, copyQuad->mask_resource_id); + EXPECT_RECT_EQ(contentsChangedSinceLastFrame, copyQuad->contents_changed_since_last_frame); + EXPECT_EQ(maskTexCoordScaleX, copyQuad->mask_tex_coord_scale_x); + EXPECT_EQ(maskTexCoordScaleY, copyQuad->mask_tex_coord_scale_y); + EXPECT_EQ(maskTexCoordOffsetX, copyQuad->mask_tex_coord_offset_x); + EXPECT_EQ(maskTexCoordOffsetY, copyQuad->mask_tex_coord_offset_y); } TEST(DrawQuadTest, copySolidColorDrawQuad) { SkColor color = 0x49494949; - CREATE_SHARED_STATE(); - CREATE_QUAD_1(SolidColorDrawQuad, color); - EXPECT_EQ(color, copyQuad->color()); + + CREATE_QUAD_1_NEW(SolidColorDrawQuad, color); + EXPECT_EQ(DrawQuad::SOLID_COLOR, copyQuad->material); + EXPECT_EQ(color, copyQuad->color); + + CREATE_QUAD_1_ALL(SolidColorDrawQuad, color); + EXPECT_EQ(DrawQuad::SOLID_COLOR, copyQuad->material); + EXPECT_EQ(color, copyQuad->color); } TEST(DrawQuadTest, copyStreamVideoDrawQuad) @@ -213,12 +324,18 @@ TEST(DrawQuadTest, copyStreamVideoDrawQuad) gfx::Rect opaqueRect(3, 7, 10, 12); unsigned textureId = 64; WebTransformationMatrix matrix(0.5, 1, 0.25, 0.75, 0, 1); - CREATE_SHARED_STATE(); - CREATE_QUAD_3(StreamVideoDrawQuad, opaqueRect, textureId, matrix); + + CREATE_QUAD_3_NEW(StreamVideoDrawQuad, opaqueRect, textureId, matrix); + EXPECT_EQ(DrawQuad::STREAM_VIDEO_CONTENT, copyQuad->material); EXPECT_RECT_EQ(opaqueRect, copyQuad->opaque_rect); - EXPECT_EQ(textureId, copyQuad->textureId()); - EXPECT_EQ(matrix, copyQuad->matrix()); + EXPECT_EQ(textureId, copyQuad->texture_id); + EXPECT_EQ(matrix, copyQuad->matrix); + + CREATE_QUAD_2_ALL(StreamVideoDrawQuad, textureId, matrix); + EXPECT_EQ(DrawQuad::STREAM_VIDEO_CONTENT, copyQuad->material); + EXPECT_EQ(textureId, copyQuad->texture_id); + EXPECT_EQ(matrix, copyQuad->matrix); } TEST(DrawQuadTest, copyTextureDrawQuad) @@ -228,14 +345,22 @@ TEST(DrawQuadTest, copyTextureDrawQuad) bool premultipliedAlpha = true; gfx::RectF uvRect(0.5, 224, -51, 36); bool flipped = true; - CREATE_SHARED_STATE(); - CREATE_QUAD_5(TextureDrawQuad, opaqueRect, resourceId, premultipliedAlpha, uvRect, flipped); + + CREATE_QUAD_5_NEW(TextureDrawQuad, opaqueRect, resourceId, premultipliedAlpha, uvRect, flipped); + EXPECT_EQ(DrawQuad::TEXTURE_CONTENT, copyQuad->material); EXPECT_RECT_EQ(opaqueRect, copyQuad->opaque_rect); - EXPECT_EQ(resourceId, copyQuad->resourceId()); - EXPECT_EQ(premultipliedAlpha, copyQuad->premultipliedAlpha()); - EXPECT_FLOAT_RECT_EQ(uvRect, copyQuad->uvRect()); - EXPECT_EQ(flipped, copyQuad->flipped()); + EXPECT_EQ(resourceId, copyQuad->resource_id); + EXPECT_EQ(premultipliedAlpha, copyQuad->premultiplied_alpha); + EXPECT_FLOAT_RECT_EQ(uvRect, copyQuad->uv_rect); + EXPECT_EQ(flipped, copyQuad->flipped); + + CREATE_QUAD_4_ALL(TextureDrawQuad, resourceId, premultipliedAlpha, uvRect, flipped); + EXPECT_EQ(DrawQuad::TEXTURE_CONTENT, copyQuad->material); + EXPECT_EQ(resourceId, copyQuad->resource_id); + EXPECT_EQ(premultipliedAlpha, copyQuad->premultiplied_alpha); + EXPECT_FLOAT_RECT_EQ(uvRect, copyQuad->uv_rect); + EXPECT_EQ(flipped, copyQuad->flipped); } TEST(DrawQuadTest, copyTileDrawQuad) @@ -249,18 +374,30 @@ TEST(DrawQuadTest, copyTileDrawQuad) bool topEdgeAA = true; bool rightEdgeAA = false; bool bottomEdgeAA = true; - CREATE_SHARED_STATE(); - CREATE_QUAD_9(TileDrawQuad, opaqueRect, resourceId, texCoordRect, textureSize, swizzleContents, leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA); + + CREATE_QUAD_9_NEW(TileDrawQuad, opaqueRect, resourceId, texCoordRect, textureSize, swizzleContents, leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA); + EXPECT_EQ(DrawQuad::TILED_CONTENT, copyQuad->material); EXPECT_RECT_EQ(opaqueRect, copyQuad->opaque_rect); - EXPECT_EQ(resourceId, copyQuad->resourceId()); - EXPECT_EQ(texCoordRect, copyQuad->texCoordRect()); - EXPECT_EQ(textureSize, copyQuad->textureSize()); - EXPECT_EQ(swizzleContents, copyQuad->swizzleContents()); - EXPECT_EQ(leftEdgeAA, copyQuad->leftEdgeAA()); - EXPECT_EQ(topEdgeAA, copyQuad->topEdgeAA()); - EXPECT_EQ(rightEdgeAA, copyQuad->rightEdgeAA()); - EXPECT_EQ(bottomEdgeAA, copyQuad->bottomEdgeAA()); + EXPECT_EQ(resourceId, copyQuad->resource_id); + EXPECT_EQ(texCoordRect, copyQuad->tex_coord_rect); + EXPECT_EQ(textureSize, copyQuad->texture_size); + EXPECT_EQ(swizzleContents, copyQuad->swizzle_contents); + EXPECT_EQ(leftEdgeAA, copyQuad->left_edge_aa); + EXPECT_EQ(topEdgeAA, copyQuad->top_edge_aa); + EXPECT_EQ(rightEdgeAA, copyQuad->right_edge_aa); + EXPECT_EQ(bottomEdgeAA, copyQuad->bottom_edge_aa); + + CREATE_QUAD_8_ALL(TileDrawQuad, resourceId, texCoordRect, textureSize, swizzleContents, leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA); + EXPECT_EQ(DrawQuad::TILED_CONTENT, copyQuad->material); + EXPECT_EQ(resourceId, copyQuad->resource_id); + EXPECT_EQ(texCoordRect, copyQuad->tex_coord_rect); + EXPECT_EQ(textureSize, copyQuad->texture_size); + EXPECT_EQ(swizzleContents, copyQuad->swizzle_contents); + EXPECT_EQ(leftEdgeAA, copyQuad->left_edge_aa); + EXPECT_EQ(topEdgeAA, copyQuad->top_edge_aa); + EXPECT_EQ(rightEdgeAA, copyQuad->right_edge_aa); + EXPECT_EQ(bottomEdgeAA, copyQuad->bottom_edge_aa); } TEST(DrawQuadTest, copyYUVVideoDrawQuad) @@ -279,20 +416,34 @@ TEST(DrawQuadTest, copyYUVVideoDrawQuad) vPlane.resourceId = 4; vPlane.size = gfx::Size(456, 486); vPlane.format = 46; - CREATE_SHARED_STATE(); - CREATE_QUAD_5(YUVVideoDrawQuad, opaqueRect, texScale, yPlane, uPlane, vPlane); + + CREATE_QUAD_5_NEW(YUVVideoDrawQuad, opaqueRect, texScale, yPlane, uPlane, vPlane); + EXPECT_EQ(DrawQuad::YUV_VIDEO_CONTENT, copyQuad->material); EXPECT_RECT_EQ(opaqueRect, copyQuad->opaque_rect); - EXPECT_EQ(texScale, copyQuad->texScale()); - EXPECT_EQ(yPlane.resourceId, copyQuad->yPlane().resourceId); - EXPECT_EQ(yPlane.size, copyQuad->yPlane().size); - EXPECT_EQ(yPlane.format, copyQuad->yPlane().format); - EXPECT_EQ(uPlane.resourceId, copyQuad->uPlane().resourceId); - EXPECT_EQ(uPlane.size, copyQuad->uPlane().size); - EXPECT_EQ(uPlane.format, copyQuad->uPlane().format); - EXPECT_EQ(vPlane.resourceId, copyQuad->vPlane().resourceId); - EXPECT_EQ(vPlane.size, copyQuad->vPlane().size); - EXPECT_EQ(vPlane.format, copyQuad->vPlane().format); + EXPECT_EQ(texScale, copyQuad->tex_scale); + EXPECT_EQ(yPlane.resourceId, copyQuad->y_plane.resourceId); + EXPECT_EQ(yPlane.size, copyQuad->y_plane.size); + EXPECT_EQ(yPlane.format, copyQuad->y_plane.format); + EXPECT_EQ(uPlane.resourceId, copyQuad->u_plane.resourceId); + EXPECT_EQ(uPlane.size, copyQuad->u_plane.size); + EXPECT_EQ(uPlane.format, copyQuad->u_plane.format); + EXPECT_EQ(vPlane.resourceId, copyQuad->v_plane.resourceId); + EXPECT_EQ(vPlane.size, copyQuad->v_plane.size); + EXPECT_EQ(vPlane.format, copyQuad->v_plane.format); + + CREATE_QUAD_4_ALL(YUVVideoDrawQuad, texScale, yPlane, uPlane, vPlane); + EXPECT_EQ(DrawQuad::YUV_VIDEO_CONTENT, copyQuad->material); + EXPECT_EQ(texScale, copyQuad->tex_scale); + EXPECT_EQ(yPlane.resourceId, copyQuad->y_plane.resourceId); + EXPECT_EQ(yPlane.size, copyQuad->y_plane.size); + EXPECT_EQ(yPlane.format, copyQuad->y_plane.format); + EXPECT_EQ(uPlane.resourceId, copyQuad->u_plane.resourceId); + EXPECT_EQ(uPlane.size, copyQuad->u_plane.size); + EXPECT_EQ(uPlane.format, copyQuad->u_plane.format); + EXPECT_EQ(vPlane.resourceId, copyQuad->v_plane.resourceId); + EXPECT_EQ(vPlane.size, copyQuad->v_plane.size); + EXPECT_EQ(vPlane.format, copyQuad->v_plane.format); } } // namespace diff --git a/cc/gl_renderer.cc b/cc/gl_renderer.cc index af67acf..e4e8034 100644 --- a/cc/gl_renderer.cc +++ b/cc/gl_renderer.cc @@ -262,31 +262,31 @@ void GLRenderer::drawQuad(DrawingFrame& frame, const DrawQuad* quad) NOTREACHED(); break; case DrawQuad::CHECKERBOARD: - drawCheckerboardQuad(frame, CheckerboardDrawQuad::materialCast(quad)); + drawCheckerboardQuad(frame, CheckerboardDrawQuad::MaterialCast(quad)); break; case DrawQuad::DEBUG_BORDER: - drawDebugBorderQuad(frame, DebugBorderDrawQuad::materialCast(quad)); + drawDebugBorderQuad(frame, DebugBorderDrawQuad::MaterialCast(quad)); break; case DrawQuad::IO_SURFACE_CONTENT: - drawIOSurfaceQuad(frame, IOSurfaceDrawQuad::materialCast(quad)); + drawIOSurfaceQuad(frame, IOSurfaceDrawQuad::MaterialCast(quad)); break; case DrawQuad::RENDER_PASS: - drawRenderPassQuad(frame, RenderPassDrawQuad::materialCast(quad)); + drawRenderPassQuad(frame, RenderPassDrawQuad::MaterialCast(quad)); break; case DrawQuad::SOLID_COLOR: - drawSolidColorQuad(frame, SolidColorDrawQuad::materialCast(quad)); + drawSolidColorQuad(frame, SolidColorDrawQuad::MaterialCast(quad)); break; case DrawQuad::STREAM_VIDEO_CONTENT: - drawStreamVideoQuad(frame, StreamVideoDrawQuad::materialCast(quad)); + drawStreamVideoQuad(frame, StreamVideoDrawQuad::MaterialCast(quad)); break; case DrawQuad::TEXTURE_CONTENT: - drawTextureQuad(frame, TextureDrawQuad::materialCast(quad)); + drawTextureQuad(frame, TextureDrawQuad::MaterialCast(quad)); break; case DrawQuad::TILED_CONTENT: - drawTileQuad(frame, TileDrawQuad::materialCast(quad)); + drawTileQuad(frame, TileDrawQuad::MaterialCast(quad)); break; case DrawQuad::YUV_VIDEO_CONTENT: - drawYUVVideoQuad(frame, YUVVideoDrawQuad::materialCast(quad)); + drawYUVVideoQuad(frame, YUVVideoDrawQuad::MaterialCast(quad)); break; } } @@ -297,7 +297,7 @@ void GLRenderer::drawCheckerboardQuad(const DrawingFrame& frame, const Checkerbo DCHECK(program && (program->initialized() || isContextLost())); GLC(context(), context()->useProgram(program->program())); - SkColor color = quad->color(); + SkColor color = quad->color; GLC(context(), context()->uniform4f(program->fragmentShader().colorLocation(), SkColorGetR(color) / 255.0, SkColorGetG(color) / 255.0, SkColorGetB(color) / 255.0, 1)); const int checkerboardWidth = 16; @@ -331,12 +331,12 @@ void GLRenderer::drawDebugBorderQuad(const DrawingFrame& frame, const DebugBorde GLRenderer::toGLMatrix(&glMatrix[0], frame.projectionMatrix * renderMatrix); GLC(context(), context()->uniformMatrix4fv(program->vertexShader().matrixLocation(), 1, false, &glMatrix[0])); - SkColor color = quad->color(); + SkColor color = quad->color; float alpha = SkColorGetA(color) / 255.0; GLC(context(), context()->uniform4f(program->fragmentShader().colorLocation(), (SkColorGetR(color) / 255.0) * alpha, (SkColorGetG(color) / 255.0) * alpha, (SkColorGetB(color) / 255.0) * alpha, alpha)); - GLC(context(), context()->lineWidth(quad->width())); + GLC(context(), context()->lineWidth(quad->width)); // The indices for the line are stored in the same array as the triangle indices. GLC(context(), context()->drawElements(GL_LINE_LOOP, 4, GL_UNSIGNED_SHORT, 6 * sizeof(unsigned short))); @@ -504,11 +504,11 @@ scoped_ptr<ScopedResource> GLRenderer::drawBackgroundFilters( void GLRenderer::drawRenderPassQuad(DrawingFrame& frame, const RenderPassDrawQuad* quad) { - CachedResource* contentsTexture = m_renderPassTextures.get(quad->renderPassId()); + CachedResource* contentsTexture = m_renderPassTextures.get(quad->render_pass_id); if (!contentsTexture || !contentsTexture->id()) return; - const RenderPass* renderPass = frame.renderPassesById->get(quad->renderPassId()); + const RenderPass* renderPass = frame.renderPassesById->get(quad->render_pass_id); DCHECK(renderPass); if (!renderPass) return; @@ -566,8 +566,8 @@ void GLRenderer::drawRenderPassQuad(DrawingFrame& frame, const RenderPassDrawQua scoped_ptr<ResourceProvider::ScopedReadLockGL> maskResourceLock; unsigned maskTextureId = 0; - if (quad->maskResourceId()) { - maskResourceLock.reset(new ResourceProvider::ScopedReadLockGL(m_resourceProvider, quad->maskResourceId())); + if (quad->mask_resource_id) { + maskResourceLock.reset(new ResourceProvider::ScopedReadLockGL(m_resourceProvider, quad->mask_resource_id)); maskTextureId = maskResourceLock->textureId(); } @@ -627,8 +627,8 @@ void GLRenderer::drawRenderPassQuad(DrawingFrame& frame, const RenderPassDrawQua DCHECK(shaderMaskTexCoordOffsetLocation != 1); GLC(context(), context()->activeTexture(GL_TEXTURE1)); GLC(context(), context()->uniform1i(shaderMaskSamplerLocation, 1)); - GLC(context(), context()->uniform2f(shaderMaskTexCoordScaleLocation, quad->maskTexCoordScaleX(), quad->maskTexCoordScaleY())); - GLC(context(), context()->uniform2f(shaderMaskTexCoordOffsetLocation, quad->maskTexCoordOffsetX(), quad->maskTexCoordOffsetY())); + GLC(context(), context()->uniform2f(shaderMaskTexCoordScaleLocation, quad->mask_tex_coord_scale_x, quad->mask_tex_coord_scale_y)); + GLC(context(), context()->uniform2f(shaderMaskTexCoordOffsetLocation, quad->mask_tex_coord_offset_x, quad->mask_tex_coord_offset_y)); context()->bindTexture(GL_TEXTURE_2D, maskTextureId); GLC(context(), context()->activeTexture(GL_TEXTURE0)); } @@ -659,7 +659,7 @@ void GLRenderer::drawSolidColorQuad(const DrawingFrame& frame, const SolidColorD const SolidColorProgram* program = solidColorProgram(); GLC(context(), context()->useProgram(program->program())); - SkColor color = quad->color(); + SkColor color = quad->color; float opacity = quad->opacity(); float alpha = (SkColorGetA(color) / 255.0) * opacity; @@ -697,7 +697,7 @@ void GLRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQuad* qua { gfx::Rect tileRect = quad->visible_rect; - gfx::RectF texCoordRect = quad->texCoordRect(); + gfx::RectF texCoordRect = quad->tex_coord_rect; float texToGeomScaleX = quad->rect.width() / texCoordRect.width(); float texToGeomScaleY = quad->rect.height() / texCoordRect.height(); @@ -737,7 +737,7 @@ void GLRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQuad* qua float vertexTexScaleY = tileRect.height() / clampGeomRect.height(); // Map to normalized texture coordinates. - const gfx::Size& textureSize = quad->textureSize(); + const gfx::Size& textureSize = quad->texture_size; float fragmentTexTranslateX = clampTexRect.x() / textureSize.width(); float fragmentTexTranslateY = clampTexRect.y() / textureSize.height(); float fragmentTexScaleX = clampTexRect.width() / textureSize.width(); @@ -756,19 +756,19 @@ void GLRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQuad* qua TileProgramUniforms uniforms; // For now, we simply skip anti-aliasing with the quad is clipped. This only happens // on perspective transformed layers that go partially behind the camera. - if (quad->isAntialiased() && !clipped) { - if (quad->swizzleContents()) + if (quad->IsAntialiased() && !clipped) { + if (quad->swizzle_contents) tileUniformLocation(tileProgramSwizzleAA(), uniforms); else tileUniformLocation(tileProgramAA(), uniforms); } else { if (quad->ShouldDrawWithBlending()) { - if (quad->swizzleContents()) + if (quad->swizzle_contents) tileUniformLocation(tileProgramSwizzle(), uniforms); else tileUniformLocation(tileProgram(), uniforms); } else { - if (quad->swizzleContents()) + if (quad->swizzle_contents) tileUniformLocation(tileProgramSwizzleOpaque(), uniforms); else tileUniformLocation(tileProgramOpaque(), uniforms); @@ -777,10 +777,10 @@ void GLRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQuad* qua GLC(context(), context()->useProgram(uniforms.program)); GLC(context(), context()->uniform1i(uniforms.samplerLocation, 0)); - ResourceProvider::ScopedReadLockGL quadResourceLock(m_resourceProvider, quad->resourceId()); + ResourceProvider::ScopedReadLockGL quadResourceLock(m_resourceProvider, quad->resource_id); GLC(context(), context()->bindTexture(GL_TEXTURE_2D, quadResourceLock.textureId())); - bool useAA = !clipped && quad->isAntialiased(); + bool useAA = !clipped && quad->IsAntialiased(); if (useAA) { LayerQuad deviceLayerBounds = LayerQuad(gfx::QuadF(deviceLayerQuad.BoundingBox())); deviceLayerBounds.inflateAntiAliasingDistance(); @@ -817,13 +817,13 @@ void GLRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQuad* qua LayerQuad::Edge rightEdge(topRight, bottomRight); // Only apply anti-aliasing to edges not clipped by culling or scissoring. - if (quad->topEdgeAA() && tileRect.y() == quad->rect.y()) + if (quad->top_edge_aa && tileRect.y() == quad->rect.y()) topEdge = deviceLayerEdges.top(); - if (quad->leftEdgeAA() && tileRect.x() == quad->rect.x()) + if (quad->left_edge_aa && tileRect.x() == quad->rect.x()) leftEdge = deviceLayerEdges.left(); - if (quad->rightEdgeAA() && tileRect.right() == quad->rect.right()) + if (quad->right_edge_aa && tileRect.right() == quad->rect.right()) rightEdge = deviceLayerEdges.right(); - if (quad->bottomEdgeAA() && tileRect.bottom() == quad->rect.bottom()) + if (quad->bottom_edge_aa && tileRect.bottom() == quad->rect.bottom()) bottomEdge = deviceLayerEdges.bottom(); float sign = gfx::QuadF(tileRect).IsCounterClockwise() ? -1 : 1; @@ -878,9 +878,9 @@ void GLRenderer::drawYUVVideoQuad(const DrawingFrame& frame, const YUVVideoDrawQ const VideoYUVProgram* program = videoYUVProgram(); DCHECK(program && (program->initialized() || isContextLost())); - const VideoLayerImpl::FramePlane& yPlane = quad->yPlane(); - const VideoLayerImpl::FramePlane& uPlane = quad->uPlane(); - const VideoLayerImpl::FramePlane& vPlane = quad->vPlane(); + const VideoLayerImpl::FramePlane& yPlane = quad->y_plane; + const VideoLayerImpl::FramePlane& uPlane = quad->u_plane; + const VideoLayerImpl::FramePlane& vPlane = quad->v_plane; ResourceProvider::ScopedReadLockGL yPlaneLock(m_resourceProvider, yPlane.resourceId); ResourceProvider::ScopedReadLockGL uPlaneLock(m_resourceProvider, uPlane.resourceId); @@ -894,7 +894,7 @@ void GLRenderer::drawYUVVideoQuad(const DrawingFrame& frame, const YUVVideoDrawQ GLC(context(), context()->useProgram(program->program())); - GLC(context(), context()->uniform2f(program->vertexShader().texScaleLocation(), quad->texScale().width(), quad->texScale().height())); + GLC(context(), context()->uniform2f(program->vertexShader().texScaleLocation(), quad->tex_scale.width(), quad->tex_scale.height())); GLC(context(), context()->uniform1i(program->fragmentShader().yTextureLocation(), 1)); GLC(context(), context()->uniform1i(program->fragmentShader().uTextureLocation(), 2)); GLC(context(), context()->uniform1i(program->fragmentShader().vTextureLocation(), 3)); @@ -937,10 +937,10 @@ void GLRenderer::drawStreamVideoQuad(const DrawingFrame& frame, const StreamVide const VideoStreamTextureProgram* program = videoStreamTextureProgram(); GLC(context(), context()->useProgram(program->program())); - toGLMatrix(&glMatrix[0], quad->matrix()); + toGLMatrix(&glMatrix[0], quad->matrix); GLC(context(), context()->uniformMatrix4fv(program->vertexShader().texMatrixLocation(), 1, false, glMatrix)); - GLC(context(), context()->bindTexture(GL_TEXTURE_EXTERNAL_OES, quad->textureId())); + GLC(context(), context()->bindTexture(GL_TEXTURE_EXTERNAL_OES, quad->texture_id)); GLC(context(), context()->uniform1i(program->fragmentShader().samplerLocation(), 0)); @@ -977,19 +977,19 @@ struct TexTransformTextureProgramBinding : TextureProgramBinding { void GLRenderer::drawTextureQuad(const DrawingFrame& frame, const TextureDrawQuad* quad) { TexTransformTextureProgramBinding binding; - if (quad->flipped()) + if (quad->flipped) binding.set(textureProgramFlip(), context()); else binding.set(textureProgram(), context()); GLC(context(), context()->useProgram(binding.programId)); GLC(context(), context()->uniform1i(binding.samplerLocation, 0)); - const gfx::RectF& uvRect = quad->uvRect(); + const gfx::RectF& uvRect = quad->uv_rect; GLC(context(), context()->uniform4f(binding.texTransformLocation, uvRect.x(), uvRect.y(), uvRect.width(), uvRect.height())); - ResourceProvider::ScopedReadLockGL quadResourceLock(m_resourceProvider, quad->resourceId()); + ResourceProvider::ScopedReadLockGL quadResourceLock(m_resourceProvider, quad->resource_id); GLC(context(), context()->bindTexture(GL_TEXTURE_2D, quadResourceLock.textureId())); - if (!quad->premultipliedAlpha()) { + if (!quad->premultiplied_alpha) { // As it turns out, the premultiplied alpha blending function (ONE, ONE_MINUS_SRC_ALPHA) // will never cause the alpha channel to be set to anything less than 1.0 if it is // initialized to that value! Therefore, premultipliedAlpha being false is the first @@ -1004,7 +1004,7 @@ void GLRenderer::drawTextureQuad(const DrawingFrame& frame, const TextureDrawQua setShaderOpacity(quad->opacity(), binding.alphaLocation); drawQuadGeometry(frame, quad->quadTransform(), quad->rect, binding.matrixLocation); - if (!quad->premultipliedAlpha()) + if (!quad->premultiplied_alpha) GLC(m_context, m_context->blendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA)); } @@ -1015,12 +1015,12 @@ void GLRenderer::drawIOSurfaceQuad(const DrawingFrame& frame, const IOSurfaceDra GLC(context(), context()->useProgram(binding.programId)); GLC(context(), context()->uniform1i(binding.samplerLocation, 0)); - if (quad->orientation() == IOSurfaceDrawQuad::Flipped) - GLC(context(), context()->uniform4f(binding.texTransformLocation, 0, quad->ioSurfaceSize().height(), quad->ioSurfaceSize().width(), quad->ioSurfaceSize().height() * -1.0)); + if (quad->orientation == IOSurfaceDrawQuad::FLIPPED) + GLC(context(), context()->uniform4f(binding.texTransformLocation, 0, quad->io_surface_size.height(), quad->io_surface_size.width(), quad->io_surface_size.height() * -1.0)); else - GLC(context(), context()->uniform4f(binding.texTransformLocation, 0, 0, quad->ioSurfaceSize().width(), quad->ioSurfaceSize().height())); + GLC(context(), context()->uniform4f(binding.texTransformLocation, 0, 0, quad->io_surface_size.width(), quad->io_surface_size.height())); - GLC(context(), context()->bindTexture(GL_TEXTURE_RECTANGLE_ARB, quad->ioSurfaceTextureId())); + GLC(context(), context()->bindTexture(GL_TEXTURE_RECTANGLE_ARB, quad->io_surface_texture_id)); setShaderOpacity(quad->opacity(), binding.alphaLocation); drawQuadGeometry(frame, quad->quadTransform(), quad->rect, binding.matrixLocation); diff --git a/cc/heads_up_display_layer_impl.cc b/cc/heads_up_display_layer_impl.cc index 7ede4b1..4faf682 100644 --- a/cc/heads_up_display_layer_impl.cc +++ b/cc/heads_up_display_layer_impl.cc @@ -95,7 +95,9 @@ void HeadsUpDisplayLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& a bool premultipliedAlpha = true; gfx::RectF uvRect(0, 0, 1, 1); bool flipped = false; - quadSink.append(TextureDrawQuad::create(sharedQuadState, quadRect, opaqueRect, m_hudTexture->id(), premultipliedAlpha, uvRect, flipped).PassAs<DrawQuad>(), appendQuadsData); + scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create(); + quad->SetNew(sharedQuadState, quadRect, opaqueRect, m_hudTexture->id(), premultipliedAlpha, uvRect, flipped); + quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData); } void HeadsUpDisplayLayerImpl::updateHudTexture(ResourceProvider* resourceProvider) diff --git a/cc/io_surface_draw_quad.cc b/cc/io_surface_draw_quad.cc index 35ab66e..4851df1 100644 --- a/cc/io_surface_draw_quad.cc +++ b/cc/io_surface_draw_quad.cc @@ -8,25 +8,49 @@ namespace cc { -scoped_ptr<IOSurfaceDrawQuad> IOSurfaceDrawQuad::create(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, const gfx::Rect& opaqueRect, const gfx::Size& ioSurfaceSize, unsigned ioSurfaceTextureId, Orientation orientation) -{ - return make_scoped_ptr(new IOSurfaceDrawQuad(sharedQuadState, quadRect, opaqueRect, ioSurfaceSize, ioSurfaceTextureId, orientation)); +IOSurfaceDrawQuad::IOSurfaceDrawQuad() + : io_surface_texture_id(0), + orientation(FLIPPED) { } -IOSurfaceDrawQuad::IOSurfaceDrawQuad(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, const gfx::Rect& opaqueRect, const gfx::Size& ioSurfaceSize, unsigned ioSurfaceTextureId, Orientation orientation) - : m_ioSurfaceSize(ioSurfaceSize) - , m_ioSurfaceTextureId(ioSurfaceTextureId) - , m_orientation(orientation) -{ - gfx::Rect visibleRect = quadRect; - bool needsBlending = false; - DrawQuad::SetAll(sharedQuadState, DrawQuad::IO_SURFACE_CONTENT, quadRect, opaqueRect, visibleRect, needsBlending); +scoped_ptr<IOSurfaceDrawQuad> IOSurfaceDrawQuad::Create() { + return make_scoped_ptr(new IOSurfaceDrawQuad); } -const IOSurfaceDrawQuad* IOSurfaceDrawQuad::materialCast(const DrawQuad* quad) -{ - DCHECK(quad->material == DrawQuad::IO_SURFACE_CONTENT); - return static_cast<const IOSurfaceDrawQuad*>(quad); +void IOSurfaceDrawQuad::SetNew(const SharedQuadState* shared_quad_state, + gfx::Rect rect, + gfx::Rect opaque_rect, + gfx::Size io_surface_size, + unsigned io_surface_texture_id, + Orientation orientation) { + gfx::Rect visible_rect = rect; + bool needs_blending = false; + DrawQuad::SetAll(shared_quad_state, DrawQuad::IO_SURFACE_CONTENT, rect, + opaque_rect, visible_rect, needs_blending); + this->io_surface_size = io_surface_size; + this->io_surface_texture_id = io_surface_texture_id; + this->orientation = orientation; +} + +void IOSurfaceDrawQuad::SetAll(const SharedQuadState* shared_quad_state, + gfx::Rect rect, + gfx::Rect opaque_rect, + gfx::Rect visible_rect, + bool needs_blending, + gfx::Size io_surface_size, + unsigned io_surface_texture_id, + Orientation orientation) { + DrawQuad::SetAll(shared_quad_state, DrawQuad::IO_SURFACE_CONTENT, rect, + opaque_rect, visible_rect, needs_blending); + this->io_surface_size = io_surface_size; + this->io_surface_texture_id = io_surface_texture_id; + this->orientation = orientation; +} + +const IOSurfaceDrawQuad* IOSurfaceDrawQuad::MaterialCast( + const DrawQuad* quad) { + DCHECK(quad->material == DrawQuad::IO_SURFACE_CONTENT); + return static_cast<const IOSurfaceDrawQuad*>(quad); } } // namespace cc diff --git a/cc/io_surface_draw_quad.h b/cc/io_surface_draw_quad.h index 432960c..2bce6b7 100644 --- a/cc/io_surface_draw_quad.h +++ b/cc/io_surface_draw_quad.h @@ -13,25 +13,37 @@ namespace cc { class CC_EXPORT IOSurfaceDrawQuad : public DrawQuad { -public: - enum Orientation { - Flipped, - Unflipped - }; - - static scoped_ptr<IOSurfaceDrawQuad> create(const SharedQuadState*, const gfx::Rect&, const gfx::Rect& opaqueRect, const gfx::Size& ioSurfaceSize, unsigned ioSurfaceTextureId, Orientation); - - gfx::Size ioSurfaceSize() const { return m_ioSurfaceSize; } - unsigned ioSurfaceTextureId() const { return m_ioSurfaceTextureId; } - Orientation orientation() const { return m_orientation; } - - static const IOSurfaceDrawQuad* materialCast(const DrawQuad*); -private: - IOSurfaceDrawQuad(const SharedQuadState*, const gfx::Rect&, const gfx::Rect& opaqueRect, const gfx::Size& ioSurfaceSize, unsigned ioSurfaceTextureId, Orientation); - - gfx::Size m_ioSurfaceSize; - unsigned m_ioSurfaceTextureId; - Orientation m_orientation; + public: + enum Orientation { + FLIPPED, + UNFLIPPED + }; + + static scoped_ptr<IOSurfaceDrawQuad> Create(); + + void SetNew(const SharedQuadState* shared_quad_state, + gfx::Rect rect, + gfx::Rect opaque_rect, + gfx::Size io_surface_size, + unsigned io_surface_texture_id, + Orientation orientation); + + void SetAll(const SharedQuadState* shared_quad_state, + gfx::Rect rect, + gfx::Rect opaque_rect, + gfx::Rect visible_rect, + bool needs_blending, + gfx::Size io_surface_size, + unsigned io_surface_texture_id, + Orientation orientation); + + gfx::Size io_surface_size; + unsigned io_surface_texture_id; + Orientation orientation; + + static const IOSurfaceDrawQuad* MaterialCast(const DrawQuad*); + private: + IOSurfaceDrawQuad(); }; } diff --git a/cc/io_surface_layer_impl.cc b/cc/io_surface_layer_impl.cc index 6d3abcb..bcf0072 100644 --- a/cc/io_surface_layer_impl.cc +++ b/cc/io_surface_layer_impl.cc @@ -79,7 +79,9 @@ void IOSurfaceLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& append gfx::Rect quadRect(gfx::Point(), contentBounds()); gfx::Rect opaqueRect(contentsOpaque() ? quadRect : gfx::Rect()); - quadSink.append(IOSurfaceDrawQuad::create(sharedQuadState, quadRect, opaqueRect, m_ioSurfaceSize, m_ioSurfaceTextureId, IOSurfaceDrawQuad::Flipped).PassAs<DrawQuad>(), appendQuadsData); + scoped_ptr<IOSurfaceDrawQuad> quad = IOSurfaceDrawQuad::Create(); + quad->SetNew(sharedQuadState, quadRect, opaqueRect, m_ioSurfaceSize, m_ioSurfaceTextureId, IOSurfaceDrawQuad::FLIPPED); + quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData); } void IOSurfaceLayerImpl::dumpLayerProperties(std::string* str, int indent) const diff --git a/cc/layer_impl.cc b/cc/layer_impl.cc index 70992f4..4927e74 100644 --- a/cc/layer_impl.cc +++ b/cc/layer_impl.cc @@ -179,7 +179,9 @@ void LayerImpl::appendDebugBorderQuad(QuadSink& quadList, const SharedQuadState* getDebugBorderProperties(&color, &width); gfx::Rect contentRect(gfx::Point(), contentBounds()); - quadList.append(DebugBorderDrawQuad::create(sharedQuadState, contentRect, color, width).PassAs<DrawQuad>(), appendQuadsData); + scoped_ptr<DebugBorderDrawQuad> debugBorderQuad = DebugBorderDrawQuad::Create(); + debugBorderQuad->SetNew(sharedQuadState, contentRect, color, width); + quadList.append(debugBorderQuad.PassAs<DrawQuad>(), appendQuadsData); } bool LayerImpl::hasContributingDelegatedRenderPasses() const diff --git a/cc/layer_tree_host_impl.cc b/cc/layer_tree_host_impl.cc index b558568..e305b88 100644 --- a/cc/layer_tree_host_impl.cc +++ b/cc/layer_tree_host_impl.cc @@ -564,19 +564,19 @@ static void removeRenderPassesRecursive(RenderPass::Id removeRenderPassId, Layer if (currentQuad->material != DrawQuad::RENDER_PASS) continue; - RenderPass::Id nextRemoveRenderPassId = RenderPassDrawQuad::materialCast(currentQuad)->renderPassId(); + RenderPass::Id nextRemoveRenderPassId = RenderPassDrawQuad::MaterialCast(currentQuad)->render_pass_id; removeRenderPassesRecursive(nextRemoveRenderPassId, frame); } } bool LayerTreeHostImpl::CullRenderPassesWithCachedTextures::shouldRemoveRenderPass(const RenderPassDrawQuad& quad, const FrameData&) const { - return quad.contentsChangedSinceLastFrame().IsEmpty() && m_renderer.haveCachedResourcesForRenderPassId(quad.renderPassId()); + return quad.contents_changed_since_last_frame.IsEmpty() && m_renderer.haveCachedResourcesForRenderPassId(quad.render_pass_id); } bool LayerTreeHostImpl::CullRenderPassesWithNoQuads::shouldRemoveRenderPass(const RenderPassDrawQuad& quad, const FrameData& frame) const { - const RenderPass* renderPass = findRenderPassById(quad.renderPassId(), frame); + const RenderPass* renderPass = findRenderPassById(quad.render_pass_id, frame); const RenderPassList& renderPasses = frame.renderPasses; RenderPassList::const_iterator foundPass = std::find(renderPasses.begin(), renderPasses.end(), renderPass); @@ -592,7 +592,7 @@ bool LayerTreeHostImpl::CullRenderPassesWithNoQuads::shouldRemoveRenderPass(cons if (currentQuad->material != DrawQuad::RENDER_PASS) return false; - const RenderPass* contributingPass = findRenderPassById(RenderPassDrawQuad::materialCast(currentQuad)->renderPassId(), frame); + const RenderPass* contributingPass = findRenderPassById(RenderPassDrawQuad::MaterialCast(currentQuad)->render_pass_id, frame); RenderPassList::const_iterator foundContributingPass = std::find(renderPasses.begin(), renderPasses.end(), contributingPass); if (foundContributingPass != renderPasses.end()) return false; @@ -629,7 +629,7 @@ void LayerTreeHostImpl::removeRenderPasses(RenderPassCuller culler, FrameData& f // change. So, capture the iterator position from the end of the // list, and restore it after the change. int positionFromEnd = frame.renderPasses.size() - it; - removeRenderPassesRecursive(renderPassQuad->renderPassId(), frame); + removeRenderPassesRecursive(renderPassQuad->render_pass_id, frame); it = frame.renderPasses.size() - positionFromEnd; DCHECK(it >= 0); } diff --git a/cc/layer_tree_host_impl_unittest.cc b/cc/layer_tree_host_impl_unittest.cc index 35017a4..6b7463c 100644 --- a/cc/layer_tree_host_impl_unittest.cc +++ b/cc/layer_tree_host_impl_unittest.cc @@ -1602,7 +1602,8 @@ public: opaqueRect = m_opaqueContentRect; SharedQuadState* sharedQuadState = quadSink.useSharedQuadState(createSharedQuadState()); - scoped_ptr<TileDrawQuad> testBlendingDrawQuad = TileDrawQuad::create(sharedQuadState, m_quadRect, opaqueRect, m_resourceId, gfx::RectF(0, 0, 1, 1), gfx::Size(1, 1), false, false, false, false, false); + scoped_ptr<TileDrawQuad> testBlendingDrawQuad = TileDrawQuad::Create(); + testBlendingDrawQuad->SetNew(sharedQuadState, m_quadRect, opaqueRect, m_resourceId, gfx::RectF(0, 0, 1, 1), gfx::Size(1, 1), false, false, false, false, false); testBlendingDrawQuad->visible_rect = m_quadVisibleRect; EXPECT_EQ(m_blend, testBlendingDrawQuad->ShouldDrawWithBlending()); EXPECT_EQ(m_hasRenderSurface, !!renderSurface()); @@ -2105,7 +2106,8 @@ public: SkColor gray = SkColorSetRGB(100, 100, 100); gfx::Rect quadRect(gfx::Point(0, 0), contentBounds()); - scoped_ptr<SolidColorDrawQuad> myQuad = SolidColorDrawQuad::create(sharedQuadState, quadRect, gray); + scoped_ptr<SolidColorDrawQuad> myQuad = SolidColorDrawQuad::Create(); + myQuad->SetNew(sharedQuadState, quadRect, gray); quadSink.append(myQuad.PassAs<DrawQuad>(), appendQuadsData); } @@ -2714,7 +2716,8 @@ static inline scoped_ptr<RenderPass> createRenderPassWithResource(ResourceProvid scoped_ptr<TestRenderPass> pass = TestRenderPass::create(RenderPass::Id(1, 1), gfx::Rect(0, 0, 1, 1), WebTransformationMatrix()); scoped_ptr<SharedQuadState> sharedState = SharedQuadState::create(WebTransformationMatrix(), gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1), 1); - scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::create(sharedState.get(), gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1), resourceId, false, gfx::RectF(0, 0, 1, 1), false); + scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create(); + quad->SetNew(sharedState.get(), gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1), resourceId, false, gfx::RectF(0, 0, 1, 1), false); pass->appendSharedQuadState(sharedState.Pass()); pass->appendQuad(quad.PassAs<DrawQuad>()); @@ -3158,8 +3161,8 @@ TEST_P(LayerTreeHostImplTest, textureCachingWithClipping) EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100), frame.renderPasses[0]->outputRect()); EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quadList()[0]->material); - const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[1]->quadList()[0]); - EXPECT_FALSE(quad->contentsChangedSinceLastFrame().IsEmpty()); + const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quadList()[0]); + EXPECT_FALSE(quad->contents_changed_since_last_frame.IsEmpty()); myHostImpl->drawLayers(frame); myHostImpl->didDrawAllLayers(frame); @@ -3816,8 +3819,8 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCaching) EXPECT_EQ(1U, frame.renderPasses[1]->quadList().size()); EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quadList()[0]->material); - const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[1]->quadList()[0]); - RenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId()); + const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quadList()[0]); + RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id); EXPECT_FALSE(targetPass->damageRect().IsEmpty()); myHostImpl->drawLayers(frame); @@ -3834,8 +3837,8 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCaching) EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size()); EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quadList()[0]->material); - const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[0]->quadList()[0]); - RenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId()); + const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quadList()[0]); + RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id); EXPECT_TRUE(targetPass->damageRect().IsEmpty()); myHostImpl->drawLayers(frame); @@ -3853,8 +3856,8 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCaching) EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size()); EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quadList()[0]->material); - const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[0]->quadList()[0]); - RenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId()); + const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quadList()[0]); + RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id); EXPECT_TRUE(targetPass->damageRect().IsEmpty()); myHostImpl->drawLayers(frame); @@ -3874,8 +3877,8 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCaching) EXPECT_EQ(DrawQuad::SOLID_COLOR, frame.renderPasses[0]->quadList()[0]->material); EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quadList()[0]->material); - const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[1]->quadList()[0]); - RenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId()); + const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quadList()[0]); + RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id); EXPECT_FALSE(targetPass->damageRect().IsEmpty()); myHostImpl->drawLayers(frame); @@ -3901,8 +3904,8 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCaching) EXPECT_EQ(1U, frame.renderPasses[1]->quadList().size()); EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quadList()[0]->material); - const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[1]->quadList()[0]); - RenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId()); + const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quadList()[0]); + RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id); EXPECT_TRUE(targetPass->damageRect().IsEmpty()); // Was our surface evicted? @@ -3922,8 +3925,8 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCaching) EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size()); EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quadList()[0]->material); - const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[0]->quadList()[0]); - RenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId()); + const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quadList()[0]); + RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id); EXPECT_TRUE(targetPass->damageRect().IsEmpty()); myHostImpl->drawLayers(frame); @@ -3943,8 +3946,8 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCaching) EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size()); EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quadList()[0]->material); - const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[0]->quadList()[0]); - RenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId()); + const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quadList()[0]); + RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id); EXPECT_TRUE(targetPass->damageRect().IsEmpty()); myHostImpl->drawLayers(frame); @@ -3975,8 +3978,8 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCachingNoPartialSwap) EXPECT_EQ(1U, frame.renderPasses[1]->quadList().size()); EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quadList()[0]->material); - const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[1]->quadList()[0]); - RenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId()); + const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quadList()[0]); + RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id); EXPECT_FALSE(targetPass->damageRect().IsEmpty()); EXPECT_FALSE(frame.renderPasses[0]->damageRect().IsEmpty()); @@ -4017,8 +4020,8 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCachingNoPartialSwap) EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size()); EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quadList()[0]->material); - const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[0]->quadList()[0]); - RenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId()); + const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quadList()[0]); + RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id); EXPECT_TRUE(targetPass->damageRect().IsEmpty()); myHostImpl->drawLayers(frame); @@ -4038,8 +4041,8 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCachingNoPartialSwap) EXPECT_EQ(DrawQuad::SOLID_COLOR, frame.renderPasses[0]->quadList()[0]->material); EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quadList()[0]->material); - const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[1]->quadList()[0]); - RenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId()); + const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quadList()[0]); + RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id); EXPECT_FALSE(targetPass->damageRect().IsEmpty()); myHostImpl->drawLayers(frame); @@ -4065,8 +4068,8 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCachingNoPartialSwap) EXPECT_EQ(1U, frame.renderPasses[1]->quadList().size()); EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quadList()[0]->material); - const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[1]->quadList()[0]); - RenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId()); + const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quadList()[0]); + RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id); EXPECT_TRUE(targetPass->damageRect().IsEmpty()); // Was our surface evicted? @@ -4104,8 +4107,8 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCachingNoPartialSwap) EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size()); EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quadList()[0]->material); - const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[0]->quadList()[0]); - RenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId()); + const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quadList()[0]); + RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id); EXPECT_TRUE(targetPass->damageRect().IsEmpty()); myHostImpl->drawLayers(frame); @@ -4212,7 +4215,8 @@ static void configureRenderPassTestData(const char* testScript, RenderPassRemova while (*currentChar && *currentChar != '\n') { if (*currentChar == 's') { // Solid color draw quad - scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::create(testData.sharedQuadState.get(), gfx::Rect(0, 0, 10, 10), SK_ColorWHITE); + scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create(); + quad->SetNew(testData.sharedQuadState.get(), gfx::Rect(0, 0, 10, 10), SK_ColorWHITE); renderPass->appendQuad(quad.PassAs<DrawQuad>()); currentChar++; @@ -4254,7 +4258,8 @@ static void configureRenderPassTestData(const char* testScript, RenderPassRemova gfx::Rect quadRect = gfx::Rect(0, 0, 1, 1); gfx::Rect contentsChangedRect = contentsChanged ? quadRect : gfx::Rect(); - scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::create(testData.sharedQuadState.get(), quadRect, newRenderPassId, isReplica, 1, contentsChangedRect, 1, 1, 0, 0); + scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::Create(); + quad->SetNew(testData.sharedQuadState.get(), quadRect, newRenderPassId, isReplica, 1, contentsChangedRect, 1, 1, 0, 0); renderPass->appendQuad(quad.PassAs<DrawQuad>()); } } @@ -4284,9 +4289,9 @@ void dumpRenderPassTestData(const RenderPassRemovalTestData& testData, char* buf pos++; break; case DrawQuad::RENDER_PASS: - *pos = RenderPassDrawQuad::materialCast(currentQuad)->renderPassId().layerId; + *pos = RenderPassDrawQuad::MaterialCast(currentQuad)->render_pass_id.layerId; pos++; - *pos = RenderPassDrawQuad::materialCast(currentQuad)->renderPassId().index; + *pos = RenderPassDrawQuad::MaterialCast(currentQuad)->render_pass_id.index; pos++; break; default: diff --git a/cc/nine_patch_layer_impl.cc b/cc/nine_patch_layer_impl.cc index 5da260d..c386670 100644 --- a/cc/nine_patch_layer_impl.cc +++ b/cc/nine_patch_layer_impl.cc @@ -86,15 +86,39 @@ void NinePatchLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& append // Nothing is opaque here. // TODO(danakj): Should we look at the SkBitmaps to determine opaqueness? gfx::Rect opaqueRect; + scoped_ptr<TextureDrawQuad> quad; - quadSink.append(TextureDrawQuad::create(sharedQuadState, topLeft, opaqueRect, m_resourceId, premultipliedAlpha, uvTopLeft, flipped).PassAs<DrawQuad>(), appendQuadsData); - quadSink.append(TextureDrawQuad::create(sharedQuadState, topRight, opaqueRect, m_resourceId, premultipliedAlpha, uvTopRight, flipped).PassAs<DrawQuad>(), appendQuadsData); - quadSink.append(TextureDrawQuad::create(sharedQuadState, bottomLeft, opaqueRect, m_resourceId, premultipliedAlpha, uvBottomLeft, flipped).PassAs<DrawQuad>(), appendQuadsData); - quadSink.append(TextureDrawQuad::create(sharedQuadState, bottomRight, opaqueRect, m_resourceId, premultipliedAlpha, uvBottomRight, flipped).PassAs<DrawQuad>(), appendQuadsData); - quadSink.append(TextureDrawQuad::create(sharedQuadState, top, opaqueRect, m_resourceId, premultipliedAlpha, uvTop, flipped).PassAs<DrawQuad>(), appendQuadsData); - quadSink.append(TextureDrawQuad::create(sharedQuadState, left, opaqueRect, m_resourceId, premultipliedAlpha, uvLeft, flipped).PassAs<DrawQuad>(), appendQuadsData); - quadSink.append(TextureDrawQuad::create(sharedQuadState, right, opaqueRect, m_resourceId, premultipliedAlpha, uvRight, flipped).PassAs<DrawQuad>(), appendQuadsData); - quadSink.append(TextureDrawQuad::create(sharedQuadState, bottom, opaqueRect, m_resourceId, premultipliedAlpha, uvBottom, flipped).PassAs<DrawQuad>(), appendQuadsData); + quad = TextureDrawQuad::Create(); + quad->SetNew(sharedQuadState, topLeft, opaqueRect, m_resourceId, premultipliedAlpha, uvTopLeft, flipped); + quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData); + + quad = TextureDrawQuad::Create(); + quad->SetNew(sharedQuadState, topRight, opaqueRect, m_resourceId, premultipliedAlpha, uvTopRight, flipped); + quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData); + + quad = TextureDrawQuad::Create(); + quad->SetNew(sharedQuadState, bottomLeft, opaqueRect, m_resourceId, premultipliedAlpha, uvBottomLeft, flipped); + quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData); + + quad = TextureDrawQuad::Create(); + quad->SetNew(sharedQuadState, bottomRight, opaqueRect, m_resourceId, premultipliedAlpha, uvBottomRight, flipped); + quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData); + + quad = TextureDrawQuad::Create(); + quad->SetNew(sharedQuadState, top, opaqueRect, m_resourceId, premultipliedAlpha, uvTop, flipped); + quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData); + + quad = TextureDrawQuad::Create(); + quad->SetNew(sharedQuadState, left, opaqueRect, m_resourceId, premultipliedAlpha, uvLeft, flipped); + quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData); + + quad = TextureDrawQuad::Create(); + quad->SetNew(sharedQuadState, right, opaqueRect, m_resourceId, premultipliedAlpha, uvRight, flipped); + quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData); + + quad = TextureDrawQuad::Create(); + quad->SetNew(sharedQuadState, bottom, opaqueRect, m_resourceId, premultipliedAlpha, uvBottom, flipped); + quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData); } void NinePatchLayerImpl::didDraw(ResourceProvider* resourceProvider) diff --git a/cc/nine_patch_layer_impl_unittest.cc b/cc/nine_patch_layer_impl_unittest.cc index b24f569..e63f25c 100644 --- a/cc/nine_patch_layer_impl_unittest.cc +++ b/cc/nine_patch_layer_impl_unittest.cc @@ -75,8 +75,8 @@ TEST(NinePatchLayerImplTest, verifyDrawQuads) Region texRemaining(bitmapRect); for (size_t i = 0; i < quads.size(); ++i) { DrawQuad* quad = quads[i]; - const TextureDrawQuad* texQuad = TextureDrawQuad::materialCast(quad); - gfx::RectF texRect = texQuad->uvRect(); + const TextureDrawQuad* texQuad = TextureDrawQuad::MaterialCast(quad); + gfx::RectF texRect = texQuad->uv_rect; texRect.Scale(bitmapSize.width(), bitmapSize.height()); texRemaining.Subtract(Region(ToRoundedIntRect(texRect))); } diff --git a/cc/picture_layer_impl.cc b/cc/picture_layer_impl.cc index 658c68f..5c1d8e8 100644 --- a/cc/picture_layer_impl.cc +++ b/cc/picture_layer_impl.cc @@ -61,18 +61,19 @@ void PictureLayerImpl::appendQuads(QuadSink& quadSink, bool outside_right_edge = geometry_rect.right() == content_rect.right(); bool outside_bottom_edge = geometry_rect.bottom() == content_rect.bottom(); - quadSink.append(TileDrawQuad::create( - sharedQuadState, - geometry_rect, - opaque_rect, - resource, - texture_rect, - iter.texture_size(), - iter->contents_swizzled(), - outside_left_edge && useAA, - outside_top_edge && useAA, - outside_right_edge && useAA, - outside_bottom_edge && useAA).PassAs<DrawQuad>(), appendQuadsData); + scoped_ptr<TileDrawQuad> quad = TileDrawQuad::Create(); + quad->SetNew(sharedQuadState, + geometry_rect, + opaque_rect, + resource, + texture_rect, + iter.texture_size(), + iter->contents_swizzled(), + outside_left_edge && useAA, + outside_top_edge && useAA, + outside_right_edge && useAA, + outside_bottom_edge && useAA); + quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData); } } diff --git a/cc/quad_culler.cc b/cc/quad_culler.cc index 5ac52ae..fe2072a 100644 --- a/cc/quad_culler.cc +++ b/cc/quad_culler.cc @@ -53,7 +53,9 @@ static inline bool appendQuadInternal(scoped_ptr<DrawQuad> drawQuad, const gfx:: if (createDebugBorderQuads && !drawQuad->IsDebugQuad() && drawQuad->visible_rect != drawQuad->rect) { SkColor color = DebugColors::CulledTileBorderColor(); float width = DebugColors::CulledTileBorderWidth(layer ? layer->layerTreeHostImpl() : NULL); - quadList.append(DebugBorderDrawQuad::create(drawQuad->shared_quad_state, drawQuad->visible_rect, color, width).PassAs<DrawQuad>()); + scoped_ptr<DebugBorderDrawQuad> debugBorderQuad = DebugBorderDrawQuad::Create(); + debugBorderQuad->SetNew(drawQuad->shared_quad_state, drawQuad->visible_rect, color, width); + quadList.append(debugBorderQuad.PassAs<DrawQuad>()); } // Pass the quad after we're done using it. diff --git a/cc/render_pass.cc b/cc/render_pass.cc index 01d7877..ac8dea4 100644 --- a/cc/render_pass.cc +++ b/cc/render_pass.cc @@ -99,7 +99,9 @@ void RenderPass::appendQuadsToFillScreen(LayerImpl* rootLayer, SkColor screenBac // The root layer transform is composed of translations and scales only, no perspective, so mapping is sufficient. gfx::Rect layerRect = MathUtil::mapClippedRect(transformToLayerSpace, fillRects.rect()); // Skip the quad culler and just append the quads directly to avoid occlusion checks. - m_quadList.append(SolidColorDrawQuad::create(sharedQuadState, layerRect, screenBackgroundColor).PassAs<DrawQuad>()); + scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create(); + quad->SetNew(sharedQuadState, layerRect, screenBackgroundColor); + m_quadList.append(quad.PassAs<DrawQuad>()); } } diff --git a/cc/render_pass_draw_quad.cc b/cc/render_pass_draw_quad.cc index 6a06825..937a621 100644 --- a/cc/render_pass_draw_quad.cc +++ b/cc/render_pass_draw_quad.cc @@ -6,42 +6,89 @@ namespace cc { -scoped_ptr<RenderPassDrawQuad> RenderPassDrawQuad::create(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, RenderPass::Id renderPassId, bool isReplica, const ResourceProvider::ResourceId maskResourceId, const gfx::Rect& contentsChangedSinceLastFrame, float maskTexCoordScaleX, float maskTexCoordScaleY, float maskTexCoordOffsetX, float maskTexCoordOffsetY) -{ - return make_scoped_ptr(new RenderPassDrawQuad(sharedQuadState, quadRect, renderPassId, isReplica, maskResourceId, contentsChangedSinceLastFrame, maskTexCoordScaleX, maskTexCoordScaleY, maskTexCoordOffsetX, maskTexCoordOffsetY)); +RenderPassDrawQuad::RenderPassDrawQuad() + : render_pass_id(RenderPass::Id(-1, -1)), + is_replica(false), + mask_resource_id(-1), + mask_tex_coord_scale_x(0), + mask_tex_coord_scale_y(0), + mask_tex_coord_offset_x(0), + mask_tex_coord_offset_y(0) { } -RenderPassDrawQuad::RenderPassDrawQuad(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, RenderPass::Id renderPassId, bool isReplica, ResourceProvider::ResourceId maskResourceId, const gfx::Rect& contentsChangedSinceLastFrame, float maskTexCoordScaleX, float maskTexCoordScaleY, float maskTexCoordOffsetX, float maskTexCoordOffsetY) - : m_renderPassId(renderPassId) - , m_isReplica(isReplica) - , m_maskResourceId(maskResourceId) - , m_contentsChangedSinceLastFrame(contentsChangedSinceLastFrame) - , m_maskTexCoordScaleX(maskTexCoordScaleX) - , m_maskTexCoordScaleY(maskTexCoordScaleY) - , m_maskTexCoordOffsetX(maskTexCoordOffsetX) - , m_maskTexCoordOffsetY(maskTexCoordOffsetY) -{ - DCHECK(m_renderPassId.layerId > 0); - DCHECK(m_renderPassId.index >= 0); - - gfx::Rect opaqueRect; - gfx::Rect visibleRect = quadRect; - bool needsBlending = false; - DrawQuad::SetAll(sharedQuadState, DrawQuad::RENDER_PASS, quadRect, opaqueRect, visibleRect, needsBlending); +scoped_ptr<RenderPassDrawQuad> RenderPassDrawQuad::Create() { + return make_scoped_ptr(new RenderPassDrawQuad); } -const RenderPassDrawQuad* RenderPassDrawQuad::materialCast(const DrawQuad* quad) -{ - DCHECK(quad->material == DrawQuad::RENDER_PASS); - return static_cast<const RenderPassDrawQuad*>(quad); +scoped_ptr<RenderPassDrawQuad> RenderPassDrawQuad::Copy( + const SharedQuadState* copied_shared_quad_state, + RenderPass::Id copied_render_pass_id) const { + scoped_ptr<RenderPassDrawQuad> copy_quad(new RenderPassDrawQuad(*MaterialCast(this))); + copy_quad->shared_quad_state = copied_shared_quad_state; + copy_quad->render_pass_id = copied_render_pass_id; + return copy_quad.Pass(); } -scoped_ptr<RenderPassDrawQuad> RenderPassDrawQuad::copy(const SharedQuadState* copiedSharedQuadState, RenderPass::Id copiedRenderPassId) const -{ - scoped_ptr<RenderPassDrawQuad> copyQuad(new RenderPassDrawQuad(*materialCast(this))); - copyQuad->shared_quad_state = copiedSharedQuadState; - copyQuad->m_renderPassId = copiedRenderPassId; - return copyQuad.Pass(); +void RenderPassDrawQuad::SetNew(const SharedQuadState* shared_quad_state, + gfx::Rect rect, + RenderPass::Id render_pass_id, + bool is_replica, + ResourceProvider::ResourceId mask_resource_id, + gfx::Rect contents_changed_since_last_frame, + float mask_tex_coord_scale_x, + float mask_tex_coord_scale_y, + float mask_tex_coord_offset_x, + float mask_tex_coord_offset_y) { + DCHECK(render_pass_id.layerId > 0); + DCHECK(render_pass_id.index >= 0); + + gfx::Rect opaque_rect; + gfx::Rect visible_rect = rect; + bool needs_blending = false; + DrawQuad::SetAll(shared_quad_state, DrawQuad::RENDER_PASS, rect, opaque_rect, + visible_rect, needs_blending); + this->render_pass_id = render_pass_id; + this->is_replica = is_replica; + this->mask_resource_id = mask_resource_id; + this->contents_changed_since_last_frame = contents_changed_since_last_frame; + this->mask_tex_coord_scale_x = mask_tex_coord_scale_x; + this->mask_tex_coord_scale_y = mask_tex_coord_scale_y; + this->mask_tex_coord_offset_x = mask_tex_coord_offset_x; + this->mask_tex_coord_offset_y = mask_tex_coord_offset_y; +} + +void RenderPassDrawQuad::SetAll(const SharedQuadState* shared_quad_state, + gfx::Rect rect, + gfx::Rect opaque_rect, + gfx::Rect visible_rect, + bool needs_blending, + RenderPass::Id render_pass_id, + bool is_replica, + ResourceProvider::ResourceId mask_resource_id, + gfx::Rect contents_changed_since_last_frame, + float mask_tex_coord_scale_x, + float mask_tex_coord_scale_y, + float mask_tex_coord_offset_x, + float mask_tex_coord_offset_y) { + DCHECK(render_pass_id.layerId > 0); + DCHECK(render_pass_id.index >= 0); + + DrawQuad::SetAll(shared_quad_state, DrawQuad::RENDER_PASS, rect, opaque_rect, + visible_rect, needs_blending); + this->render_pass_id = render_pass_id; + this->is_replica = is_replica; + this->mask_resource_id = mask_resource_id; + this->contents_changed_since_last_frame = contents_changed_since_last_frame; + this->mask_tex_coord_scale_x = mask_tex_coord_scale_x; + this->mask_tex_coord_scale_y = mask_tex_coord_scale_y; + this->mask_tex_coord_offset_x = mask_tex_coord_offset_x; + this->mask_tex_coord_offset_y = mask_tex_coord_offset_y; +} + +const RenderPassDrawQuad* RenderPassDrawQuad::MaterialCast( + const DrawQuad* quad) { + DCHECK(quad->material == DrawQuad::RENDER_PASS); + return static_cast<const RenderPassDrawQuad*>(quad); } } // namespace cc diff --git a/cc/render_pass_draw_quad.h b/cc/render_pass_draw_quad.h index f58a7ec9..b4c7c75 100644 --- a/cc/render_pass_draw_quad.h +++ b/cc/render_pass_draw_quad.h @@ -15,33 +15,51 @@ namespace cc { class CC_EXPORT RenderPassDrawQuad : public DrawQuad { -public: - static scoped_ptr<RenderPassDrawQuad> create(const SharedQuadState*, const gfx::Rect&, RenderPass::Id renderPassId, bool isReplica, ResourceProvider::ResourceId maskResourceId, const gfx::Rect& contentsChangedSinceLastFrame, float maskTexCoordScaleX, float maskTexCoordScaleY, float maskTexCoordOffsetX, float maskTexCoordOffsetY); + public: + static scoped_ptr<RenderPassDrawQuad> Create(); - RenderPass::Id renderPassId() const { return m_renderPassId; } - bool isReplica() const { return m_isReplica; } - ResourceProvider::ResourceId maskResourceId() const { return m_maskResourceId; } - const gfx::Rect& contentsChangedSinceLastFrame() const { return m_contentsChangedSinceLastFrame; } + void SetNew(const SharedQuadState* shared_quad_state, + gfx::Rect rect, + RenderPass::Id render_pass_id, + bool is_replica, + ResourceProvider::ResourceId mask_resource_id, + gfx::Rect contents_changed_since_last_frame, + float mask_tex_coord_scale_x, + float mask_tex_coord_scale_y, + float mask_tex_coord_offset_x, + float mask_tex_coord_offset_y); - static const RenderPassDrawQuad* materialCast(const DrawQuad*); - float maskTexCoordScaleX() const { return m_maskTexCoordScaleX; } - float maskTexCoordScaleY() const { return m_maskTexCoordScaleY; } - float maskTexCoordOffsetX() const { return m_maskTexCoordOffsetX; } - float maskTexCoordOffsetY() const { return m_maskTexCoordOffsetY; } + void SetAll(const SharedQuadState* shared_quad_state, + gfx::Rect rect, + gfx::Rect opaque_rect, + gfx::Rect visible_rect, + bool needs_blending, + RenderPass::Id render_pass_id, + bool is_replica, + ResourceProvider::ResourceId mask_resource_id, + gfx::Rect contents_changed_since_last_frame, + float mask_tex_coord_scale_x, + float mask_tex_coord_scale_y, + float mask_tex_coord_offset_x, + float mask_tex_coord_offset_y); - scoped_ptr<RenderPassDrawQuad> copy(const SharedQuadState* copiedSharedQuadState, RenderPass::Id copiedRenderPassId) const; + scoped_ptr<RenderPassDrawQuad> Copy( + const SharedQuadState* copied_shared_quad_state, + RenderPass::Id copied_render_pass_id) const; + RenderPass::Id render_pass_id; + bool is_replica; + ResourceProvider::ResourceId mask_resource_id; + gfx::Rect contents_changed_since_last_frame; + // TODO(danakj): Make these a tex_coord_rect like TileDrawQuad. + float mask_tex_coord_scale_x; + float mask_tex_coord_scale_y; + float mask_tex_coord_offset_x; + float mask_tex_coord_offset_y; + + static const RenderPassDrawQuad* MaterialCast(const DrawQuad*); private: - RenderPassDrawQuad(const SharedQuadState*, const gfx::Rect&, RenderPass::Id renderPassId, bool isReplica, ResourceProvider::ResourceId maskResourceId, const gfx::Rect& contentsChangedSinceLastFrame, float maskTexCoordScaleX, float maskTexCoordScaleY, float maskTexCoordOffsetX, float maskTexCoordOffsetY); - - RenderPass::Id m_renderPassId; - bool m_isReplica; - ResourceProvider::ResourceId m_maskResourceId; - gfx::Rect m_contentsChangedSinceLastFrame; - float m_maskTexCoordScaleX; - float m_maskTexCoordScaleY; - float m_maskTexCoordOffsetX; - float m_maskTexCoordOffsetY; + RenderPassDrawQuad(); }; } diff --git a/cc/render_pass_unittest.cc b/cc/render_pass_unittest.cc index 2ba9624..6666986 100644 --- a/cc/render_pass_unittest.cc +++ b/cc/render_pass_unittest.cc @@ -62,7 +62,10 @@ TEST(RenderPassTest, copyShouldBeIdenticalExceptIdAndQuads) // Stick a quad in the pass, this should not get copied. pass->sharedQuadStateList().append(SharedQuadState::create(WebTransformationMatrix(), gfx::Rect(), gfx::Rect(), 1)); - pass->quadList().append(CheckerboardDrawQuad::create(pass->sharedQuadStateList().last(), gfx::Rect(), SkColor()).PassAs<DrawQuad>()); + + scoped_ptr<CheckerboardDrawQuad> checkerboardQuad = CheckerboardDrawQuad::Create(); + checkerboardQuad->SetNew(pass->sharedQuadStateList().last(), gfx::Rect(), SkColor()); + pass->quadList().append(checkerboardQuad.PassAs<DrawQuad>()); RenderPass::Id newId(63, 4); diff --git a/cc/render_surface_impl.cc b/cc/render_surface_impl.cc index 3f3d3d1..83be66da 100644 --- a/cc/render_surface_impl.cc +++ b/cc/render_surface_impl.cc @@ -203,7 +203,9 @@ void RenderSurfaceImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQ if (m_owningLayer->showDebugBorders()) { SkColor color = forReplica ? DebugColors::SurfaceReplicaBorderColor() : DebugColors::SurfaceBorderColor(); float width = forReplica ? DebugColors::SurfaceReplicaBorderWidth(m_owningLayer->layerTreeHostImpl()) : DebugColors::SurfaceBorderWidth(m_owningLayer->layerTreeHostImpl()); - quadSink.append(DebugBorderDrawQuad::create(sharedQuadState, contentRect(), color, width).PassAs<DrawQuad>(), appendQuadsData); + scoped_ptr<DebugBorderDrawQuad> debugBorderQuad = DebugBorderDrawQuad::Create(); + debugBorderQuad->SetNew(sharedQuadState, contentRect(), color, width); + quadSink.append(debugBorderQuad.PassAs<DrawQuad>(), appendQuadsData); } // FIXME: By using the same RenderSurfaceImpl for both the content and its reflection, @@ -236,8 +238,10 @@ void RenderSurfaceImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQ ResourceProvider::ResourceId maskResourceId = maskLayer ? maskLayer->contentsResourceId() : 0; gfx::Rect contentsChangedSinceLastFrame = contentsChanged() ? m_contentRect : gfx::Rect(); - quadSink.append(RenderPassDrawQuad::create(sharedQuadState, contentRect(), renderPassId, forReplica, maskResourceId, contentsChangedSinceLastFrame, - maskTexCoordScaleX, maskTexCoordScaleY, maskTexCoordOffsetX, maskTexCoordOffsetY).PassAs<DrawQuad>(), appendQuadsData); + scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::Create(); + quad->SetNew(sharedQuadState, contentRect(), renderPassId, forReplica, maskResourceId, contentsChangedSinceLastFrame, + maskTexCoordScaleX, maskTexCoordScaleY, maskTexCoordOffsetX, maskTexCoordOffsetY); + quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData); } } // namespace cc diff --git a/cc/scrollbar_layer_impl.cc b/cc/scrollbar_layer_impl.cc index 2b82529..5b6968dc 100644 --- a/cc/scrollbar_layer_impl.cc +++ b/cc/scrollbar_layer_impl.cc @@ -97,7 +97,8 @@ void ScrollbarLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& append if (m_thumbResourceId && !thumbRect.isEmpty()) { gfx::Rect quadRect(scrollbarLayerRectToContentRect(thumbRect)); gfx::Rect opaqueRect; - scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::create(sharedQuadState, quadRect, opaqueRect, m_thumbResourceId, premultipledAlpha, uvRect, flipped); + scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create(); + quad->SetNew(sharedQuadState, quadRect, opaqueRect, m_thumbResourceId, premultipledAlpha, uvRect, flipped); quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData); } @@ -108,7 +109,9 @@ void ScrollbarLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& append if (m_foreTrackResourceId && !foreTrackRect.isEmpty()) { gfx::Rect quadRect(scrollbarLayerRectToContentRect(foreTrackRect)); gfx::Rect opaqueRect(contentsOpaque() ? quadRect : gfx::Rect()); - quadSink.append(TextureDrawQuad::create(sharedQuadState, quadRect, opaqueRect, m_foreTrackResourceId, premultipledAlpha, toUVRect(foreTrackRect, boundsRect), flipped).PassAs<DrawQuad>(), appendQuadsData); + scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create(); + quad->SetNew(sharedQuadState, quadRect, opaqueRect, m_foreTrackResourceId, premultipledAlpha, toUVRect(foreTrackRect, boundsRect), flipped); + quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData); } // Order matters here: since the back track texture is being drawn to the entire contents rect, we must append it after the thumb and @@ -116,7 +119,9 @@ void ScrollbarLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& append if (!contentBoundsRect.IsEmpty()) { gfx::Rect quadRect(contentBoundsRect); gfx::Rect opaqueRect(contentsOpaque() ? quadRect : gfx::Rect()); - quadSink.append(TextureDrawQuad::create(sharedQuadState, quadRect, opaqueRect, m_backTrackResourceId, premultipledAlpha, uvRect, flipped).PassAs<DrawQuad>(), appendQuadsData); + scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create(); + quad->SetNew(sharedQuadState, quadRect, opaqueRect, m_backTrackResourceId, premultipledAlpha, uvRect, flipped); + quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData); } } diff --git a/cc/software_renderer.cc b/cc/software_renderer.cc index e22ecec..d6a3905 100644 --- a/cc/software_renderer.cc +++ b/cc/software_renderer.cc @@ -189,19 +189,19 @@ void SoftwareRenderer::drawQuad(DrawingFrame& frame, const DrawQuad* quad) switch (quad->material) { case DrawQuad::DEBUG_BORDER: - drawDebugBorderQuad(frame, DebugBorderDrawQuad::materialCast(quad)); + drawDebugBorderQuad(frame, DebugBorderDrawQuad::MaterialCast(quad)); break; case DrawQuad::SOLID_COLOR: - drawSolidColorQuad(frame, SolidColorDrawQuad::materialCast(quad)); + drawSolidColorQuad(frame, SolidColorDrawQuad::MaterialCast(quad)); break; case DrawQuad::TEXTURE_CONTENT: - drawTextureQuad(frame, TextureDrawQuad::materialCast(quad)); + drawTextureQuad(frame, TextureDrawQuad::MaterialCast(quad)); break; case DrawQuad::TILED_CONTENT: - drawTileQuad(frame, TileDrawQuad::materialCast(quad)); + drawTileQuad(frame, TileDrawQuad::MaterialCast(quad)); break; case DrawQuad::RENDER_PASS: - drawRenderPassQuad(frame, RenderPassDrawQuad::materialCast(quad)); + drawRenderPassQuad(frame, RenderPassDrawQuad::MaterialCast(quad)); break; default: drawUnsupportedQuad(frame, quad); @@ -220,33 +220,33 @@ void SoftwareRenderer::drawDebugBorderQuad(const DrawingFrame& frame, const Debu m_skCurrentCanvas->getTotalMatrix().mapPoints(transformedVertices, vertices, 4); m_skCurrentCanvas->resetMatrix(); - m_skCurrentPaint.setColor(quad->color()); - m_skCurrentPaint.setAlpha(quad->opacity() * SkColorGetA(quad->color())); + m_skCurrentPaint.setColor(quad->color); + m_skCurrentPaint.setAlpha(quad->opacity() * SkColorGetA(quad->color)); m_skCurrentPaint.setStyle(SkPaint::kStroke_Style); - m_skCurrentPaint.setStrokeWidth(quad->width()); + m_skCurrentPaint.setStrokeWidth(quad->width); m_skCurrentCanvas->drawPoints(SkCanvas::kPolygon_PointMode, 4, transformedVertices, m_skCurrentPaint); } void SoftwareRenderer::drawSolidColorQuad(const DrawingFrame& frame, const SolidColorDrawQuad* quad) { - m_skCurrentPaint.setColor(quad->color()); - m_skCurrentPaint.setAlpha(quad->opacity() * SkColorGetA(quad->color())); + m_skCurrentPaint.setColor(quad->color); + m_skCurrentPaint.setAlpha(quad->opacity() * SkColorGetA(quad->color)); m_skCurrentCanvas->drawRect(gfx::RectFToSkRect(quadVertexRect()), m_skCurrentPaint); } void SoftwareRenderer::drawTextureQuad(const DrawingFrame& frame, const TextureDrawQuad* quad) { - if (!isSoftwareResource(quad->resourceId())) { + if (!isSoftwareResource(quad->resource_id)) { drawUnsupportedQuad(frame, quad); return; } // FIXME: Add support for non-premultiplied alpha. - ResourceProvider::ScopedReadLockSoftware lock(m_resourceProvider, quad->resourceId()); + ResourceProvider::ScopedReadLockSoftware lock(m_resourceProvider, quad->resource_id); const SkBitmap* bitmap = lock.skBitmap(); - gfx::RectF uvRect = gfx::ScaleRect(quad->uvRect(), bitmap->width(), bitmap->height()); + gfx::RectF uvRect = gfx::ScaleRect(quad->uv_rect, bitmap->width(), bitmap->height()); SkRect skUvRect = gfx::RectFToSkRect(uvRect); - if (quad->flipped()) + if (quad->flipped) m_skCurrentCanvas->scale(1, -1); m_skCurrentCanvas->drawBitmapRectToRect(*bitmap, &skUvRect, gfx::RectFToSkRect(quadVertexRect()), @@ -255,10 +255,10 @@ void SoftwareRenderer::drawTextureQuad(const DrawingFrame& frame, const TextureD void SoftwareRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQuad* quad) { - DCHECK(isSoftwareResource(quad->resourceId())); - ResourceProvider::ScopedReadLockSoftware lock(m_resourceProvider, quad->resourceId()); + DCHECK(isSoftwareResource(quad->resource_id)); + ResourceProvider::ScopedReadLockSoftware lock(m_resourceProvider, quad->resource_id); - SkRect uvRect = gfx::RectFToSkRect(quad->texCoordRect()); + SkRect uvRect = gfx::RectFToSkRect(quad->tex_coord_rect); m_skCurrentPaint.setFilterBitmap(true); m_skCurrentCanvas->drawBitmapRectToRect(*lock.skBitmap(), &uvRect, gfx::RectFToSkRect(quadVertexRect()), @@ -267,11 +267,11 @@ void SoftwareRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQua void SoftwareRenderer::drawRenderPassQuad(const DrawingFrame& frame, const RenderPassDrawQuad* quad) { - CachedResource* contentTexture = m_renderPassTextures.get(quad->renderPassId()); + CachedResource* contentTexture = m_renderPassTextures.get(quad->render_pass_id); if (!contentTexture || !contentTexture->id()) return; - const RenderPass* renderPass = frame.renderPassesById->get(quad->renderPassId()); + const RenderPass* renderPass = frame.renderPassesById->get(quad->render_pass_id); DCHECK(renderPass); if (!renderPass) return; @@ -299,16 +299,16 @@ void SoftwareRenderer::drawRenderPassQuad(const DrawingFrame& frame, const Rende if (filter) m_skCurrentPaint.setImageFilter(filter); - if (quad->maskResourceId()) { - ResourceProvider::ScopedReadLockSoftware maskLock(m_resourceProvider, quad->maskResourceId()); + if (quad->mask_resource_id) { + ResourceProvider::ScopedReadLockSoftware maskLock(m_resourceProvider, quad->mask_resource_id); const SkBitmap* mask = maskLock.skBitmap(); SkRect maskRect = SkRect::MakeXYWH( - quad->maskTexCoordOffsetX() * mask->width(), - quad->maskTexCoordOffsetY() * mask->height(), - quad->maskTexCoordScaleX() * mask->width(), - quad->maskTexCoordScaleY() * mask->height()); + quad->mask_tex_coord_offset_x * mask->width(), + quad->mask_tex_coord_offset_y * mask->height(), + quad->mask_tex_coord_scale_x * mask->width(), + quad->mask_tex_coord_scale_y * mask->height()); SkMatrix maskMat; maskMat.setRectToRect(maskRect, destRect, SkMatrix::kFill_ScaleToFit); diff --git a/cc/software_renderer_unittest.cc b/cc/software_renderer_unittest.cc index 0051336..234a6f0 100644 --- a/cc/software_renderer_unittest.cc +++ b/cc/software_renderer_unittest.cc @@ -69,10 +69,12 @@ TEST_F(SoftwareRendererTest, solidColorQuad) scoped_ptr<SharedQuadState> sharedQuadState = SharedQuadState::create(WebTransformationMatrix(), outerRect, outerRect, 1.0); RenderPass::Id rootRenderPassId = RenderPass::Id(1, 1); scoped_ptr<TestRenderPass> rootRenderPass = TestRenderPass::create(rootRenderPassId, outerRect, WebTransformationMatrix()); - scoped_ptr<DrawQuad> outerQuad = SolidColorDrawQuad::create(sharedQuadState.get(), outerRect, SK_ColorYELLOW).PassAs<DrawQuad>(); - scoped_ptr<DrawQuad> innerQuad = SolidColorDrawQuad::create(sharedQuadState.get(), innerRect, SK_ColorCYAN).PassAs<DrawQuad>(); - rootRenderPass->appendQuad(innerQuad.Pass()); - rootRenderPass->appendQuad(outerQuad.Pass()); + scoped_ptr<SolidColorDrawQuad> outerQuad = SolidColorDrawQuad::Create(); + outerQuad->SetNew(sharedQuadState.get(), outerRect, SK_ColorYELLOW); + scoped_ptr<SolidColorDrawQuad> innerQuad = SolidColorDrawQuad::Create(); + innerQuad->SetNew(sharedQuadState.get(), innerRect, SK_ColorCYAN); + rootRenderPass->appendQuad(innerQuad.PassAs<DrawQuad>()); + rootRenderPass->appendQuad(outerQuad.PassAs<DrawQuad>()); RenderPassList list; RenderPassIdHashMap hashmap; @@ -126,10 +128,12 @@ TEST_F(SoftwareRendererTest, tileQuad) scoped_ptr<SharedQuadState> sharedQuadState = SharedQuadState::create(WebTransformationMatrix(), outerRect, outerRect, 1.0); RenderPass::Id rootRenderPassId = RenderPass::Id(1, 1); scoped_ptr<TestRenderPass> rootRenderPass = TestRenderPass::create(rootRenderPassId, gfx::Rect(gfx::Point(), deviceViewportSize()), WebTransformationMatrix()); - scoped_ptr<DrawQuad> outerQuad = TileDrawQuad::create(sharedQuadState.get(), outerRect, outerRect, resourceYellow, gfx::RectF(gfx::PointF(), outerSize), outerSize, false, false, false, false, false).PassAs<DrawQuad>(); - scoped_ptr<DrawQuad> innerQuad = TileDrawQuad::create(sharedQuadState.get(), innerRect, innerRect, resourceCyan, gfx::RectF(gfx::PointF(), innerSize), innerSize, false, false, false, false, false).PassAs<DrawQuad>(); - rootRenderPass->appendQuad(innerQuad.Pass()); - rootRenderPass->appendQuad(outerQuad.Pass()); + scoped_ptr<TileDrawQuad> outerQuad = TileDrawQuad::Create(); + outerQuad->SetNew(sharedQuadState.get(), outerRect, outerRect, resourceYellow, gfx::RectF(gfx::PointF(), outerSize), outerSize, false, false, false, false, false); + scoped_ptr<TileDrawQuad> innerQuad = TileDrawQuad::Create(); + innerQuad->SetNew(sharedQuadState.get(), innerRect, innerRect, resourceCyan, gfx::RectF(gfx::PointF(), innerSize), innerSize, false, false, false, false, false); + rootRenderPass->appendQuad(innerQuad.PassAs<DrawQuad>()); + rootRenderPass->appendQuad(outerQuad.PassAs<DrawQuad>()); RenderPassList list; RenderPassIdHashMap hashmap; diff --git a/cc/solid_color_draw_quad.cc b/cc/solid_color_draw_quad.cc index d6daad2..54a9b75 100644 --- a/cc/solid_color_draw_quad.cc +++ b/cc/solid_color_draw_quad.cc @@ -8,24 +8,38 @@ namespace cc { -scoped_ptr<SolidColorDrawQuad> SolidColorDrawQuad::create(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, SkColor color) -{ - return make_scoped_ptr(new SolidColorDrawQuad(sharedQuadState, quadRect, color)); +SolidColorDrawQuad::SolidColorDrawQuad() : color(0) {} + +scoped_ptr<SolidColorDrawQuad> SolidColorDrawQuad::Create() { + return make_scoped_ptr(new SolidColorDrawQuad); +} + +void SolidColorDrawQuad::SetNew(const SharedQuadState* shared_quad_state, + gfx::Rect rect, + SkColor color) { + gfx::Rect opaque_rect = SkColorGetA(color) == 255 ? rect : gfx::Rect(); + gfx::Rect visible_rect = rect; + bool needs_blending = false; + DrawQuad::SetAll(shared_quad_state, DrawQuad::SOLID_COLOR, rect, opaque_rect, + visible_rect, needs_blending); + this->color = color; } -SolidColorDrawQuad::SolidColorDrawQuad(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, SkColor color) - : m_color(color) -{ - gfx::Rect opaqueRect = SkColorGetA(m_color) == 255 ? quadRect : gfx::Rect(); - gfx::Rect visibleRect = quadRect; - bool needsBlending = false; - DrawQuad::SetAll(sharedQuadState, DrawQuad::SOLID_COLOR, quadRect, opaqueRect, visibleRect, needsBlending); +void SolidColorDrawQuad::SetAll(const SharedQuadState* shared_quad_state, + gfx::Rect rect, + gfx::Rect opaque_rect, + gfx::Rect visible_rect, + bool needs_blending, + SkColor color) { + DrawQuad::SetAll(shared_quad_state, DrawQuad::SOLID_COLOR, rect, opaque_rect, + visible_rect, needs_blending); + this->color = color; } -const SolidColorDrawQuad* SolidColorDrawQuad::materialCast(const DrawQuad* quad) -{ - DCHECK(quad->material == DrawQuad::SOLID_COLOR); - return static_cast<const SolidColorDrawQuad*>(quad); +const SolidColorDrawQuad* SolidColorDrawQuad::MaterialCast( + const DrawQuad* quad) { + DCHECK(quad->material == DrawQuad::SOLID_COLOR); + return static_cast<const SolidColorDrawQuad*>(quad); } } // namespacec cc diff --git a/cc/solid_color_draw_quad.h b/cc/solid_color_draw_quad.h index e816936..c8dd0c0 100644 --- a/cc/solid_color_draw_quad.h +++ b/cc/solid_color_draw_quad.h @@ -13,16 +13,25 @@ namespace cc { class CC_EXPORT SolidColorDrawQuad : public DrawQuad { -public: - static scoped_ptr<SolidColorDrawQuad> create(const SharedQuadState*, const gfx::Rect&, SkColor); + public: + static scoped_ptr<SolidColorDrawQuad> Create(); - SkColor color() const { return m_color; }; + void SetNew(const SharedQuadState* shared_quad_state, + gfx::Rect rect, + SkColor color); - static const SolidColorDrawQuad* materialCast(const DrawQuad*); -private: - SolidColorDrawQuad(const SharedQuadState*, const gfx::Rect&, SkColor); + void SetAll(const SharedQuadState* shared_quad_state, + gfx::Rect rect, + gfx::Rect opaque_rect, + gfx::Rect visible_rect, + bool needs_blending, + SkColor color); - SkColor m_color; + SkColor color; + + static const SolidColorDrawQuad* MaterialCast(const DrawQuad*); + private: + SolidColorDrawQuad(); }; } diff --git a/cc/solid_color_layer_impl.cc b/cc/solid_color_layer_impl.cc index cf11f86..fb4429f 100644 --- a/cc/solid_color_layer_impl.cc +++ b/cc/solid_color_layer_impl.cc @@ -33,7 +33,9 @@ void SolidColorLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appen for (int x = 0; x < width; x += m_tileSize) { for (int y = 0; y < height; y += m_tileSize) { gfx::Rect solidTileRect(x, y, std::min(width - x, m_tileSize), std::min(height - y, m_tileSize)); - quadSink.append(SolidColorDrawQuad::create(sharedQuadState, solidTileRect, backgroundColor()).PassAs<DrawQuad>(), appendQuadsData); + scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create(); + quad->SetNew(sharedQuadState, solidTileRect, backgroundColor()); + quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData); } } } diff --git a/cc/solid_color_layer_impl_unittest.cc b/cc/solid_color_layer_impl_unittest.cc index bf289e5..5cb4ebd 100644 --- a/cc/solid_color_layer_impl_unittest.cc +++ b/cc/solid_color_layer_impl_unittest.cc @@ -57,7 +57,7 @@ TEST(SolidColorLayerImplTest, verifyCorrectBackgroundColorInQuad) layer->appendQuads(quadCuller, data); ASSERT_EQ(quadCuller.quadList().size(), 1U); - EXPECT_EQ(SolidColorDrawQuad::materialCast(quadCuller.quadList()[0])->color(), testColor); + EXPECT_EQ(SolidColorDrawQuad::MaterialCast(quadCuller.quadList()[0])->color, testColor); } TEST(SolidColorLayerImplTest, verifyCorrectOpacityInQuad) @@ -80,7 +80,7 @@ TEST(SolidColorLayerImplTest, verifyCorrectOpacityInQuad) layer->appendQuads(quadCuller, data); ASSERT_EQ(quadCuller.quadList().size(), 1U); - EXPECT_EQ(opacity, SolidColorDrawQuad::materialCast(quadCuller.quadList()[0])->opacity()); + EXPECT_EQ(opacity, SolidColorDrawQuad::MaterialCast(quadCuller.quadList()[0])->opacity()); } TEST(SolidColorLayerImplTest, verifyOpaqueRect) diff --git a/cc/stream_video_draw_quad.cc b/cc/stream_video_draw_quad.cc index 24ef430..0286a19 100644 --- a/cc/stream_video_draw_quad.cc +++ b/cc/stream_video_draw_quad.cc @@ -8,24 +8,42 @@ namespace cc { -scoped_ptr<StreamVideoDrawQuad> StreamVideoDrawQuad::create(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, const gfx::Rect& opaqueRect, unsigned textureId, const WebKit::WebTransformationMatrix& matrix) -{ - return make_scoped_ptr(new StreamVideoDrawQuad(sharedQuadState, quadRect, opaqueRect, textureId, matrix)); +StreamVideoDrawQuad::StreamVideoDrawQuad() : texture_id(0) {} + +scoped_ptr<StreamVideoDrawQuad> StreamVideoDrawQuad::Create() { + return make_scoped_ptr(new StreamVideoDrawQuad); +} + +void StreamVideoDrawQuad::SetNew(const SharedQuadState* shared_quad_state, + gfx::Rect rect, + gfx::Rect opaque_rect, + unsigned texture_id, + const WebKit::WebTransformationMatrix& matrix) { + gfx::Rect visible_rect = rect; + bool needs_blending = false; + DrawQuad::SetAll(shared_quad_state, DrawQuad::STREAM_VIDEO_CONTENT, rect, + opaque_rect, visible_rect, needs_blending); + this->texture_id = texture_id; + this->matrix = matrix; } -StreamVideoDrawQuad::StreamVideoDrawQuad(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, const gfx::Rect& opaqueRect, unsigned textureId, const WebKit::WebTransformationMatrix& matrix) - : m_textureId(textureId) - , m_matrix(matrix) -{ - gfx::Rect visibleRect = quadRect; - bool needsBlending = false; - DrawQuad::SetAll(sharedQuadState, DrawQuad::STREAM_VIDEO_CONTENT, quadRect, opaqueRect, visibleRect, needsBlending); +void StreamVideoDrawQuad::SetAll(const SharedQuadState* shared_quad_state, + gfx::Rect rect, + gfx::Rect opaque_rect, + gfx::Rect visible_rect, + bool needs_blending, + unsigned texture_id, + const WebKit::WebTransformationMatrix& matrix) { + DrawQuad::SetAll(shared_quad_state, DrawQuad::STREAM_VIDEO_CONTENT, rect, + opaque_rect, visible_rect, needs_blending); + this->texture_id = texture_id; + this->matrix = matrix; } -const StreamVideoDrawQuad* StreamVideoDrawQuad::materialCast(const DrawQuad* quad) -{ - DCHECK(quad->material == DrawQuad::STREAM_VIDEO_CONTENT); - return static_cast<const StreamVideoDrawQuad*>(quad); +const StreamVideoDrawQuad* StreamVideoDrawQuad::MaterialCast( + const DrawQuad* quad) { + DCHECK(quad->material == DrawQuad::STREAM_VIDEO_CONTENT); + return static_cast<const StreamVideoDrawQuad*>(quad); } } // namespace cc diff --git a/cc/stream_video_draw_quad.h b/cc/stream_video_draw_quad.h index 508a001..9e6154b 100644 --- a/cc/stream_video_draw_quad.h +++ b/cc/stream_video_draw_quad.h @@ -13,18 +13,29 @@ namespace cc { class CC_EXPORT StreamVideoDrawQuad : public DrawQuad { -public: - static scoped_ptr<StreamVideoDrawQuad> create(const SharedQuadState*, const gfx::Rect&, const gfx::Rect& opaqueRect, unsigned textureId, const WebKit::WebTransformationMatrix&); - - unsigned textureId() const { return m_textureId; } - const WebKit::WebTransformationMatrix& matrix() const { return m_matrix; } - - static const StreamVideoDrawQuad* materialCast(const DrawQuad*); -private: - StreamVideoDrawQuad(const SharedQuadState*, const gfx::Rect&, const gfx::Rect& opaqueRect, unsigned textureId, const WebKit::WebTransformationMatrix&); - - unsigned m_textureId; - WebKit::WebTransformationMatrix m_matrix; + public: + static scoped_ptr<StreamVideoDrawQuad> Create(); + + void SetNew(const SharedQuadState* shared_quad_state, + gfx::Rect rect, + gfx::Rect opaque_rect, + unsigned texture_id, + const WebKit::WebTransformationMatrix& matrix); + + void SetAll(const SharedQuadState* shared_quad_state, + gfx::Rect rect, + gfx::Rect opaque_rect, + gfx::Rect visible_rect, + bool needs_blending, + unsigned texture_id, + const WebKit::WebTransformationMatrix& matrix); + + unsigned texture_id; + WebKit::WebTransformationMatrix matrix; + + static const StreamVideoDrawQuad* MaterialCast(const DrawQuad*); + private: + StreamVideoDrawQuad(); }; } diff --git a/cc/test/render_pass_test_common.cc b/cc/test/render_pass_test_common.cc index f8f2e22..5c83150 100644 --- a/cc/test/render_pass_test_common.cc +++ b/cc/test/render_pass_test_common.cc @@ -29,18 +29,37 @@ void TestRenderPass::appendOneOfEveryQuadType(cc::ResourceProvider* resourceProv cc::ResourceProvider::ResourceId textureResource = resourceProvider->createResourceFromExternalTexture(1); scoped_ptr<cc::SharedQuadState> sharedState = cc::SharedQuadState::create(WebTransformationMatrix(), rect, rect, 1); - appendQuad(cc::CheckerboardDrawQuad::create(sharedState.get(), rect, SK_ColorRED).PassAs<DrawQuad>()); - appendQuad(cc::DebugBorderDrawQuad::create(sharedState.get(), rect, SK_ColorRED, 1).Pass().PassAs<DrawQuad>()); - appendQuad(cc::IOSurfaceDrawQuad::create(sharedState.get(), rect, opaqueRect, gfx::Size(50, 50), 1, cc::IOSurfaceDrawQuad::Flipped).PassAs<DrawQuad>()); + scoped_ptr<cc::CheckerboardDrawQuad> checkerboardQuad = cc::CheckerboardDrawQuad::Create(); + checkerboardQuad->SetNew(sharedState.get(), rect, SK_ColorRED); + appendQuad(checkerboardQuad.PassAs<DrawQuad>()); - cc::RenderPass::Id passId(1, 1); - appendQuad(cc::RenderPassDrawQuad::create(sharedState.get(), rect, passId, false, 0, rect, 0, 0, 0, 0).PassAs<DrawQuad>()); + scoped_ptr<cc::DebugBorderDrawQuad> debugBorderQuad = cc::DebugBorderDrawQuad::Create(); + debugBorderQuad->SetNew(sharedState.get(), rect, SK_ColorRED, 1); + appendQuad(debugBorderQuad.PassAs<DrawQuad>()); - appendQuad(cc::SolidColorDrawQuad::create(sharedState.get(), rect, SK_ColorRED).PassAs<DrawQuad>()); - appendQuad(cc::StreamVideoDrawQuad::create(sharedState.get(), rect, opaqueRect, 1, WebKit::WebTransformationMatrix()).PassAs<DrawQuad>()); - appendQuad(cc::TextureDrawQuad::create(sharedState.get(), rect, opaqueRect, textureResource, false, rect, false).PassAs<DrawQuad>()); + scoped_ptr<cc::IOSurfaceDrawQuad> ioSurfaceQuad = cc::IOSurfaceDrawQuad::Create(); + ioSurfaceQuad->SetNew(sharedState.get(), rect, opaqueRect, gfx::Size(50, 50), 1, cc::IOSurfaceDrawQuad::FLIPPED); + appendQuad(ioSurfaceQuad.PassAs<DrawQuad>()); - appendQuad(cc::TileDrawQuad::create(sharedState.get(), rect, opaqueRect, textureResource, gfx::RectF(0, 0, 100, 100), gfx::Size(100, 100), false, false, false, false, false).PassAs<DrawQuad>()); + scoped_ptr<cc::RenderPassDrawQuad> renderPassQuad = cc::RenderPassDrawQuad::Create(); + renderPassQuad->SetNew(sharedState.get(), rect, cc::RenderPass::Id(1, 1), false, 0, rect, 0, 0, 0, 0); + appendQuad(renderPassQuad.PassAs<DrawQuad>()); + + scoped_ptr<cc::SolidColorDrawQuad> solidColorQuad = cc::SolidColorDrawQuad::Create(); + solidColorQuad->SetNew(sharedState.get(), rect, SK_ColorRED); + appendQuad(solidColorQuad.PassAs<DrawQuad>()); + + scoped_ptr<cc::StreamVideoDrawQuad> streamVideoQuad = cc::StreamVideoDrawQuad::Create(); + streamVideoQuad->SetNew(sharedState.get(), rect, opaqueRect, 1, WebKit::WebTransformationMatrix()); + appendQuad(streamVideoQuad.PassAs<DrawQuad>()); + + scoped_ptr<cc::TextureDrawQuad> textureQuad = cc::TextureDrawQuad::Create(); + textureQuad->SetNew(sharedState.get(), rect, opaqueRect, textureResource, false, rect, false); + appendQuad(textureQuad.PassAs<DrawQuad>()); + + scoped_ptr<cc::TileDrawQuad> tileQuad = cc::TileDrawQuad::Create(); + tileQuad->SetNew(sharedState.get(), rect, opaqueRect, textureResource, gfx::RectF(0, 0, 100, 100), gfx::Size(100, 100), false, false, false, false, false); + appendQuad(tileQuad.PassAs<DrawQuad>()); cc::VideoLayerImpl::FramePlane planes[3]; for (int i = 0; i < 3; ++i) { @@ -48,7 +67,10 @@ void TestRenderPass::appendOneOfEveryQuadType(cc::ResourceProvider* resourceProv planes[i].size = gfx::Size(100, 100); planes[i].format = GL_LUMINANCE; } - appendQuad(cc::YUVVideoDrawQuad::create(sharedState.get(), rect, opaqueRect, gfx::Size(100, 100), planes[0], planes[1], planes[2]).PassAs<DrawQuad>()); + scoped_ptr<cc::YUVVideoDrawQuad> yuvQuad = cc::YUVVideoDrawQuad::Create(); + yuvQuad->SetNew(sharedState.get(), rect, opaqueRect, gfx::Size(100, 100), planes[0], planes[1], planes[2]); + appendQuad(yuvQuad.PassAs<DrawQuad>()); + appendSharedQuadState(sharedState.Pass()); } diff --git a/cc/texture_draw_quad.cc b/cc/texture_draw_quad.cc index 65ea410..d552c39 100644 --- a/cc/texture_draw_quad.cc +++ b/cc/texture_draw_quad.cc @@ -8,26 +8,54 @@ namespace cc { -scoped_ptr<TextureDrawQuad> TextureDrawQuad::create(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, const gfx::Rect& opaqueRect, unsigned resourceId, bool premultipliedAlpha, const gfx::RectF& uvRect, bool flipped) -{ - return make_scoped_ptr(new TextureDrawQuad(sharedQuadState, quadRect, opaqueRect, resourceId, premultipliedAlpha, uvRect, flipped)); +TextureDrawQuad::TextureDrawQuad() + : resource_id(0), + premultiplied_alpha(false), + flipped(false) { } -TextureDrawQuad::TextureDrawQuad(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, const gfx::Rect& opaqueRect, unsigned resourceId, bool premultipliedAlpha, const gfx::RectF& uvRect, bool flipped) - : m_resourceId(resourceId) - , m_premultipliedAlpha(premultipliedAlpha) - , m_uvRect(uvRect) - , m_flipped(flipped) -{ - gfx::Rect visibleRect = quadRect; - bool needsBlending = false; - DrawQuad::SetAll(sharedQuadState, DrawQuad::TEXTURE_CONTENT, quadRect, opaqueRect, visibleRect, needsBlending); +scoped_ptr<TextureDrawQuad> TextureDrawQuad::Create() { + return make_scoped_ptr(new TextureDrawQuad); } -const TextureDrawQuad* TextureDrawQuad::materialCast(const DrawQuad* quad) -{ - DCHECK(quad->material == DrawQuad::TEXTURE_CONTENT); - return static_cast<const TextureDrawQuad*>(quad); +void TextureDrawQuad::SetNew(const SharedQuadState* shared_quad_state, + gfx::Rect rect, + gfx::Rect opaque_rect, + unsigned resource_id, + bool premultiplied_alpha, + const gfx::RectF& uv_rect, + bool flipped) { + gfx::Rect visible_rect = rect; + bool needs_blending = false; + DrawQuad::SetAll(shared_quad_state, DrawQuad::TEXTURE_CONTENT, rect, + opaque_rect, visible_rect, needs_blending); + this->resource_id = resource_id; + this->premultiplied_alpha = premultiplied_alpha; + this->uv_rect = uv_rect; + this->flipped = flipped; +} + +void TextureDrawQuad::SetAll(const SharedQuadState* shared_quad_state, + gfx::Rect rect, + gfx::Rect opaque_rect, + gfx::Rect visible_rect, + bool needs_blending, + unsigned resource_id, + bool premultiplied_alpha, + const gfx::RectF& uv_rect, + bool flipped) { + DrawQuad::SetAll(shared_quad_state, DrawQuad::TEXTURE_CONTENT, rect, + opaque_rect, visible_rect, needs_blending); + this->resource_id = resource_id; + this->premultiplied_alpha = premultiplied_alpha; + this->uv_rect = uv_rect; + this->flipped = flipped; +} + +const TextureDrawQuad* TextureDrawQuad::MaterialCast( + const DrawQuad* quad) { + DCHECK(quad->material == DrawQuad::TEXTURE_CONTENT); + return static_cast<const TextureDrawQuad*>(quad); } } // namespace cc diff --git a/cc/texture_draw_quad.h b/cc/texture_draw_quad.h index 5a6d3f3..177febf 100644 --- a/cc/texture_draw_quad.h +++ b/cc/texture_draw_quad.h @@ -13,22 +13,35 @@ namespace cc { class CC_EXPORT TextureDrawQuad : public DrawQuad { -public: - static scoped_ptr<TextureDrawQuad> create(const SharedQuadState*, const gfx::Rect&, const gfx::Rect& opaqueRect, unsigned resourceId, bool premultipliedAlpha, const gfx::RectF& uvRect, bool flipped); - gfx::RectF uvRect() const { return m_uvRect; } - - unsigned resourceId() const { return m_resourceId; } - bool premultipliedAlpha() const { return m_premultipliedAlpha; } - bool flipped() const { return m_flipped; } - - static const TextureDrawQuad* materialCast(const DrawQuad*); -private: - TextureDrawQuad(const SharedQuadState*, const gfx::Rect&, const gfx::Rect& opaqueRect, unsigned resourceId, bool premultipliedAlpha, const gfx::RectF& uvRect, bool flipped); - - unsigned m_resourceId; - bool m_premultipliedAlpha; - gfx::RectF m_uvRect; - bool m_flipped; + public: + static scoped_ptr<TextureDrawQuad> Create(); + + void SetNew(const SharedQuadState* shared_quad_state, + gfx::Rect rect, + gfx::Rect opaque_rect, + unsigned resource_id, + bool premultiplied_alpha, + const gfx::RectF& uv_rect, + bool flipped); + + void SetAll(const SharedQuadState* shared_quad_state, + gfx::Rect rect, + gfx::Rect opaque_rect, + gfx::Rect visible_rect, + bool needs_blending, + unsigned resource_id, + bool premultiplied_alpha, + const gfx::RectF& uv_rect, + bool flipped); + + unsigned resource_id; + bool premultiplied_alpha; + gfx::RectF uv_rect; + bool flipped; + + static const TextureDrawQuad* MaterialCast(const DrawQuad*); + private: + TextureDrawQuad(); }; } diff --git a/cc/texture_layer_impl.cc b/cc/texture_layer_impl.cc index 81c58cc..e8a6874 100644 --- a/cc/texture_layer_impl.cc +++ b/cc/texture_layer_impl.cc @@ -43,7 +43,9 @@ void TextureLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQu gfx::Rect quadRect(gfx::Point(), contentBounds()); gfx::Rect opaqueRect(contentsOpaque() ? quadRect : gfx::Rect()); - quadSink.append(TextureDrawQuad::create(sharedQuadState, quadRect, opaqueRect, m_externalTextureResource, m_premultipliedAlpha, m_uvRect, m_flipped).PassAs<DrawQuad>(), appendQuadsData); + scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create(); + quad->SetNew(sharedQuadState, quadRect, opaqueRect, m_externalTextureResource, m_premultipliedAlpha, m_uvRect, m_flipped); + quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData); } void TextureLayerImpl::didDraw(ResourceProvider* resourceProvider) diff --git a/cc/tile_draw_quad.cc b/cc/tile_draw_quad.cc index 1f2e9f5..965bb03 100644 --- a/cc/tile_draw_quad.cc +++ b/cc/tile_draw_quad.cc @@ -9,30 +9,76 @@ namespace cc { -scoped_ptr<TileDrawQuad> TileDrawQuad::create(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, const gfx::Rect& opaqueRect, unsigned resourceId, const gfx::RectF& texCoordRect, const gfx::Size& textureSize, bool swizzleContents, bool leftEdgeAA, bool topEdgeAA, bool rightEdgeAA, bool bottomEdgeAA) -{ - return make_scoped_ptr(new TileDrawQuad(sharedQuadState, quadRect, opaqueRect, resourceId, texCoordRect, textureSize, swizzleContents, leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA)); +TileDrawQuad::TileDrawQuad() + : resource_id(0), + swizzle_contents(false), + left_edge_aa(false), + top_edge_aa(false), + right_edge_aa(false), + bottom_edge_aa(false) { } -TileDrawQuad::TileDrawQuad(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, const gfx::Rect& opaqueRect, unsigned resourceId, const gfx::RectF& texCoordRect, const gfx::Size& textureSize, bool swizzleContents, bool leftEdgeAA, bool topEdgeAA, bool rightEdgeAA, bool bottomEdgeAA) - : m_resourceId(resourceId) - , m_texCoordRect(texCoordRect) - , m_textureSize(textureSize) - , m_swizzleContents(swizzleContents) - , m_leftEdgeAA(leftEdgeAA) - , m_topEdgeAA(topEdgeAA) - , m_rightEdgeAA(rightEdgeAA) - , m_bottomEdgeAA(bottomEdgeAA) -{ - gfx::Rect visibleRect = quadRect; - bool needsBlending = isAntialiased(); - DrawQuad::SetAll(sharedQuadState, DrawQuad::TILED_CONTENT, quadRect, opaqueRect, visibleRect, needsBlending); +scoped_ptr<TileDrawQuad> TileDrawQuad::Create() { + return make_scoped_ptr(new TileDrawQuad); } -const TileDrawQuad* TileDrawQuad::materialCast(const DrawQuad* quad) -{ - DCHECK(quad->material == DrawQuad::TILED_CONTENT); - return static_cast<const TileDrawQuad*>(quad); +void TileDrawQuad::SetNew(const SharedQuadState* shared_quad_state, + gfx::Rect rect, + gfx::Rect opaque_rect, + unsigned resource_id, + const gfx::RectF& tex_coord_rect, + gfx::Size texture_size, + bool swizzle_contents, + bool left_edge_aa, + bool top_edge_aa, + bool right_edge_aa, + bool bottom_edge_aa) { + gfx::Rect visible_rect = rect; + bool needs_blending = false; + DrawQuad::SetAll(shared_quad_state, DrawQuad::TILED_CONTENT, rect, + opaque_rect, visible_rect, needs_blending); + this->resource_id = resource_id; + this->tex_coord_rect = tex_coord_rect; + this->texture_size = texture_size; + this->swizzle_contents = swizzle_contents; + this->left_edge_aa = left_edge_aa; + this->top_edge_aa = top_edge_aa; + this->right_edge_aa = right_edge_aa; + this->bottom_edge_aa = bottom_edge_aa; + + // Override needs_blending after initializing the quad. + this->needs_blending = IsAntialiased(); +} + +void TileDrawQuad::SetAll(const SharedQuadState* shared_quad_state, + gfx::Rect rect, + gfx::Rect opaque_rect, + gfx::Rect visible_rect, + bool needs_blending, + unsigned resource_id, + const gfx::RectF& tex_coord_rect, + gfx::Size texture_size, + bool swizzle_contents, + bool left_edge_aa, + bool top_edge_aa, + bool right_edge_aa, + bool bottom_edge_aa) { + DrawQuad::SetAll(shared_quad_state, DrawQuad::TILED_CONTENT, rect, + opaque_rect, visible_rect, needs_blending); + this->resource_id = resource_id; + this->tex_coord_rect = tex_coord_rect; + this->texture_size = texture_size; + this->swizzle_contents = swizzle_contents; + this->left_edge_aa = left_edge_aa; + this->top_edge_aa = top_edge_aa; + this->right_edge_aa = right_edge_aa; + this->bottom_edge_aa = bottom_edge_aa; +} + +const TileDrawQuad* TileDrawQuad::MaterialCast( + const DrawQuad* quad) { + DCHECK(quad->material == DrawQuad::TILED_CONTENT); + return static_cast<const TileDrawQuad*>(quad); } } // namespace cc diff --git a/cc/tile_draw_quad.h b/cc/tile_draw_quad.h index dccf8bc..ae41d4ab 100644 --- a/cc/tile_draw_quad.h +++ b/cc/tile_draw_quad.h @@ -15,35 +15,54 @@ namespace cc { class CC_EXPORT TileDrawQuad : public DrawQuad { -public: - static scoped_ptr<TileDrawQuad> create(const SharedQuadState*, const gfx::Rect& quadRect, const gfx::Rect& opaqueRect, unsigned resourceId, const gfx::RectF& texCoordRect, const gfx::Size& textureSize, bool swizzleContents, bool leftEdgeAA, bool topEdgeAA, bool rightEdgeAA, bool bottomEdgeAA); - - unsigned resourceId() const { return m_resourceId; } - gfx::RectF texCoordRect() const { return m_texCoordRect; } - gfx::Size textureSize() const { return m_textureSize; } - bool swizzleContents() const { return m_swizzleContents; } - - // TODO(danakj): Stick the data used to compute these things in the quad - // instead so the parent compositor can decide to use AA on its own. - bool leftEdgeAA() const { return m_leftEdgeAA; } - bool topEdgeAA() const { return m_topEdgeAA; } - bool rightEdgeAA() const { return m_rightEdgeAA; } - bool bottomEdgeAA() const { return m_bottomEdgeAA; } - - bool isAntialiased() const { return leftEdgeAA() || topEdgeAA() || rightEdgeAA() || bottomEdgeAA(); } - - static const TileDrawQuad* materialCast(const DrawQuad*); -private: - TileDrawQuad(const SharedQuadState*, const gfx::Rect& quadRect, const gfx::Rect& opaqueRect, unsigned resourceId, const gfx::RectF& texCoordRect, const gfx::Size& textureSize, bool swizzleContents, bool leftEdgeAA, bool topEdgeAA, bool rightEdgeAA, bool bottomEdgeAA); - - unsigned m_resourceId; - gfx::RectF m_texCoordRect; - gfx::Size m_textureSize; - bool m_swizzleContents; - bool m_leftEdgeAA; - bool m_topEdgeAA; - bool m_rightEdgeAA; - bool m_bottomEdgeAA; + public: + static scoped_ptr<TileDrawQuad> Create(); + + void SetNew(const SharedQuadState* shared_quad_state, + gfx::Rect rect, + gfx::Rect opaque_rect, + unsigned resource_id, + const gfx::RectF& tex_coord_rect, + gfx::Size texture_size, + bool swizzle_contents, + bool left_edge_aa, + bool top_edge_aa, + bool right_edge_aa, + bool bottom_edge_aa); + + void SetAll(const SharedQuadState* shared_quad_state, + gfx::Rect rect, + gfx::Rect opaque_rect, + gfx::Rect visible_rect, + bool needs_blending, + unsigned resource_id, + const gfx::RectF& tex_coord_rect, + gfx::Size texture_size, + bool swizzle_contents, + bool left_edge_aa, + bool top_edge_aa, + bool right_edge_aa, + bool bottom_edge_aa); + + unsigned resource_id; + gfx::RectF tex_coord_rect; + gfx::Size texture_size; + bool swizzle_contents; + + // TODO(danakj): Stick the data used to compute these things in the quad + // instead so the parent compositor can decide to use AA on its own. + bool left_edge_aa; + bool top_edge_aa; + bool right_edge_aa; + bool bottom_edge_aa; + + bool IsAntialiased() const { + return left_edge_aa || top_edge_aa || right_edge_aa || bottom_edge_aa; + } + + static const TileDrawQuad* MaterialCast(const DrawQuad*); + private: + TileDrawQuad(); }; } diff --git a/cc/tiled_layer_impl.cc b/cc/tiled_layer_impl.cc index 3773542..ff4eaa3 100644 --- a/cc/tiled_layer_impl.cc +++ b/cc/tiled_layer_impl.cc @@ -133,7 +133,9 @@ void TiledLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuad borderColor = DebugColors::TileBorderColor(); borderWidth = DebugColors::TileBorderWidth(layerTreeHostImpl()); } - quadSink.append(DebugBorderDrawQuad::create(sharedQuadState, tileRect, borderColor, borderWidth).PassAs<DrawQuad>(), appendQuadsData); + scoped_ptr<DebugBorderDrawQuad> debugBorderQuad = DebugBorderDrawQuad::Create(); + debugBorderQuad->SetNew(sharedQuadState, tileRect, borderColor, borderWidth); + quadSink.append(debugBorderQuad.PassAs<DrawQuad>(), appendQuadsData); } } } @@ -160,9 +162,14 @@ void TiledLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuad else checkerColor = kTileCheckerboardColor; - appendQuadsData.hadMissingTiles |= quadSink.append(CheckerboardDrawQuad::create(sharedQuadState, tileRect, checkerColor).PassAs<DrawQuad>(), appendQuadsData); - } else - appendQuadsData.hadMissingTiles |= quadSink.append(SolidColorDrawQuad::create(sharedQuadState, tileRect, backgroundColor()).PassAs<DrawQuad>(), appendQuadsData); + scoped_ptr<CheckerboardDrawQuad> checkerboardQuad = CheckerboardDrawQuad::Create(); + checkerboardQuad->SetNew(sharedQuadState, tileRect, checkerColor); + appendQuadsData.hadMissingTiles |= quadSink.append(checkerboardQuad.PassAs<DrawQuad>(), appendQuadsData); + } else { + scoped_ptr<SolidColorDrawQuad> solidColorQuad = SolidColorDrawQuad::Create(); + solidColorQuad->SetNew(sharedQuadState, tileRect, backgroundColor()); + appendQuadsData.hadMissingTiles |= quadSink.append(solidColorQuad.PassAs<DrawQuad>(), appendQuadsData); + } continue; } @@ -188,7 +195,9 @@ void TiledLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuad bool rightEdgeAA = i == m_tiler->numTilesX() - 1 && useAA; bool bottomEdgeAA = j == m_tiler->numTilesY() - 1 && useAA; - quadSink.append(TileDrawQuad::create(sharedQuadState, tileRect, tileOpaqueRect, tile->resourceId(), texCoordRect, textureSize, tile->contentsSwizzled(), leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA).PassAs<DrawQuad>(), appendQuadsData); + scoped_ptr<TileDrawQuad> quad = TileDrawQuad::Create(); + quad->SetNew(sharedQuadState, tileRect, tileOpaqueRect, tile->resourceId(), texCoordRect, textureSize, tile->contentsSwizzled(), leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA); + quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData); } } } diff --git a/cc/tiled_layer_impl_unittest.cc b/cc/tiled_layer_impl_unittest.cc index c501dff..2771a87 100644 --- a/cc/tiled_layer_impl_unittest.cc +++ b/cc/tiled_layer_impl_unittest.cc @@ -199,11 +199,11 @@ TEST(TiledLayerImplTest, textureInfoForLayerNoBorders) getQuads(quads, sharedStates, tileSize, layerSize, LayerTilingData::NoBorderTexels, gfx::Rect(gfx::Point(), layerSize)); for (size_t i = 0; i < quads.size(); ++i) { - const TileDrawQuad* quad = TileDrawQuad::materialCast(quads[i]); + const TileDrawQuad* quad = TileDrawQuad::MaterialCast(quads[i]); - EXPECT_NE(quad->resourceId(), 0u) << quadString << i; - EXPECT_EQ(quad->texCoordRect(), gfx::RectF(gfx::PointF(), tileSize)) << quadString << i; - EXPECT_EQ(quad->textureSize(), tileSize) << quadString << i; + EXPECT_NE(0u, quad->resource_id) << quadString << i; + EXPECT_EQ(gfx::RectF(gfx::PointF(), tileSize), quad->tex_coord_rect) << quadString << i; + EXPECT_EQ(tileSize, quad->texture_size) << quadString << i; EXPECT_EQ(gfx::Rect(0, 0, 1, 1), quad->opaque_rect) << quadString << i; } } diff --git a/cc/video_layer_impl.cc b/cc/video_layer_impl.cc index 68a424c..49c493c 100644 --- a/cc/video_layer_impl.cc +++ b/cc/video_layer_impl.cc @@ -217,8 +217,8 @@ void VideoLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuad const FramePlane& uPlane = m_framePlanes[media::VideoFrame::kUPlane]; const FramePlane& vPlane = m_framePlanes[media::VideoFrame::kVPlane]; gfx::SizeF texScale(texWidthScale, texHeightScale); - scoped_ptr<YUVVideoDrawQuad> yuvVideoQuad = YUVVideoDrawQuad::create( - sharedQuadState, quadRect, opaqueRect, texScale, yPlane, uPlane, vPlane); + scoped_ptr<YUVVideoDrawQuad> yuvVideoQuad = YUVVideoDrawQuad::Create(); + yuvVideoQuad->SetNew(sharedQuadState, quadRect, opaqueRect, texScale, yPlane, uPlane, vPlane); quadSink.append(yuvVideoQuad.PassAs<DrawQuad>(), appendQuadsData); break; } @@ -228,7 +228,8 @@ void VideoLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuad bool premultipliedAlpha = true; gfx::RectF uvRect(0, 0, texWidthScale, texHeightScale); bool flipped = false; - scoped_ptr<TextureDrawQuad> textureQuad = TextureDrawQuad::create(sharedQuadState, quadRect, opaqueRect, plane.resourceId, premultipliedAlpha, uvRect, flipped); + scoped_ptr<TextureDrawQuad> textureQuad = TextureDrawQuad::Create(); + textureQuad->SetNew(sharedQuadState, quadRect, opaqueRect, plane.resourceId, premultipliedAlpha, uvRect, flipped); quadSink.append(textureQuad.PassAs<DrawQuad>(), appendQuadsData); break; } @@ -237,13 +238,15 @@ void VideoLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuad bool premultipliedAlpha = true; gfx::RectF uvRect(0, 0, texWidthScale, texHeightScale); bool flipped = false; - scoped_ptr<TextureDrawQuad> textureQuad = TextureDrawQuad::create(sharedQuadState, quadRect, opaqueRect, m_externalTextureResource, premultipliedAlpha, uvRect, flipped); + scoped_ptr<TextureDrawQuad> textureQuad = TextureDrawQuad::Create(); + textureQuad->SetNew(sharedQuadState, quadRect, opaqueRect, m_externalTextureResource, premultipliedAlpha, uvRect, flipped); quadSink.append(textureQuad.PassAs<DrawQuad>(), appendQuadsData); break; } case GL_TEXTURE_RECTANGLE_ARB: { gfx::Size visibleSize(visibleRect.width(), visibleRect.height()); - scoped_ptr<IOSurfaceDrawQuad> ioSurfaceQuad = IOSurfaceDrawQuad::create(sharedQuadState, quadRect, opaqueRect, visibleSize, m_frame->texture_id(), IOSurfaceDrawQuad::Unflipped); + scoped_ptr<IOSurfaceDrawQuad> ioSurfaceQuad = IOSurfaceDrawQuad::Create(); + ioSurfaceQuad->SetNew(sharedQuadState, quadRect, opaqueRect, visibleSize, m_frame->texture_id(), IOSurfaceDrawQuad::UNFLIPPED); quadSink.append(ioSurfaceQuad.PassAs<DrawQuad>(), appendQuadsData); break; } @@ -251,10 +254,8 @@ void VideoLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuad // StreamTexture hardware decoder. WebKit::WebTransformationMatrix transform(m_streamTextureMatrix); transform.scaleNonUniform(texWidthScale, texHeightScale); - scoped_ptr<StreamVideoDrawQuad> streamVideoQuad = - StreamVideoDrawQuad::create(sharedQuadState, quadRect, opaqueRect, - m_frame->texture_id(), - transform); + scoped_ptr<StreamVideoDrawQuad> streamVideoQuad = StreamVideoDrawQuad::Create(); + streamVideoQuad->SetNew(sharedQuadState, quadRect, opaqueRect, m_frame->texture_id(), transform); quadSink.append(streamVideoQuad.PassAs<DrawQuad>(), appendQuadsData); break; } diff --git a/cc/yuv_video_draw_quad.cc b/cc/yuv_video_draw_quad.cc index 5e3bb6f..dcb4369 100644 --- a/cc/yuv_video_draw_quad.cc +++ b/cc/yuv_video_draw_quad.cc @@ -8,46 +8,51 @@ namespace cc { -scoped_ptr<YUVVideoDrawQuad> YUVVideoDrawQuad::create( - const SharedQuadState* sharedQuadState, - const gfx::Rect& quadRect, - const gfx::Rect& opaqueRect, - const gfx::SizeF& texScale, - const VideoLayerImpl::FramePlane& yPlane, - const VideoLayerImpl::FramePlane& uPlane, - const VideoLayerImpl::FramePlane& vPlane) -{ - return make_scoped_ptr(new YUVVideoDrawQuad(sharedQuadState, - quadRect, opaqueRect, texScale, - yPlane, uPlane, vPlane)); +YUVVideoDrawQuad::YUVVideoDrawQuad() {} +YUVVideoDrawQuad::~YUVVideoDrawQuad() {} + +scoped_ptr<YUVVideoDrawQuad> YUVVideoDrawQuad::Create() { + return make_scoped_ptr(new YUVVideoDrawQuad); } -YUVVideoDrawQuad::YUVVideoDrawQuad( - const SharedQuadState* sharedQuadState, - const gfx::Rect& quadRect, - const gfx::Rect& opaqueRect, - const gfx::SizeF& texScale, - const VideoLayerImpl::FramePlane& yPlane, - const VideoLayerImpl::FramePlane& uPlane, - const VideoLayerImpl::FramePlane& vPlane) - : m_texScale(texScale) - , m_yPlane(yPlane) - , m_uPlane(uPlane) - , m_vPlane(vPlane) -{ - gfx::Rect visibleRect = quadRect; - bool needsBlending = false; - DrawQuad::SetAll(sharedQuadState, DrawQuad::YUV_VIDEO_CONTENT, quadRect, opaqueRect, visibleRect, needsBlending); +void YUVVideoDrawQuad::SetNew(const SharedQuadState* shared_quad_state, + gfx::Rect rect, + gfx::Rect opaque_rect, + gfx::SizeF tex_scale, + const VideoLayerImpl::FramePlane& y_plane, + const VideoLayerImpl::FramePlane& u_plane, + const VideoLayerImpl::FramePlane& v_plane) { + gfx::Rect visible_rect = rect; + bool needs_blending = false; + DrawQuad::SetAll(shared_quad_state, DrawQuad::YUV_VIDEO_CONTENT, rect, + opaque_rect, visible_rect, needs_blending); + this->tex_scale = tex_scale; + this->y_plane = y_plane; + this->u_plane = u_plane; + this->v_plane = v_plane; } -YUVVideoDrawQuad::~YUVVideoDrawQuad() -{ +void YUVVideoDrawQuad::SetAll(const SharedQuadState* shared_quad_state, + gfx::Rect rect, + gfx::Rect opaque_rect, + gfx::Rect visible_rect, + bool needs_blending, + gfx::SizeF tex_scale, + const VideoLayerImpl::FramePlane& y_plane, + const VideoLayerImpl::FramePlane& u_plane, + const VideoLayerImpl::FramePlane& v_plane) { + DrawQuad::SetAll(shared_quad_state, DrawQuad::YUV_VIDEO_CONTENT, rect, + opaque_rect, visible_rect, needs_blending); + this->tex_scale = tex_scale; + this->y_plane = y_plane; + this->u_plane = u_plane; + this->v_plane = v_plane; } -const YUVVideoDrawQuad* YUVVideoDrawQuad::materialCast(const DrawQuad* quad) -{ - DCHECK(quad->material == DrawQuad::YUV_VIDEO_CONTENT); - return static_cast<const YUVVideoDrawQuad*>(quad); +const YUVVideoDrawQuad* YUVVideoDrawQuad::MaterialCast( + const DrawQuad* quad) { + DCHECK(quad->material == DrawQuad::YUV_VIDEO_CONTENT); + return static_cast<const YUVVideoDrawQuad*>(quad); } } // namespace cc diff --git a/cc/yuv_video_draw_quad.h b/cc/yuv_video_draw_quad.h index e923b68..9f03d99 100644 --- a/cc/yuv_video_draw_quad.h +++ b/cc/yuv_video_draw_quad.h @@ -14,39 +14,37 @@ namespace cc { class CC_EXPORT YUVVideoDrawQuad : public DrawQuad { -public: - static scoped_ptr<YUVVideoDrawQuad> create( - const SharedQuadState* sharedQuadState, - const gfx::Rect& quadRect, - const gfx::Rect& opaqueRect, - const gfx::SizeF& texScale, - const VideoLayerImpl::FramePlane& yPlane, - const VideoLayerImpl::FramePlane& uPlane, - const VideoLayerImpl::FramePlane& vPlane); - - virtual ~YUVVideoDrawQuad(); - - const gfx::SizeF& texScale() const { return m_texScale; } - - const VideoLayerImpl::FramePlane& yPlane() const { return m_yPlane; } - const VideoLayerImpl::FramePlane& uPlane() const { return m_uPlane; } - const VideoLayerImpl::FramePlane& vPlane() const { return m_vPlane; } - - static const YUVVideoDrawQuad* materialCast(const DrawQuad*); -private: - YUVVideoDrawQuad( - const SharedQuadState* sharedQuadState, - const gfx::Rect& quadRect, - const gfx::Rect& opaqueRect, - const gfx::SizeF& texScale, - const VideoLayerImpl::FramePlane& yPlane, - const VideoLayerImpl::FramePlane& uPlane, - const VideoLayerImpl::FramePlane& vPlane); - - gfx::SizeF m_texScale; - VideoLayerImpl::FramePlane m_yPlane; - VideoLayerImpl::FramePlane m_uPlane; - VideoLayerImpl::FramePlane m_vPlane; + public: + virtual ~YUVVideoDrawQuad(); + + static scoped_ptr<YUVVideoDrawQuad> Create(); + + void SetNew(const SharedQuadState* shared_quad_state, + gfx::Rect rect, + gfx::Rect opaque_rect, + gfx::SizeF tex_scale, + const VideoLayerImpl::FramePlane& y_plane, + const VideoLayerImpl::FramePlane& u_plane, + const VideoLayerImpl::FramePlane& v_plane); + + void SetAll(const SharedQuadState* shared_quad_state, + gfx::Rect rect, + gfx::Rect opaque_rect, + gfx::Rect visible_rect, + bool needs_blending, + gfx::SizeF tex_scale, + const VideoLayerImpl::FramePlane& y_plane, + const VideoLayerImpl::FramePlane& u_plane, + const VideoLayerImpl::FramePlane& v_plane); + + gfx::SizeF tex_scale; + VideoLayerImpl::FramePlane y_plane; + VideoLayerImpl::FramePlane u_plane; + VideoLayerImpl::FramePlane v_plane; + + static const YUVVideoDrawQuad* MaterialCast(const DrawQuad*); + private: + YUVVideoDrawQuad(); }; } |