cc/gl_renderer.cc - Issue 11189043: cc: Rename cc classes and members to match filenames

Unified Diff: cc/gl_renderer.cc

Issue 11189043: cc: Rename cc classes and members to match filenames (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src

Patch Set: Created 8 years, 2 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: cc/gl_renderer.cc

diff --git a/cc/gl_renderer.cc b/cc/gl_renderer.cc

index 18c9f4fa88f1bbd4b5276942cbab68813c922b10..e6e7d06c69ad5a243c7ee8b2c210af92aff192bb 100644

--- a/cc/gl_renderer.cc

+++ b/cc/gl_renderer.cc

@@ -59,18 +59,18 @@ bool needsIOSurfaceReadbackWorkaround()

} // anonymous namespace

-scoped_ptr<CCRendererGL> CCRendererGL::create(CCRendererClient* client, CCResourceProvider* resourceProvider)

+scoped_ptr<GLRenderer> GLRenderer::create(RendererClient* client, ResourceProvider* resourceProvider)

{

- scoped_ptr<CCRendererGL> renderer(make_scoped_ptr(new CCRendererGL(client, resourceProvider)));

+ scoped_ptr<GLRenderer> renderer(make_scoped_ptr(new GLRenderer(client, resourceProvider)));

if (!renderer->initialize())

- return scoped_ptr<CCRendererGL>();

+ return scoped_ptr<GLRenderer>();

return renderer.Pass();

}

-CCRendererGL::CCRendererGL(CCRendererClient* client,

- CCResourceProvider* resourceProvider)

- : CCDirectRenderer(client, resourceProvider)

+GLRenderer::GLRenderer(RendererClient* client,

+ ResourceProvider* resourceProvider)

+ : DirectRenderer(client, resourceProvider)

, m_offscreenFramebufferId(0)

, m_sharedGeometryQuad(FloatRect(-0.5f, -0.5f, 1.0f, 1.0f))

, m_context(resourceProvider->graphicsContext3D())

@@ -83,7 +83,7 @@ CCRendererGL::CCRendererGL(CCRendererClient* client,

ASSERT(m_context);

}

-bool CCRendererGL::initialize()

+bool GLRenderer::initialize()

{

if (!m_context->makeContextCurrent())

return false;

@@ -105,10 +105,10 @@ bool CCRendererGL::initialize()

m_capabilities.contextHasCachedFrontBuffer = extensions.count("GL_CHROMIUM_front_buffer_cached");

- m_capabilities.usingPartialSwap = CCSettings::partialSwapEnabled() && extensions.count("GL_CHROMIUM_post_sub_buffer");

+ m_capabilities.usingPartialSwap = Settings::partialSwapEnabled() && extensions.count("GL_CHROMIUM_post_sub_buffer");

// Use the swapBuffers callback only with the threaded proxy.

- if (CCProxy::hasImplThread())

+ if (Proxy::hasImplThread())

m_capabilities.usingSwapCompleteCallback = extensions.count("GL_CHROMIUM_swapbuffers_complete_callback");

if (m_capabilities.usingSwapCompleteCallback)

m_context->setSwapBuffersCompleteCallbackCHROMIUM(this);

@@ -139,33 +139,33 @@ bool CCRendererGL::initialize()

return true;

}

-CCRendererGL::~CCRendererGL()

+GLRenderer::~GLRenderer()

{

- ASSERT(CCProxy::isImplThread());

+ ASSERT(Proxy::isImplThread());

m_context->setSwapBuffersCompleteCallbackCHROMIUM(0);

m_context->setMemoryAllocationChangedCallbackCHROMIUM(0);

m_context->setContextLostCallback(0);

cleanupSharedObjects();

}

-const RendererCapabilities& CCRendererGL::capabilities() const

+const RendererCapabilities& GLRenderer::capabilities() const

{

return m_capabilities;

}

-WebGraphicsContext3D* CCRendererGL::context()

+WebGraphicsContext3D* GLRenderer::context()

{

return m_context;

}

-void CCRendererGL::debugGLCall(WebGraphicsContext3D* context, const char* command, const char* file, int line)

+void GLRenderer::debugGLCall(WebGraphicsContext3D* context, const char* command, const char* file, int line)

{

unsigned long error = context->getError();

if (error != GraphicsContext3D::NO_ERROR)

LOG_ERROR("GL command failed: File: %s\n\tLine %d\n\tcommand: %s, error %x\n", file, line, command, static_cast<int>(error));

}

-void CCRendererGL::setVisible(bool visible)

+void GLRenderer::setVisible(bool visible)

{

if (m_visible == visible)

return;

@@ -179,17 +179,17 @@ void CCRendererGL::setVisible(bool visible)

enforceMemoryPolicy();

}

-void CCRendererGL::releaseRenderPassTextures()

+void GLRenderer::releaseRenderPassTextures()

{

m_renderPassTextures.clear();

}

-void CCRendererGL::viewportChanged()

+void GLRenderer::viewportChanged()

{

m_isViewportChanged = true;

}

-void CCRendererGL::clearFramebuffer(DrawingFrame& frame)

+void GLRenderer::clearFramebuffer(DrawingFrame& frame)

{

// On DEBUG builds, opaque render passes are cleared to blue to easily see regions that were not drawn on the screen.

if (frame.currentRenderPass->hasTransparentBackground())

@@ -203,7 +203,7 @@ void CCRendererGL::clearFramebuffer(DrawingFrame& frame)

m_context->clear(GraphicsContext3D::COLOR_BUFFER_BIT);

}

-void CCRendererGL::beginDrawingFrame(DrawingFrame& frame)

+void GLRenderer::beginDrawingFrame(DrawingFrame& frame)

{

// FIXME: Remove this once framebuffer is automatically recreated on first use

ensureFramebuffer();

@@ -211,7 +211,7 @@ void CCRendererGL::beginDrawingFrame(DrawingFrame& frame)

if (viewportSize().isEmpty())

return;

- TRACE_EVENT0("cc", "CCRendererGL::drawLayers");

+ TRACE_EVENT0("cc", "GLRenderer::drawLayers");

if (m_isViewportChanged) {

// Only reshape when we know we are going to draw. Otherwise, the reshape

// can leave the window at the wrong size if we never draw and the proper

@@ -231,13 +231,13 @@ void CCRendererGL::beginDrawingFrame(DrawingFrame& frame)

GLC(m_context, m_context->blendFunc(GraphicsContext3D::ONE, GraphicsContext3D::ONE_MINUS_SRC_ALPHA));

}

-void CCRendererGL::doNoOp()

+void GLRenderer::doNoOp()

{

GLC(m_context, m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, 0));

GLC(m_context, m_context->flush());

}

-void CCRendererGL::drawQuad(DrawingFrame& frame, const CCDrawQuad* quad)

+void GLRenderer::drawQuad(DrawingFrame& frame, const DrawQuad* quad)

{

if (quad->needsBlending())

GLC(m_context, m_context->enable(GraphicsContext3D::BLEND));

@@ -245,40 +245,40 @@ void CCRendererGL::drawQuad(DrawingFrame& frame, const CCDrawQuad* quad)

GLC(m_context, m_context->disable(GraphicsContext3D::BLEND));

switch (quad->material()) {

- case CCDrawQuad::Invalid:

+ case DrawQuad::Invalid:

ASSERT_NOT_REACHED();

break;

- case CCDrawQuad::Checkerboard:

- drawCheckerboardQuad(frame, CCCheckerboardDrawQuad::materialCast(quad));

+ case DrawQuad::Checkerboard:

+ drawCheckerboardQuad(frame, CheckerboardDrawQuad::materialCast(quad));

break;

- case CCDrawQuad::DebugBorder:

- drawDebugBorderQuad(frame, CCDebugBorderDrawQuad::materialCast(quad));

+ case DrawQuad::DebugBorder:

+ drawDebugBorderQuad(frame, DebugBorderDrawQuad::materialCast(quad));

break;

- case CCDrawQuad::IOSurfaceContent:

- drawIOSurfaceQuad(frame, CCIOSurfaceDrawQuad::materialCast(quad));

+ case DrawQuad::IOSurfaceContent:

+ drawIOSurfaceQuad(frame, IOSurfaceDrawQuad::materialCast(quad));

break;

- case CCDrawQuad::RenderPass:

- drawRenderPassQuad(frame, CCRenderPassDrawQuad::materialCast(quad));

+ case DrawQuad::RenderPass:

+ drawRenderPassQuad(frame, RenderPassDrawQuad::materialCast(quad));

break;

- case CCDrawQuad::SolidColor:

- drawSolidColorQuad(frame, CCSolidColorDrawQuad::materialCast(quad));

+ case DrawQuad::SolidColor:

+ drawSolidColorQuad(frame, SolidColorDrawQuad::materialCast(quad));

break;

- case CCDrawQuad::StreamVideoContent:

- drawStreamVideoQuad(frame, CCStreamVideoDrawQuad::materialCast(quad));

+ case DrawQuad::StreamVideoContent:

+ drawStreamVideoQuad(frame, StreamVideoDrawQuad::materialCast(quad));

break;

- case CCDrawQuad::TextureContent:

- drawTextureQuad(frame, CCTextureDrawQuad::materialCast(quad));

+ case DrawQuad::TextureContent:

+ drawTextureQuad(frame, TextureDrawQuad::materialCast(quad));

break;

- case CCDrawQuad::TiledContent:

- drawTileQuad(frame, CCTileDrawQuad::materialCast(quad));

+ case DrawQuad::TiledContent:

+ drawTileQuad(frame, TileDrawQuad::materialCast(quad));

break;

- case CCDrawQuad::YUVVideoContent:

- drawYUVVideoQuad(frame, CCYUVVideoDrawQuad::materialCast(quad));

+ case DrawQuad::YUVVideoContent:

+ drawYUVVideoQuad(frame, YUVVideoDrawQuad::materialCast(quad));

break;

}

-void CCRendererGL::drawCheckerboardQuad(const DrawingFrame& frame, const CCCheckerboardDrawQuad* quad)

+void GLRenderer::drawCheckerboardQuad(const DrawingFrame& frame, const CheckerboardDrawQuad* quad)

{

const TileCheckerboardProgram* program = tileCheckerboardProgram();

ASSERT(program && program->initialized());

@@ -303,7 +303,7 @@ void CCRendererGL::drawCheckerboardQuad(const DrawingFrame& frame, const CCCheck

drawQuadGeometry(frame, quad->quadTransform(), quad->quadRect(), program->vertexShader().matrixLocation());

}

-void CCRendererGL::drawDebugBorderQuad(const DrawingFrame& frame, const CCDebugBorderDrawQuad* quad)

+void GLRenderer::drawDebugBorderQuad(const DrawingFrame& frame, const DebugBorderDrawQuad* quad)

{

static float glMatrix[16];

const SolidColorProgram* program = solidColorProgram();

@@ -315,7 +315,7 @@ void CCRendererGL::drawDebugBorderQuad(const DrawingFrame& frame, const CCDebugB

WebTransformationMatrix renderMatrix = quad->quadTransform();

renderMatrix.translate(0.5 * layerRect.width() + layerRect.x(), 0.5 * layerRect.height() + layerRect.y());

renderMatrix.scaleNonUniform(layerRect.width(), layerRect.height());

- CCRendererGL::toGLMatrix(&glMatrix[0], frame.projectionMatrix * renderMatrix);

+ GLRenderer::toGLMatrix(&glMatrix[0], frame.projectionMatrix * renderMatrix);

GLC(context(), context()->uniformMatrix4fv(program->vertexShader().matrixLocation(), 1, false, &glMatrix[0]));

SkColor color = quad->color();

@@ -329,25 +329,25 @@ void CCRendererGL::drawDebugBorderQuad(const DrawingFrame& frame, const CCDebugB

GLC(context(), context()->drawElements(GraphicsContext3D::LINE_LOOP, 4, GraphicsContext3D::UNSIGNED_SHORT, 6 * sizeof(unsigned short)));

}

-static inline SkBitmap applyFilters(CCRendererGL* renderer, const WebKit::WebFilterOperations& filters, CCScopedTexture* sourceTexture)

+static inline SkBitmap applyFilters(GLRenderer* renderer, const WebKit::WebFilterOperations& filters, ScopedTexture* sourceTexture)

{

if (filters.isEmpty())

return SkBitmap();

- WebGraphicsContext3D* filterContext = CCProxy::hasImplThread() ? WebSharedGraphicsContext3D::compositorThreadContext() : WebSharedGraphicsContext3D::mainThreadContext();

- GrContext* filterGrContext = CCProxy::hasImplThread() ? WebSharedGraphicsContext3D::compositorThreadGrContext() : WebSharedGraphicsContext3D::mainThreadGrContext();

+ WebGraphicsContext3D* filterContext = Proxy::hasImplThread() ? WebSharedGraphicsContext3D::compositorThreadContext() : WebSharedGraphicsContext3D::mainThreadContext();

+ GrContext* filterGrContext = Proxy::hasImplThread() ? WebSharedGraphicsContext3D::compositorThreadGrContext() : WebSharedGraphicsContext3D::mainThreadGrContext();

if (!filterContext || !filterGrContext)

return SkBitmap();

renderer->context()->flush();

- CCResourceProvider::ScopedWriteLockGL lock(renderer->resourceProvider(), sourceTexture->id());

- SkBitmap source = CCRenderSurfaceFilters::apply(filters, lock.textureId(), sourceTexture->size(), filterContext, filterGrContext);

+ ResourceProvider::ScopedWriteLockGL lock(renderer->resourceProvider(), sourceTexture->id());

+ SkBitmap source = RenderSurfaceFilters::apply(filters, lock.textureId(), sourceTexture->size(), filterContext, filterGrContext);

return source;

}

-scoped_ptr<CCScopedTexture> CCRendererGL::drawBackgroundFilters(DrawingFrame& frame, const CCRenderPassDrawQuad* quad, const WebKit::WebFilterOperations& filters, const WebTransformationMatrix& contentsDeviceTransform)

+scoped_ptr<ScopedTexture> GLRenderer::drawBackgroundFilters(DrawingFrame& frame, const RenderPassDrawQuad* quad, const WebKit::WebFilterOperations& filters, const WebTransformationMatrix& contentsDeviceTransform)

{

// This method draws a background filter, which applies a filter to any pixels behind the quad and seen through its background.

// The algorithm works as follows:

@@ -363,19 +363,19 @@ scoped_ptr<CCScopedTexture> CCRendererGL::drawBackgroundFilters(DrawingFrame& fr

// Pixel copies in this algorithm occur at steps 2, 3, 4, and 5.

- // FIXME: When this algorithm changes, update CCLayerTreeHost::prioritizeTextures() accordingly.

+ // FIXME: When this algorithm changes, update LayerTreeHost::prioritizeTextures() accordingly.

if (filters.isEmpty())

- return scoped_ptr<CCScopedTexture>();

+ return scoped_ptr<ScopedTexture>();

// FIXME: We only allow background filters on an opaque render surface because other surfaces may contain

// translucent pixels, and the contents behind those translucent pixels wouldn't have the filter applied.

if (frame.currentRenderPass->hasTransparentBackground())

- return scoped_ptr<CCScopedTexture>();

+ return scoped_ptr<ScopedTexture>();

ASSERT(!frame.currentTexture);

// FIXME: Do a single readback for both the surface and replica and cache the filtered results (once filter textures are not reused).

- IntRect deviceRect = enclosingIntRect(CCMathUtil::mapClippedRect(contentsDeviceTransform, sharedGeometryQuad().boundingBox()));

+ IntRect deviceRect = enclosingIntRect(MathUtil::mapClippedRect(contentsDeviceTransform, sharedGeometryQuad().boundingBox()));

int top, right, bottom, left;

filters.getOutsets(top, right, bottom, left);

@@ -384,22 +384,22 @@ scoped_ptr<CCScopedTexture> CCRendererGL::drawBackgroundFilters(DrawingFrame& fr

deviceRect.intersect(frame.currentRenderPass->outputRect());

- scoped_ptr<CCScopedTexture> deviceBackgroundTexture = CCScopedTexture::create(m_resourceProvider);

+ scoped_ptr<ScopedTexture> deviceBackgroundTexture = ScopedTexture::create(m_resourceProvider);

if (!getFramebufferTexture(deviceBackgroundTexture.get(), deviceRect))

- return scoped_ptr<CCScopedTexture>();

+ return scoped_ptr<ScopedTexture>();

SkBitmap filteredDeviceBackground = applyFilters(this, filters, deviceBackgroundTexture.get());

if (!filteredDeviceBackground.getTexture())

- return scoped_ptr<CCScopedTexture>();

+ return scoped_ptr<ScopedTexture>();

GrTexture* texture = reinterpret_cast<GrTexture*>(filteredDeviceBackground.getTexture());

int filteredDeviceBackgroundTextureId = texture->getTextureHandle();

- scoped_ptr<CCScopedTexture> backgroundTexture = CCScopedTexture::create(m_resourceProvider);

- if (!backgroundTexture->allocate(CCRenderer::ImplPool, quad->quadRect().size(), GraphicsContext3D::RGBA, CCResourceProvider::TextureUsageFramebuffer))

- return scoped_ptr<CCScopedTexture>();

+ scoped_ptr<ScopedTexture> backgroundTexture = ScopedTexture::create(m_resourceProvider);

+ if (!backgroundTexture->allocate(Renderer::ImplPool, quad->quadRect().size(), GraphicsContext3D::RGBA, ResourceProvider::TextureUsageFramebuffer))

+ return scoped_ptr<ScopedTexture>();

- const CCRenderPass* targetRenderPass = frame.currentRenderPass;

+ const RenderPass* targetRenderPass = frame.currentRenderPass;

bool usingBackgroundTexture = useScopedTexture(frame, backgroundTexture.get(), quad->quadRect());

if (usingBackgroundTexture) {

@@ -414,17 +414,17 @@ scoped_ptr<CCScopedTexture> CCRendererGL::drawBackgroundFilters(DrawingFrame& fr

useRenderPass(frame, targetRenderPass);

if (!usingBackgroundTexture)

- return scoped_ptr<CCScopedTexture>();

+ return scoped_ptr<ScopedTexture>();

return backgroundTexture.Pass();

}

-void CCRendererGL::drawRenderPassQuad(DrawingFrame& frame, const CCRenderPassDrawQuad* quad)

+void GLRenderer::drawRenderPassQuad(DrawingFrame& frame, const RenderPassDrawQuad* quad)

{

CachedTexture* contentsTexture = m_renderPassTextures.get(quad->renderPassId());

if (!contentsTexture || !contentsTexture->id())

return;

- const CCRenderPass* renderPass = frame.renderPassesById->get(quad->renderPassId());

+ const RenderPass* renderPass = frame.renderPassesById->get(quad->renderPassId());

ASSERT(renderPass);

if (!renderPass)

return;

@@ -437,33 +437,33 @@ void CCRendererGL::drawRenderPassQuad(DrawingFrame& frame, const CCRenderPassDra

if (!contentsDeviceTransform.isInvertible())

return;

- scoped_ptr<CCScopedTexture> backgroundTexture = drawBackgroundFilters(frame, quad, renderPass->backgroundFilters(), contentsDeviceTransform);

+ scoped_ptr<ScopedTexture> backgroundTexture = drawBackgroundFilters(frame, quad, renderPass->backgroundFilters(), contentsDeviceTransform);

// FIXME: Cache this value so that we don't have to do it for both the surface and its replica.

// Apply filters to the contents texture.

SkBitmap filterBitmap = applyFilters(this, renderPass->filters(), contentsTexture);

- scoped_ptr<CCResourceProvider::ScopedReadLockGL> contentsResourceLock;

+ scoped_ptr<ResourceProvider::ScopedReadLockGL> contentsResourceLock;

unsigned contentsTextureId = 0;

if (filterBitmap.getTexture()) {

GrTexture* texture = reinterpret_cast<GrTexture*>(filterBitmap.getTexture());

contentsTextureId = texture->getTextureHandle();

} else {

- contentsResourceLock = make_scoped_ptr(new CCResourceProvider::ScopedReadLockGL(m_resourceProvider, contentsTexture->id()));

+ contentsResourceLock = make_scoped_ptr(new ResourceProvider::ScopedReadLockGL(m_resourceProvider, contentsTexture->id()));

contentsTextureId = contentsResourceLock->textureId();

}

// Draw the background texture if there is one.

if (backgroundTexture) {

ASSERT(backgroundTexture->size() == quad->quadRect().size());

- CCResourceProvider::ScopedReadLockGL lock(m_resourceProvider, backgroundTexture->id());

+ ResourceProvider::ScopedReadLockGL lock(m_resourceProvider, backgroundTexture->id());

copyTextureToFramebuffer(frame, lock.textureId(), quad->quadRect(), quad->quadTransform());

}

bool clipped = false;

- FloatQuad deviceQuad = CCMathUtil::mapQuad(contentsDeviceTransform, sharedGeometryQuad(), clipped);

+ FloatQuad deviceQuad = MathUtil::mapQuad(contentsDeviceTransform, sharedGeometryQuad(), clipped);

ASSERT(!clipped);

- CCLayerQuad deviceLayerBounds = CCLayerQuad(FloatQuad(deviceQuad.boundingBox()));

- CCLayerQuad deviceLayerEdges = CCLayerQuad(deviceQuad);

+ LayerQuad deviceLayerBounds = LayerQuad(FloatQuad(deviceQuad.boundingBox()));

+ LayerQuad deviceLayerEdges = LayerQuad(deviceQuad);

// Use anti-aliasing programs only when necessary.

bool useAA = (!deviceQuad.isRectilinear() || !deviceQuad.boundingBox().isExpressibleAsIntRect());

@@ -472,10 +472,10 @@ void CCRendererGL::drawRenderPassQuad(DrawingFrame& frame, const CCRenderPassDra

deviceLayerEdges.inflateAntiAliasingDistance();

}

- scoped_ptr<CCResourceProvider::ScopedReadLockGL> maskResourceLock;

+ scoped_ptr<ResourceProvider::ScopedReadLockGL> maskResourceLock;

unsigned maskTextureId = 0;

if (quad->maskResourceId()) {

- maskResourceLock.reset(new CCResourceProvider::ScopedReadLockGL(m_resourceProvider, quad->maskResourceId()));

+ maskResourceLock.reset(new ResourceProvider::ScopedReadLockGL(m_resourceProvider, quad->maskResourceId()));

maskTextureId = maskResourceLock->textureId();

}

@@ -550,7 +550,7 @@ void CCRendererGL::drawRenderPassQuad(DrawingFrame& frame, const CCRenderPassDra

}

// Map device space quad to surface space. contentsDeviceTransform has no 3d component since it was generated with to2dTransform() so we don't need to project.

- FloatQuad surfaceQuad = CCMathUtil::mapQuad(contentsDeviceTransform.inverse(), deviceLayerEdges.floatQuad(), clipped);

+ FloatQuad surfaceQuad = MathUtil::mapQuad(contentsDeviceTransform.inverse(), deviceLayerEdges.floatQuad(), clipped);

ASSERT(!clipped);

setShaderOpacity(quad->opacity(), shaderAlphaLocation);

@@ -558,7 +558,7 @@ void CCRendererGL::drawRenderPassQuad(DrawingFrame& frame, const CCRenderPassDra

drawQuadGeometry(frame, quad->quadTransform(), quad->quadRect(), shaderMatrixLocation);

}

-void CCRendererGL::drawSolidColorQuad(const DrawingFrame& frame, const CCSolidColorDrawQuad* quad)

+void GLRenderer::drawSolidColorQuad(const DrawingFrame& frame, const SolidColorDrawQuad* quad)

{

const SolidColorProgram* program = solidColorProgram();

GLC(context(), context()->useProgram(program->program()));

@@ -597,7 +597,7 @@ static void tileUniformLocation(T program, TileProgramUniforms& uniforms)

uniforms.edgeLocation = program->fragmentShader().edgeLocation();

}

-void CCRendererGL::drawTileQuad(const DrawingFrame& frame, const CCTileDrawQuad* quad)

+void GLRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQuad* quad)

{

IntRect tileRect = quad->quadVisibleRect();

@@ -638,7 +638,7 @@ void CCRendererGL::drawTileQuad(const DrawingFrame& frame, const CCTileDrawQuad*

return;

bool clipped = false;

- FloatQuad deviceLayerQuad = CCMathUtil::mapQuad(deviceTransform, FloatQuad(quad->visibleContentRect()), clipped);

+ FloatQuad deviceLayerQuad = MathUtil::mapQuad(deviceTransform, FloatQuad(quad->visibleContentRect()), clipped);

ASSERT(!clipped);

TileProgramUniforms uniforms;

@@ -666,17 +666,17 @@ void CCRendererGL::drawTileQuad(const DrawingFrame& frame, const CCTileDrawQuad*

GLC(context(), context()->useProgram(uniforms.program));

GLC(context(), context()->uniform1i(uniforms.samplerLocation, 0));

GLC(context(), context()->activeTexture(GraphicsContext3D::TEXTURE0));

- CCResourceProvider::ScopedReadLockGL quadResourceLock(m_resourceProvider, quad->resourceId());

+ ResourceProvider::ScopedReadLockGL quadResourceLock(m_resourceProvider, quad->resourceId());

GLC(context(), context()->bindTexture(GraphicsContext3D::TEXTURE_2D, quadResourceLock.textureId()));

GLC(context(), context()->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MIN_FILTER, quad->textureFilter()));

GLC(context(), context()->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MAG_FILTER, quad->textureFilter()));

bool useAA = !clipped && quad->isAntialiased();

if (useAA) {

- CCLayerQuad deviceLayerBounds = CCLayerQuad(FloatQuad(deviceLayerQuad.boundingBox()));

+ LayerQuad deviceLayerBounds = LayerQuad(FloatQuad(deviceLayerQuad.boundingBox()));

deviceLayerBounds.inflateAntiAliasingDistance();

- CCLayerQuad deviceLayerEdges = CCLayerQuad(deviceLayerQuad);

+ LayerQuad deviceLayerEdges = LayerQuad(deviceLayerQuad);

deviceLayerEdges.inflateAntiAliasingDistance();

float edge[24];

@@ -693,19 +693,19 @@ void CCRendererGL::drawTileQuad(const DrawingFrame& frame, const CCTileDrawQuad*

FloatPoint topRight(tileRect.maxX(), tileRect.y());

// Map points to device space.

- bottomRight = CCMathUtil::mapPoint(deviceTransform, bottomRight, clipped);

+ bottomRight = MathUtil::mapPoint(deviceTransform, bottomRight, clipped);

ASSERT(!clipped);

- bottomLeft = CCMathUtil::mapPoint(deviceTransform, bottomLeft, clipped);

+ bottomLeft = MathUtil::mapPoint(deviceTransform, bottomLeft, clipped);

ASSERT(!clipped);

- topLeft = CCMathUtil::mapPoint(deviceTransform, topLeft, clipped);

+ topLeft = MathUtil::mapPoint(deviceTransform, topLeft, clipped);

ASSERT(!clipped);

- topRight = CCMathUtil::mapPoint(deviceTransform, topRight, clipped);

+ topRight = MathUtil::mapPoint(deviceTransform, topRight, clipped);

ASSERT(!clipped);

- CCLayerQuad::Edge bottomEdge(bottomRight, bottomLeft);

- CCLayerQuad::Edge leftEdge(bottomLeft, topLeft);

- CCLayerQuad::Edge topEdge(topLeft, topRight);

- CCLayerQuad::Edge rightEdge(topRight, bottomRight);

+ LayerQuad::Edge bottomEdge(bottomRight, bottomLeft);

+ LayerQuad::Edge leftEdge(bottomLeft, topLeft);

+ LayerQuad::Edge topEdge(topLeft, topRight);

+ LayerQuad::Edge rightEdge(topRight, bottomRight);

// Only apply anti-aliasing to edges not clipped by culling or scissoring.

if (quad->topEdgeAA() && tileRect.y() == quad->quadRect().y())

@@ -724,11 +724,11 @@ void CCRendererGL::drawTileQuad(const DrawingFrame& frame, const CCTileDrawQuad*

rightEdge.scale(sign);

// Create device space quad.

- CCLayerQuad deviceQuad(leftEdge, topEdge, rightEdge, bottomEdge);

+ LayerQuad deviceQuad(leftEdge, topEdge, rightEdge, bottomEdge);

// Map device space quad to local space. contentsDeviceTransform has no 3d component since it was generated with to2dTransform() so we don't need to project.

WebTransformationMatrix inverseDeviceTransform = deviceTransform.inverse();

- localQuad = CCMathUtil::mapQuad(inverseDeviceTransform, deviceQuad.floatQuad(), clipped);

+ localQuad = MathUtil::mapQuad(inverseDeviceTransform, deviceQuad.floatQuad(), clipped);

// We should not ASSERT(!clipped) here, because anti-aliasing inflation may cause deviceQuad to become

// clipped. To our knowledge this scenario does not need to be handled differently than the unclipped case.

@@ -764,18 +764,18 @@ void CCRendererGL::drawTileQuad(const DrawingFrame& frame, const CCTileDrawQuad*

drawQuadGeometry(frame, quad->quadTransform(), centeredRect, uniforms.matrixLocation);

}

-void CCRendererGL::drawYUVVideoQuad(const DrawingFrame& frame, const CCYUVVideoDrawQuad* quad)

+void GLRenderer::drawYUVVideoQuad(const DrawingFrame& frame, const YUVVideoDrawQuad* quad)

{

const VideoYUVProgram* program = videoYUVProgram();

ASSERT(program && program->initialized());

- const CCVideoLayerImpl::FramePlane& yPlane = quad->yPlane();

- const CCVideoLayerImpl::FramePlane& uPlane = quad->uPlane();

- const CCVideoLayerImpl::FramePlane& vPlane = quad->vPlane();

+ const VideoLayerImpl::FramePlane& yPlane = quad->yPlane();

+ const VideoLayerImpl::FramePlane& uPlane = quad->uPlane();

+ const VideoLayerImpl::FramePlane& vPlane = quad->vPlane();

- CCResourceProvider::ScopedReadLockGL yPlaneLock(m_resourceProvider, yPlane.resourceId);

- CCResourceProvider::ScopedReadLockGL uPlaneLock(m_resourceProvider, uPlane.resourceId);

- CCResourceProvider::ScopedReadLockGL vPlaneLock(m_resourceProvider, vPlane.resourceId);

+ ResourceProvider::ScopedReadLockGL yPlaneLock(m_resourceProvider, yPlane.resourceId);

+ ResourceProvider::ScopedReadLockGL uPlaneLock(m_resourceProvider, uPlane.resourceId);

+ ResourceProvider::ScopedReadLockGL vPlaneLock(m_resourceProvider, vPlane.resourceId);

GLC(context(), context()->activeTexture(GraphicsContext3D::TEXTURE1));

GLC(context(), context()->bindTexture(GraphicsContext3D::TEXTURE_2D, yPlaneLock.textureId()));

GLC(context(), context()->activeTexture(GraphicsContext3D::TEXTURE2));

@@ -802,7 +802,7 @@ void CCRendererGL::drawYUVVideoQuad(const DrawingFrame& frame, const CCYUVVideoD

0.f, -.391f, 2.018f,

1.596f, -.813f, 0.f,

};

- GLC(context(), context()->uniformMatrix3fv(program->fragmentShader().ccMatrixLocation(), 1, 0, yuv2RGB));

+ GLC(context(), context()->uniformMatrix3fv(program->fragmentShader().matrixLocation(), 1, 0, yuv2RGB));

// These values map to 16, 128, and 128 respectively, and are computed

// as a fraction over 256 (e.g. 16 / 256 = 0.0625).

@@ -824,7 +824,7 @@ void CCRendererGL::drawYUVVideoQuad(const DrawingFrame& frame, const CCYUVVideoD

GLC(context(), context()->activeTexture(GraphicsContext3D::TEXTURE0));

}

-void CCRendererGL::drawStreamVideoQuad(const DrawingFrame& frame, const CCStreamVideoDrawQuad* quad)

+void GLRenderer::drawStreamVideoQuad(const DrawingFrame& frame, const StreamVideoDrawQuad* quad)

{

static float glMatrix[16];

@@ -869,9 +869,9 @@ struct TexTransformTextureProgramBinding : TextureProgramBinding {

int texTransformLocation;

};

-void CCRendererGL::drawTextureQuad(const DrawingFrame& frame, const CCTextureDrawQuad* quad)

+void GLRenderer::drawTextureQuad(const DrawingFrame& frame, const TextureDrawQuad* quad)

{

- ASSERT(CCProxy::isImplThread());

+ ASSERT(Proxy::isImplThread());

TexTransformTextureProgramBinding binding;

if (quad->flipped())

@@ -884,7 +884,7 @@ void CCRendererGL::drawTextureQuad(const DrawingFrame& frame, const CCTextureDra

GLC(context(), context()->uniform4f(binding.texTransformLocation, uvRect.x(), uvRect.y(), uvRect.width(), uvRect.height()));

GLC(context(), context()->activeTexture(GraphicsContext3D::TEXTURE0));

- CCResourceProvider::ScopedReadLockGL quadResourceLock(m_resourceProvider, quad->resourceId());

+ ResourceProvider::ScopedReadLockGL quadResourceLock(m_resourceProvider, quad->resourceId());

GLC(context(), context()->bindTexture(GraphicsContext3D::TEXTURE_2D, quadResourceLock.textureId()));

// FIXME: setting the texture parameters every time is redundant. Move this code somewhere

@@ -913,15 +913,15 @@ void CCRendererGL::drawTextureQuad(const DrawingFrame& frame, const CCTextureDra

GLC(m_context, m_context->blendFunc(GraphicsContext3D::ONE, GraphicsContext3D::ONE_MINUS_SRC_ALPHA));

}

-void CCRendererGL::drawIOSurfaceQuad(const DrawingFrame& frame, const CCIOSurfaceDrawQuad* quad)

+void GLRenderer::drawIOSurfaceQuad(const DrawingFrame& frame, const IOSurfaceDrawQuad* quad)

{

- ASSERT(CCProxy::isImplThread());

+ ASSERT(Proxy::isImplThread());

TexTransformTextureProgramBinding binding;

binding.set(textureIOSurfaceProgram());

GLC(context(), context()->useProgram(binding.programId));

GLC(context(), context()->uniform1i(binding.samplerLocation, 0));

- if (quad->orientation() == CCIOSurfaceDrawQuad::Flipped)

+ if (quad->orientation() == IOSurfaceDrawQuad::Flipped)

GLC(context(), context()->uniform4f(binding.texTransformLocation, 0, quad->ioSurfaceSize().height(), quad->ioSurfaceSize().width(), quad->ioSurfaceSize().height() * -1.0));

else

GLC(context(), context()->uniform4f(binding.texTransformLocation, 0, 0, quad->ioSurfaceSize().width(), quad->ioSurfaceSize().height()));

@@ -935,7 +935,7 @@ void CCRendererGL::drawIOSurfaceQuad(const DrawingFrame& frame, const CCIOSurfac

GLC(context(), context()->bindTexture(Extensions3D::TEXTURE_RECTANGLE_ARB, 0));

}

-void CCRendererGL::finishDrawingFrame(DrawingFrame& frame)

+void GLRenderer::finishDrawingFrame(DrawingFrame& frame)

{

m_currentFramebufferLock.reset();

m_swapBufferRect.unite(enclosingIntRect(frame.rootDamageRect));

@@ -944,12 +944,12 @@ void CCRendererGL::finishDrawingFrame(DrawingFrame& frame)

GLC(m_context, m_context->disable(GraphicsContext3D::BLEND));

}

-bool CCRendererGL::flippedFramebuffer() const

+bool GLRenderer::flippedFramebuffer() const

{

return true;

}

-void CCRendererGL::toGLMatrix(float* flattened, const WebTransformationMatrix& m)

+void GLRenderer::toGLMatrix(float* flattened, const WebTransformationMatrix& m)

{

flattened[0] = m.m11();

flattened[1] = m.m12();

@@ -969,7 +969,7 @@ void CCRendererGL::toGLMatrix(float* flattened, const WebTransformationMatrix& m

flattened[15] = m.m44();

}

-void CCRendererGL::setShaderFloatQuad(const FloatQuad& quad, int quadLocation)

+void GLRenderer::setShaderFloatQuad(const FloatQuad& quad, int quadLocation)

{

if (quadLocation == -1)

return;

@@ -986,13 +986,13 @@ void CCRendererGL::setShaderFloatQuad(const FloatQuad& quad, int quadLocation)

GLC(m_context, m_context->uniform2fv(quadLocation, 4, point));

}

-void CCRendererGL::setShaderOpacity(float opacity, int alphaLocation)

+void GLRenderer::setShaderOpacity(float opacity, int alphaLocation)

{

if (alphaLocation != -1)

GLC(m_context, m_context->uniform1f(alphaLocation, opacity));

}

-void CCRendererGL::drawQuadGeometry(const DrawingFrame& frame, const WebKit::WebTransformationMatrix& drawTransform, const FloatRect& quadRect, int matrixLocation)

+void GLRenderer::drawQuadGeometry(const DrawingFrame& frame, const WebKit::WebTransformationMatrix& drawTransform, const FloatRect& quadRect, int matrixLocation)

{

WebTransformationMatrix quadRectMatrix;

quadRectTransform(&quadRectMatrix, drawTransform, quadRect);

@@ -1003,7 +1003,7 @@ void CCRendererGL::drawQuadGeometry(const DrawingFrame& frame, const WebKit::Web

GLC(m_context, m_context->drawElements(GraphicsContext3D::TRIANGLES, 6, GraphicsContext3D::UNSIGNED_SHORT, 0));

}

-void CCRendererGL::copyTextureToFramebuffer(const DrawingFrame& frame, int textureId, const IntRect& rect, const WebTransformationMatrix& drawMatrix)

+void GLRenderer::copyTextureToFramebuffer(const DrawingFrame& frame, int textureId, const IntRect& rect, const WebTransformationMatrix& drawMatrix)

{

const RenderPassProgram* program = renderPassProgram();

@@ -1020,18 +1020,18 @@ void CCRendererGL::copyTextureToFramebuffer(const DrawingFrame& frame, int textu

drawQuadGeometry(frame, drawMatrix, rect, program->vertexShader().matrixLocation());

}

-void CCRendererGL::finish()

+void GLRenderer::finish()

{

- TRACE_EVENT0("cc", "CCRendererGL::finish");

+ TRACE_EVENT0("cc", "GLRenderer::finish");

m_context->finish();

}

-bool CCRendererGL::swapBuffers()

+bool GLRenderer::swapBuffers()

{

ASSERT(m_visible);

ASSERT(!m_isFramebufferDiscarded);

- TRACE_EVENT0("cc", "CCRendererGL::swapBuffers");

+ TRACE_EVENT0("cc", "GLRenderer::swapBuffers");

// We're done! Time to swapbuffers!

if (m_capabilities.usingPartialSwap) {

@@ -1050,25 +1050,25 @@ bool CCRendererGL::swapBuffers()

return true;

}

-void CCRendererGL::onSwapBuffersComplete()

+void GLRenderer::onSwapBuffersComplete()

{

m_client->onSwapBuffersComplete();

}

-void CCRendererGL::onMemoryAllocationChanged(WebGraphicsMemoryAllocation allocation)

+void GLRenderer::onMemoryAllocationChanged(WebGraphicsMemoryAllocation allocation)

{

// FIXME: This is called on the main thread in single threaded mode, but we expect it on the impl thread.

- if (!CCProxy::hasImplThread()) {

- ASSERT(CCProxy::isMainThread());

+ if (!Proxy::hasImplThread()) {

+ ASSERT(Proxy::isMainThread());

DebugScopedSetImplThread impl;

onMemoryAllocationChangedOnImplThread(allocation);

} else {

- ASSERT(CCProxy::isImplThread());

+ ASSERT(Proxy::isImplThread());

onMemoryAllocationChangedOnImplThread(allocation);

}

-void CCRendererGL::onMemoryAllocationChangedOnImplThread(WebKit::WebGraphicsMemoryAllocation allocation)

+void GLRenderer::onMemoryAllocationChangedOnImplThread(WebKit::WebGraphicsMemoryAllocation allocation)

{

m_discardFramebufferWhenNotVisible = !allocation.suggestHaveBackbuffer;

// Just ignore the memory manager when it says to set the limit to zero

@@ -1079,10 +1079,10 @@ void CCRendererGL::onMemoryAllocationChangedOnImplThread(WebKit::WebGraphicsMemo

enforceMemoryPolicy();

}

-void CCRendererGL::enforceMemoryPolicy()

+void GLRenderer::enforceMemoryPolicy()

{

if (!m_visible) {

- TRACE_EVENT0("cc", "CCRendererGL::enforceMemoryPolicy dropping resources");

+ TRACE_EVENT0("cc", "GLRenderer::enforceMemoryPolicy dropping resources");

releaseRenderPassTextures();

if (m_discardFramebufferWhenNotVisible)

discardFramebuffer();

@@ -1090,7 +1090,7 @@ void CCRendererGL::enforceMemoryPolicy()

}

-void CCRendererGL::discardFramebuffer()

+void GLRenderer::discardFramebuffer()

{

if (m_isFramebufferDiscarded)

return;

@@ -1106,7 +1106,7 @@ void CCRendererGL::discardFramebuffer()

m_client->setFullRootLayerDamage();

}

-void CCRendererGL::ensureFramebuffer()

+void GLRenderer::ensureFramebuffer()

{

if (!m_isFramebufferDiscarded)

return;

@@ -1118,13 +1118,13 @@ void CCRendererGL::ensureFramebuffer()

m_isFramebufferDiscarded = false;

}

-void CCRendererGL::onContextLost()

+void GLRenderer::onContextLost()

{

m_client->didLoseContext();

}

-void CCRendererGL::getFramebufferPixels(void *pixels, const IntRect& rect)

+void GLRenderer::getFramebufferPixels(void *pixels, const IntRect& rect)

{

ASSERT(rect.maxX() <= viewportWidth() && rect.maxY() <= viewportHeight());

@@ -1191,21 +1191,21 @@ void CCRendererGL::getFramebufferPixels(void *pixels, const IntRect& rect)

enforceMemoryPolicy();

}

-bool CCRendererGL::getFramebufferTexture(CCScopedTexture* texture, const IntRect& deviceRect)

+bool GLRenderer::getFramebufferTexture(ScopedTexture* texture, const IntRect& deviceRect)

{

ASSERT(!texture->id() || (texture->size() == deviceRect.size() && texture->format() == GraphicsContext3D::RGB));

- if (!texture->id() && !texture->allocate(CCRenderer::ImplPool, deviceRect.size(), GraphicsContext3D::RGB, CCResourceProvider::TextureUsageAny))

+ if (!texture->id() && !texture->allocate(Renderer::ImplPool, deviceRect.size(), GraphicsContext3D::RGB, ResourceProvider::TextureUsageAny))

return false;

- CCResourceProvider::ScopedWriteLockGL lock(m_resourceProvider, texture->id());

+ ResourceProvider::ScopedWriteLockGL lock(m_resourceProvider, texture->id());

GLC(m_context, m_context->bindTexture(GraphicsContext3D::TEXTURE_2D, lock.textureId()));

GLC(m_context, m_context->copyTexImage2D(GraphicsContext3D::TEXTURE_2D, 0, texture->format(),

deviceRect.x(), deviceRect.y(), deviceRect.width(), deviceRect.height(), 0));

return true;

}

-bool CCRendererGL::useScopedTexture(DrawingFrame& frame, const CCScopedTexture* texture, const IntRect& viewportRect)

+bool GLRenderer::useScopedTexture(DrawingFrame& frame, const ScopedTexture* texture, const IntRect& viewportRect)

{

ASSERT(texture->id());

frame.currentRenderPass = 0;

@@ -1214,18 +1214,18 @@ bool CCRendererGL::useScopedTexture(DrawingFrame& frame, const CCScopedTexture*

return bindFramebufferToTexture(frame, texture, viewportRect);

}

-void CCRendererGL::bindFramebufferToOutputSurface(DrawingFrame& frame)

+void GLRenderer::bindFramebufferToOutputSurface(DrawingFrame& frame)

{

m_currentFramebufferLock.reset();

GLC(m_context, m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, 0));

}

-bool CCRendererGL::bindFramebufferToTexture(DrawingFrame& frame, const CCScopedTexture* texture, const IntRect& framebufferRect)

+bool GLRenderer::bindFramebufferToTexture(DrawingFrame& frame, const ScopedTexture* texture, const IntRect& framebufferRect)

{

ASSERT(texture->id());

GLC(m_context, m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_offscreenFramebufferId));

- m_currentFramebufferLock = make_scoped_ptr(new CCResourceProvider::ScopedWriteLockGL(m_resourceProvider, texture->id()));

+ m_currentFramebufferLock = make_scoped_ptr(new ResourceProvider::ScopedWriteLockGL(m_resourceProvider, texture->id()));

unsigned textureId = m_currentFramebufferLock->textureId();

GLC(m_context, m_context->framebufferTexture2D(GraphicsContext3D::FRAMEBUFFER, GraphicsContext3D::COLOR_ATTACHMENT0, GraphicsContext3D::TEXTURE_2D, textureId, 0));

@@ -1242,30 +1242,30 @@ bool CCRendererGL::bindFramebufferToTexture(DrawingFrame& frame, const CCScopedT

return true;

}

-void CCRendererGL::enableScissorTestRect(const IntRect& scissorRect)

+void GLRenderer::enableScissorTestRect(const IntRect& scissorRect)

{

GLC(m_context, m_context->enable(GraphicsContext3D::SCISSOR_TEST));

GLC(m_context, m_context->scissor(scissorRect.x(), scissorRect.y(), scissorRect.width(), scissorRect.height()));

}

-void CCRendererGL::disableScissorTest()

+void GLRenderer::disableScissorTest()

{

GLC(m_context, m_context->disable(GraphicsContext3D::SCISSOR_TEST));

}

-void CCRendererGL::setDrawViewportSize(const IntSize& viewportSize)

+void GLRenderer::setDrawViewportSize(const IntSize& viewportSize)

{

GLC(m_context, m_context->viewport(0, 0, viewportSize.width(), viewportSize.height()));

}

-bool CCRendererGL::makeContextCurrent()

+bool GLRenderer::makeContextCurrent()

{

return m_context->makeContextCurrent();

}

-bool CCRendererGL::initializeSharedObjects()

+bool GLRenderer::initializeSharedObjects()

{

- TRACE_EVENT0("cc", "CCRendererGL::initializeSharedObjects");

+ TRACE_EVENT0("cc", "GLRenderer::initializeSharedObjects");

makeContextCurrent();

// Create an FBO for doing offscreen rendering.

@@ -1283,191 +1283,191 @@ bool CCRendererGL::initializeSharedObjects()

return true;

}

-const CCRendererGL::TileCheckerboardProgram* CCRendererGL::tileCheckerboardProgram()

+const GLRenderer::TileCheckerboardProgram* GLRenderer::tileCheckerboardProgram()

{

if (!m_tileCheckerboardProgram)

m_tileCheckerboardProgram = make_scoped_ptr(new TileCheckerboardProgram(m_context));

if (!m_tileCheckerboardProgram->initialized()) {

- TRACE_EVENT0("cc", "CCRendererGL::checkerboardProgram::initalize");

+ TRACE_EVENT0("cc", "GLRenderer::checkerboardProgram::initalize");

m_tileCheckerboardProgram->initialize(m_context, m_isUsingBindUniform);

}

return m_tileCheckerboardProgram.get();

}

-const CCRendererGL::SolidColorProgram* CCRendererGL::solidColorProgram()

+const GLRenderer::SolidColorProgram* GLRenderer::solidColorProgram()

{

if (!m_solidColorProgram)

m_solidColorProgram = make_scoped_ptr(new SolidColorProgram(m_context));

if (!m_solidColorProgram->initialized()) {

- TRACE_EVENT0("cc", "CCRendererGL::solidColorProgram::initialize");

+ TRACE_EVENT0("cc", "GLRenderer::solidColorProgram::initialize");

m_solidColorProgram->initialize(m_context, m_isUsingBindUniform);

}

return m_solidColorProgram.get();

}

-const CCRendererGL::RenderPassProgram* CCRendererGL::renderPassProgram()

+const GLRenderer::RenderPassProgram* GLRenderer::renderPassProgram()

{

ASSERT(m_renderPassProgram);

if (!m_renderPassProgram->initialized()) {

- TRACE_EVENT0("cc", "CCRendererGL::renderPassProgram::initialize");

+ TRACE_EVENT0("cc", "GLRenderer::renderPassProgram::initialize");

m_renderPassProgram->initialize(m_context, m_isUsingBindUniform);

}

return m_renderPassProgram.get();

}

-const CCRendererGL::RenderPassProgramAA* CCRendererGL::renderPassProgramAA()

+const GLRenderer::RenderPassProgramAA* GLRenderer::renderPassProgramAA()

{

if (!m_renderPassProgramAA)

m_renderPassProgramAA = make_scoped_ptr(new RenderPassProgramAA(m_context));

if (!m_renderPassProgramAA->initialized()) {

- TRACE_EVENT0("cc", "CCRendererGL::renderPassProgramAA::initialize");

+ TRACE_EVENT0("cc", "GLRenderer::renderPassProgramAA::initialize");

m_renderPassProgramAA->initialize(m_context, m_isUsingBindUniform);

}

return m_renderPassProgramAA.get();

}

-const CCRendererGL::RenderPassMaskProgram* CCRendererGL::renderPassMaskProgram()

+const GLRenderer::RenderPassMaskProgram* GLRenderer::renderPassMaskProgram()

{

if (!m_renderPassMaskProgram)

m_renderPassMaskProgram = make_scoped_ptr(new RenderPassMaskProgram(m_context));

if (!m_renderPassMaskProgram->initialized()) {

- TRACE_EVENT0("cc", "CCRendererGL::renderPassMaskProgram::initialize");

+ TRACE_EVENT0("cc", "GLRenderer::renderPassMaskProgram::initialize");

m_renderPassMaskProgram->initialize(m_context, m_isUsingBindUniform);

}

return m_renderPassMaskProgram.get();

}

-const CCRendererGL::RenderPassMaskProgramAA* CCRendererGL::renderPassMaskProgramAA()

+const GLRenderer::RenderPassMaskProgramAA* GLRenderer::renderPassMaskProgramAA()

{

if (!m_renderPassMaskProgramAA)

m_renderPassMaskProgramAA = make_scoped_ptr(new RenderPassMaskProgramAA(m_context));

if (!m_renderPassMaskProgramAA->initialized()) {

- TRACE_EVENT0("cc", "CCRendererGL::renderPassMaskProgramAA::initialize");

+ TRACE_EVENT0("cc", "GLRenderer::renderPassMaskProgramAA::initialize");

m_renderPassMaskProgramAA->initialize(m_context, m_isUsingBindUniform);

}

return m_renderPassMaskProgramAA.get();

}

-const CCRendererGL::TileProgram* CCRendererGL::tileProgram()

+const GLRenderer::TileProgram* GLRenderer::tileProgram()

{

ASSERT(m_tileProgram);

if (!m_tileProgram->initialized()) {

- TRACE_EVENT0("cc", "CCRendererGL::tileProgram::initialize");

+ TRACE_EVENT0("cc", "GLRenderer::tileProgram::initialize");

m_tileProgram->initialize(m_context, m_isUsingBindUniform);

}

return m_tileProgram.get();

}

-const CCRendererGL::TileProgramOpaque* CCRendererGL::tileProgramOpaque()

+const GLRenderer::TileProgramOpaque* GLRenderer::tileProgramOpaque()

{

ASSERT(m_tileProgramOpaque);

if (!m_tileProgramOpaque->initialized()) {

- TRACE_EVENT0("cc", "CCRendererGL::tileProgramOpaque::initialize");

+ TRACE_EVENT0("cc", "GLRenderer::tileProgramOpaque::initialize");

m_tileProgramOpaque->initialize(m_context, m_isUsingBindUniform);

}

return m_tileProgramOpaque.get();

}

-const CCRendererGL::TileProgramAA* CCRendererGL::tileProgramAA()

+const GLRenderer::TileProgramAA* GLRenderer::tileProgramAA()

{

if (!m_tileProgramAA)

m_tileProgramAA = make_scoped_ptr(new TileProgramAA(m_context));

if (!m_tileProgramAA->initialized()) {

- TRACE_EVENT0("cc", "CCRendererGL::tileProgramAA::initialize");

+ TRACE_EVENT0("cc", "GLRenderer::tileProgramAA::initialize");

m_tileProgramAA->initialize(m_context, m_isUsingBindUniform);

}

return m_tileProgramAA.get();

}

-const CCRendererGL::TileProgramSwizzle* CCRendererGL::tileProgramSwizzle()

+const GLRenderer::TileProgramSwizzle* GLRenderer::tileProgramSwizzle()

{

if (!m_tileProgramSwizzle)

m_tileProgramSwizzle = make_scoped_ptr(new TileProgramSwizzle(m_context));

if (!m_tileProgramSwizzle->initialized()) {

- TRACE_EVENT0("cc", "CCRendererGL::tileProgramSwizzle::initialize");

+ TRACE_EVENT0("cc", "GLRenderer::tileProgramSwizzle::initialize");

m_tileProgramSwizzle->initialize(m_context, m_isUsingBindUniform);

}

return m_tileProgramSwizzle.get();

}

-const CCRendererGL::TileProgramSwizzleOpaque* CCRendererGL::tileProgramSwizzleOpaque()

+const GLRenderer::TileProgramSwizzleOpaque* GLRenderer::tileProgramSwizzleOpaque()

{

if (!m_tileProgramSwizzleOpaque)

m_tileProgramSwizzleOpaque = make_scoped_ptr(new TileProgramSwizzleOpaque(m_context));

if (!m_tileProgramSwizzleOpaque->initialized()) {

- TRACE_EVENT0("cc", "CCRendererGL::tileProgramSwizzleOpaque::initialize");

+ TRACE_EVENT0("cc", "GLRenderer::tileProgramSwizzleOpaque::initialize");

m_tileProgramSwizzleOpaque->initialize(m_context, m_isUsingBindUniform);

}

return m_tileProgramSwizzleOpaque.get();

}

-const CCRendererGL::TileProgramSwizzleAA* CCRendererGL::tileProgramSwizzleAA()

+const GLRenderer::TileProgramSwizzleAA* GLRenderer::tileProgramSwizzleAA()

{

if (!m_tileProgramSwizzleAA)

m_tileProgramSwizzleAA = make_scoped_ptr(new TileProgramSwizzleAA(m_context));

if (!m_tileProgramSwizzleAA->initialized()) {

- TRACE_EVENT0("cc", "CCRendererGL::tileProgramSwizzleAA::initialize");

+ TRACE_EVENT0("cc", "GLRenderer::tileProgramSwizzleAA::initialize");

m_tileProgramSwizzleAA->initialize(m_context, m_isUsingBindUniform);

}

return m_tileProgramSwizzleAA.get();

}

-const CCRendererGL::TextureProgram* CCRendererGL::textureProgram()

+const GLRenderer::TextureProgram* GLRenderer::textureProgram()

{

if (!m_textureProgram)

m_textureProgram = make_scoped_ptr(new TextureProgram(m_context));

if (!m_textureProgram->initialized()) {

- TRACE_EVENT0("cc", "CCRendererGL::textureProgram::initialize");

+ TRACE_EVENT0("cc", "GLRenderer::textureProgram::initialize");

m_textureProgram->initialize(m_context, m_isUsingBindUniform);

}

return m_textureProgram.get();

}

-const CCRendererGL::TextureProgramFlip* CCRendererGL::textureProgramFlip()

+const GLRenderer::TextureProgramFlip* GLRenderer::textureProgramFlip()

{

if (!m_textureProgramFlip)

m_textureProgramFlip = make_scoped_ptr(new TextureProgramFlip(m_context));

if (!m_textureProgramFlip->initialized()) {

- TRACE_EVENT0("cc", "CCRendererGL::textureProgramFlip::initialize");

+ TRACE_EVENT0("cc", "GLRenderer::textureProgramFlip::initialize");

m_textureProgramFlip->initialize(m_context, m_isUsingBindUniform);

}

return m_textureProgramFlip.get();

}

-const CCRendererGL::TextureIOSurfaceProgram* CCRendererGL::textureIOSurfaceProgram()

+const GLRenderer::TextureIOSurfaceProgram* GLRenderer::textureIOSurfaceProgram()

{

if (!m_textureIOSurfaceProgram)

m_textureIOSurfaceProgram = make_scoped_ptr(new TextureIOSurfaceProgram(m_context));

if (!m_textureIOSurfaceProgram->initialized()) {

- TRACE_EVENT0("cc", "CCRendererGL::textureIOSurfaceProgram::initialize");

+ TRACE_EVENT0("cc", "GLRenderer::textureIOSurfaceProgram::initialize");

m_textureIOSurfaceProgram->initialize(m_context, m_isUsingBindUniform);

}

return m_textureIOSurfaceProgram.get();

}

-const CCRendererGL::VideoYUVProgram* CCRendererGL::videoYUVProgram()

+const GLRenderer::VideoYUVProgram* GLRenderer::videoYUVProgram()

{

if (!m_videoYUVProgram)

m_videoYUVProgram = make_scoped_ptr(new VideoYUVProgram(m_context));

if (!m_videoYUVProgram->initialized()) {

- TRACE_EVENT0("cc", "CCRendererGL::videoYUVProgram::initialize");

+ TRACE_EVENT0("cc", "GLRenderer::videoYUVProgram::initialize");

m_videoYUVProgram->initialize(m_context, m_isUsingBindUniform);

}

return m_videoYUVProgram.get();

}

-const CCRendererGL::VideoStreamTextureProgram* CCRendererGL::videoStreamTextureProgram()

+const GLRenderer::VideoStreamTextureProgram* GLRenderer::videoStreamTextureProgram()

{

if (!m_videoStreamTextureProgram)

m_videoStreamTextureProgram = make_scoped_ptr(new VideoStreamTextureProgram(m_context));

if (!m_videoStreamTextureProgram->initialized()) {

- TRACE_EVENT0("cc", "CCRendererGL::streamTextureProgram::initialize");

+ TRACE_EVENT0("cc", "GLRenderer::streamTextureProgram::initialize");

m_videoStreamTextureProgram->initialize(m_context, m_isUsingBindUniform);

}

return m_videoStreamTextureProgram.get();

}

-void CCRendererGL::cleanupSharedObjects()

+void GLRenderer::cleanupSharedObjects()

{

makeContextCurrent();

@@ -1518,7 +1518,7 @@ void CCRendererGL::cleanupSharedObjects()

releaseRenderPassTextures();

}

-bool CCRendererGL::isContextLost()

+bool GLRenderer::isContextLost()

{

return (m_context->getGraphicsResetStatusARB() != GraphicsContext3D::NO_ERROR);

}

« cc/active_animation.h ('K') | « cc/gl_renderer.h ('k') | cc/gl_renderer_unittest.cc » ('j') | no next file with comments »