Rename GrGpuGL to GrGLGpu for consistency
Review URL: https://codereview.chromium.org/808593003
diff --git a/src/gpu/gl/GrGLBufferImpl.cpp b/src/gpu/gl/GrGLBufferImpl.cpp
index 8b5eda5..3aa81e5 100644
--- a/src/gpu/gl/GrGLBufferImpl.cpp
+++ b/src/gpu/gl/GrGLBufferImpl.cpp
@@ -20,7 +20,7 @@
// objects are implemented as client-side-arrays on tile-deferred architectures.
#define DYNAMIC_USAGE_PARAM GR_GL_STREAM_DRAW
-GrGLBufferImpl::GrGLBufferImpl(GrGpuGL* gpu, const Desc& desc, GrGLenum bufferType)
+GrGLBufferImpl::GrGLBufferImpl(GrGLGpu* gpu, const Desc& desc, GrGLenum bufferType)
: fDesc(desc)
, fBufferType(bufferType)
, fMapPtr(NULL) {
@@ -35,7 +35,7 @@
VALIDATE();
}
-void GrGLBufferImpl::release(GrGpuGL* gpu) {
+void GrGLBufferImpl::release(GrGLGpu* gpu) {
VALIDATE();
// make sure we've not been abandoned or already released
if (fCPUData) {
@@ -65,7 +65,7 @@
VALIDATE();
}
-void GrGLBufferImpl::bind(GrGpuGL* gpu) const {
+void GrGLBufferImpl::bind(GrGLGpu* gpu) const {
VALIDATE();
if (GR_GL_ARRAY_BUFFER == fBufferType) {
gpu->bindVertexBuffer(fDesc.fID);
@@ -76,7 +76,7 @@
VALIDATE();
}
-void* GrGLBufferImpl::map(GrGpuGL* gpu) {
+void* GrGLBufferImpl::map(GrGLGpu* gpu) {
VALIDATE();
SkASSERT(!this->isMapped());
if (0 == fDesc.fID) {
@@ -133,7 +133,7 @@
return fMapPtr;
}
-void GrGLBufferImpl::unmap(GrGpuGL* gpu) {
+void GrGLBufferImpl::unmap(GrGLGpu* gpu) {
VALIDATE();
SkASSERT(this->isMapped());
if (0 != fDesc.fID) {
@@ -160,7 +160,7 @@
return SkToBool(fMapPtr);
}
-bool GrGLBufferImpl::updateData(GrGpuGL* gpu, const void* src, size_t srcSizeInBytes) {
+bool GrGLBufferImpl::updateData(GrGLGpu* gpu, const void* src, size_t srcSizeInBytes) {
SkASSERT(!this->isMapped());
VALIDATE();
if (srcSizeInBytes > fDesc.fSizeInBytes) {
diff --git a/src/gpu/gl/GrGLBufferImpl.h b/src/gpu/gl/GrGLBufferImpl.h
index 279075f..8617a89 100644
--- a/src/gpu/gl/GrGLBufferImpl.h
+++ b/src/gpu/gl/GrGLBufferImpl.h
@@ -11,7 +11,7 @@
#include "SkTypes.h"
#include "gl/GrGLFunctions.h"
-class GrGpuGL;
+class GrGLGpu;
/**
* This class serves as the implementation of GrGL*Buffer classes. It was written to avoid code
@@ -26,24 +26,24 @@
bool fDynamic;
};
- GrGLBufferImpl(GrGpuGL*, const Desc&, GrGLenum bufferType);
+ GrGLBufferImpl(GrGLGpu*, const Desc&, GrGLenum bufferType);
~GrGLBufferImpl() {
// either release or abandon should have been called by the owner of this object.
SkASSERT(0 == fDesc.fID);
}
void abandon();
- void release(GrGpuGL* gpu);
+ void release(GrGLGpu* gpu);
GrGLuint bufferID() const { return fDesc.fID; }
size_t baseOffset() const { return reinterpret_cast<size_t>(fCPUData); }
- void bind(GrGpuGL* gpu) const;
+ void bind(GrGLGpu* gpu) const;
- void* map(GrGpuGL* gpu);
- void unmap(GrGpuGL* gpu);
+ void* map(GrGLGpu* gpu);
+ void unmap(GrGLGpu* gpu);
bool isMapped() const;
- bool updateData(GrGpuGL* gpu, const void* src, size_t srcSizeInBytes);
+ bool updateData(GrGLGpu* gpu, const void* src, size_t srcSizeInBytes);
private:
void validate() const;
diff --git a/src/gpu/gl/GrGLIndexBuffer.cpp b/src/gpu/gl/GrGLIndexBuffer.cpp
index 5991c09..1fea4ea 100644
--- a/src/gpu/gl/GrGLIndexBuffer.cpp
+++ b/src/gpu/gl/GrGLIndexBuffer.cpp
@@ -8,7 +8,7 @@
#include "GrGLIndexBuffer.h"
#include "GrGpuGL.h"
-GrGLIndexBuffer::GrGLIndexBuffer(GrGpuGL* gpu, const Desc& desc)
+GrGLIndexBuffer::GrGLIndexBuffer(GrGLGpu* gpu, const Desc& desc)
: INHERITED(gpu, desc.fIsWrapped, desc.fSizeInBytes, desc.fDynamic, 0 == desc.fID)
, fImpl(gpu, desc, GR_GL_ELEMENT_ARRAY_BUFFER) {
this->registerWithCache();
diff --git a/src/gpu/gl/GrGLIndexBuffer.h b/src/gpu/gl/GrGLIndexBuffer.h
index a62bba1..0eb10bb 100644
--- a/src/gpu/gl/GrGLIndexBuffer.h
+++ b/src/gpu/gl/GrGLIndexBuffer.h
@@ -12,14 +12,14 @@
#include "GrGLBufferImpl.h"
#include "gl/GrGLInterface.h"
-class GrGpuGL;
+class GrGLGpu;
class GrGLIndexBuffer : public GrIndexBuffer {
public:
typedef GrGLBufferImpl::Desc Desc;
- GrGLIndexBuffer(GrGpuGL* gpu, const Desc& desc);
+ GrGLIndexBuffer(GrGLGpu* gpu, const Desc& desc);
GrGLuint bufferID() const { return fImpl.bufferID(); }
size_t baseOffset() const { return fImpl.baseOffset(); }
@@ -39,9 +39,9 @@
virtual void onUnmap() SK_OVERRIDE;
virtual bool onUpdateData(const void* src, size_t srcSizeInBytes) SK_OVERRIDE;
- GrGpuGL* getGpuGL() const {
+ GrGLGpu* getGpuGL() const {
SkASSERT(!this->wasDestroyed());
- return (GrGpuGL*)(this->getGpu());
+ return (GrGLGpu*)(this->getGpu());
}
GrGLBufferImpl fImpl;
diff --git a/src/gpu/gl/GrGLPath.cpp b/src/gpu/gl/GrGLPath.cpp
index abbd127..80139d7 100644
--- a/src/gpu/gl/GrGLPath.cpp
+++ b/src/gpu/gl/GrGLPath.cpp
@@ -90,7 +90,7 @@
static const bool kIsWrapped = false; // The constructor creates the GL path object.
-void GrGLPath::InitPathObject(GrGpuGL* gpu,
+void GrGLPath::InitPathObject(GrGLGpu* gpu,
GrGLuint pathID,
const SkPath& skPath,
const SkStrokeRec& stroke) {
@@ -183,7 +183,7 @@
}
}
-GrGLPath::GrGLPath(GrGpuGL* gpu, const SkPath& path, const SkStrokeRec& stroke)
+GrGLPath::GrGLPath(GrGLGpu* gpu, const SkPath& path, const SkStrokeRec& stroke)
: INHERITED(gpu, kIsWrapped, path, stroke),
fPathID(gpu->glPathRendering()->genPaths(1)) {
@@ -198,7 +198,7 @@
void GrGLPath::onRelease() {
if (0 != fPathID && !this->isWrapped()) {
- static_cast<GrGpuGL*>(this->getGpu())->glPathRendering()->deletePaths(fPathID, 1);
+ static_cast<GrGLGpu*>(this->getGpu())->glPathRendering()->deletePaths(fPathID, 1);
fPathID = 0;
}
diff --git a/src/gpu/gl/GrGLPath.h b/src/gpu/gl/GrGLPath.h
index a7640d5..57a2640 100644
--- a/src/gpu/gl/GrGLPath.h
+++ b/src/gpu/gl/GrGLPath.h
@@ -12,7 +12,7 @@
#include "../GrPath.h"
#include "gl/GrGLFunctions.h"
-class GrGpuGL;
+class GrGLGpu;
/**
* Currently this represents a path built using GL_NV_path_rendering. If we
@@ -22,12 +22,12 @@
class GrGLPath : public GrPath {
public:
- static void InitPathObject(GrGpuGL*,
+ static void InitPathObject(GrGLGpu*,
GrGLuint pathID,
const SkPath&,
const SkStrokeRec&);
- GrGLPath(GrGpuGL* gpu, const SkPath& path, const SkStrokeRec& stroke);
+ GrGLPath(GrGLGpu* gpu, const SkPath& path, const SkStrokeRec& stroke);
GrGLuint pathID() const { return fPathID; }
protected:
diff --git a/src/gpu/gl/GrGLPathRange.cpp b/src/gpu/gl/GrGLPathRange.cpp
index 5ff64f8..a85c320 100644
--- a/src/gpu/gl/GrGLPathRange.cpp
+++ b/src/gpu/gl/GrGLPathRange.cpp
@@ -11,14 +11,14 @@
#include "GrGLPathRendering.h"
#include "GrGpuGL.h"
-GrGLPathRange::GrGLPathRange(GrGpuGL* gpu, PathGenerator* pathGenerator, const SkStrokeRec& stroke)
+GrGLPathRange::GrGLPathRange(GrGLGpu* gpu, PathGenerator* pathGenerator, const SkStrokeRec& stroke)
: INHERITED(gpu, pathGenerator, stroke),
fBasePathID(gpu->glPathRendering()->genPaths(this->getNumPaths())),
fGpuMemorySize(0) {
this->registerWithCache();
}
-GrGLPathRange::GrGLPathRange(GrGpuGL* gpu,
+GrGLPathRange::GrGLPathRange(GrGLGpu* gpu,
GrGLuint basePathID,
int numPaths,
size_t gpuMemorySize,
@@ -30,7 +30,7 @@
}
void GrGLPathRange::onInitPath(int index, const SkPath& skPath) const {
- GrGpuGL* gpu = static_cast<GrGpuGL*>(this->getGpu());
+ GrGLGpu* gpu = static_cast<GrGLGpu*>(this->getGpu());
if (NULL == gpu) {
return;
}
@@ -51,7 +51,7 @@
SkASSERT(this->getGpu());
if (0 != fBasePathID && !this->isWrapped()) {
- static_cast<GrGpuGL*>(this->getGpu())->glPathRendering()->deletePaths(fBasePathID,
+ static_cast<GrGLGpu*>(this->getGpu())->glPathRendering()->deletePaths(fBasePathID,
this->getNumPaths());
fBasePathID = 0;
}
diff --git a/src/gpu/gl/GrGLPathRange.h b/src/gpu/gl/GrGLPathRange.h
index 5fbfb1f..17d44c2 100644
--- a/src/gpu/gl/GrGLPathRange.h
+++ b/src/gpu/gl/GrGLPathRange.h
@@ -12,7 +12,7 @@
#include "../GrPathRange.h"
#include "gl/GrGLFunctions.h"
-class GrGpuGL;
+class GrGLGpu;
/**
* Currently this represents a range of GL_NV_path_rendering Path IDs. If we
@@ -26,14 +26,14 @@
* Initialize a GL path range from a PathGenerator. This class will allocate
* the GPU path objects and initialize them lazily.
*/
- GrGLPathRange(GrGpuGL*, PathGenerator*, const SkStrokeRec&);
+ GrGLPathRange(GrGLGpu*, PathGenerator*, const SkStrokeRec&);
/**
* Initialize a GL path range from an existing range of pre-initialized GPU
* path objects. This class assumes ownership of the GPU path objects and
* will delete them when done.
*/
- GrGLPathRange(GrGpuGL*,
+ GrGLPathRange(GrGLGpu*,
GrGLuint basePathID,
int numPaths,
size_t gpuMemorySize,
diff --git a/src/gpu/gl/GrGLPathRendering.cpp b/src/gpu/gl/GrGLPathRendering.cpp
index 44b8681..a20c4de 100644
--- a/src/gpu/gl/GrGLPathRendering.cpp
+++ b/src/gpu/gl/GrGLPathRendering.cpp
@@ -59,7 +59,7 @@
}
}
-GrGLPathRendering::GrGLPathRendering(GrGpuGL* gpu)
+GrGLPathRendering::GrGLPathRendering(GrGLGpu* gpu)
: fGpu(gpu) {
const GrGLInterface* glInterface = gpu->glInterface();
fCaps.stencilThenCoverSupport =
diff --git a/src/gpu/gl/GrGLPathRendering.h b/src/gpu/gl/GrGLPathRendering.h
index 1f1a33c..ee4011d 100644
--- a/src/gpu/gl/GrGLPathRendering.h
+++ b/src/gpu/gl/GrGLPathRendering.h
@@ -15,11 +15,11 @@
#include "gl/GrGLProgram.h"
class GrGLNameAllocator;
-class GrGpuGL;
+class GrGLGpu;
/**
* This class wraps the NV_path_rendering extension and manages its various
- * API versions. If a method is not present in the GrGLInterface of the GrGpuGL
+ * API versions. If a method is not present in the GrGLInterface of the GrGLGpu
* (because the driver version is old), it tries to provide a backup
* implementation. But if a backup implementation is not practical, it marks the
* method as not supported.
@@ -27,9 +27,9 @@
class GrGLPathRendering : public GrPathRendering {
public:
/**
- * Create a new GrGLPathRendering object from a given GrGpuGL.
+ * Create a new GrGLPathRendering object from a given GrGLGpu.
*/
- GrGLPathRendering(GrGpuGL* gpu);
+ GrGLPathRendering(GrGLGpu* gpu);
virtual ~GrGLPathRendering();
// GrPathRendering implementations.
@@ -126,7 +126,7 @@
GrGLuint pathBase, GrGLint reference, GrGLuint mask, GrGLenum coverMode,
GrGLenum transformType, const GrGLfloat *transformValues);
- GrGpuGL* fGpu;
+ GrGLGpu* fGpu;
SkAutoTDelete<GrGLNameAllocator> fPathNameAllocator;
Caps fCaps;
GrGLProgram::MatrixState fHWProjectionMatrixState;
diff --git a/src/gpu/gl/GrGLProgram.cpp b/src/gpu/gl/GrGLProgram.cpp
index 7d5b0d7..0f4b70d 100644
--- a/src/gpu/gl/GrGLProgram.cpp
+++ b/src/gpu/gl/GrGLProgram.cpp
@@ -53,7 +53,7 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
-GrGLProgram::GrGLProgram(GrGpuGL* gpu,
+GrGLProgram::GrGLProgram(GrGLGpu* gpu,
const GrProgramDesc& desc,
const BuiltinUniformHandles& builtinUniforms,
GrGLuint programID,
@@ -239,7 +239,7 @@
/////////////////////////////////////////////////////////////////////////////////////////
-GrGLNvprProgramBase::GrGLNvprProgramBase(GrGpuGL* gpu,
+GrGLNvprProgramBase::GrGLNvprProgramBase(GrGLGpu* gpu,
const GrProgramDesc& desc,
const BuiltinUniformHandles& builtinUniforms,
GrGLuint programID,
@@ -261,7 +261,7 @@
/////////////////////////////////////////////////////////////////////////////////////////
-GrGLNvprProgram::GrGLNvprProgram(GrGpuGL* gpu,
+GrGLNvprProgram::GrGLNvprProgram(GrGLGpu* gpu,
const GrProgramDesc& desc,
const BuiltinUniformHandles& builtinUniforms,
GrGLuint programID,
@@ -314,7 +314,7 @@
//////////////////////////////////////////////////////////////////////////////////////
-GrGLLegacyNvprProgram::GrGLLegacyNvprProgram(GrGpuGL* gpu,
+GrGLLegacyNvprProgram::GrGLLegacyNvprProgram(GrGLGpu* gpu,
const GrProgramDesc& desc,
const BuiltinUniformHandles& builtinUniforms,
GrGLuint programID,
diff --git a/src/gpu/gl/GrGLProgram.h b/src/gpu/gl/GrGLProgram.h
index bada8fd..09dd4aa 100644
--- a/src/gpu/gl/GrGLProgram.h
+++ b/src/gpu/gl/GrGLProgram.h
@@ -126,7 +126,7 @@
/**
* This function uploads uniforms and calls each GrGLProcessor's setData. It is called before a
* draw occurs using the program after the program has already been bound. It also uses the
- * GrGpuGL object to bind the textures required by the GrGLProcessors. The color and coverage
+ * GrGLGpu object to bind the textures required by the GrGLProcessors. The color and coverage
* stages come from GrGLProgramDesc::Build().
*/
void setData(const GrOptDrawState&);
@@ -135,7 +135,7 @@
typedef GrGLProgramDataManager::UniformHandle UniformHandle;
typedef GrGLProgramDataManager::UniformInfoArray UniformInfoArray;
- GrGLProgram(GrGpuGL*,
+ GrGLProgram(GrGLGpu*,
const GrProgramDesc&,
const BuiltinUniformHandles&,
GrGLuint programID,
@@ -177,7 +177,7 @@
SkAutoTUnref<GrGLInstalledFragProcs> fFragmentProcessors;
GrProgramDesc fDesc;
- GrGpuGL* fGpu;
+ GrGLGpu* fGpu;
GrGLProgramDataManager fProgramDataManager;
friend class GrGLProgramBuilder;
@@ -194,7 +194,7 @@
*/
class GrGLNvprProgramBase : public GrGLProgram {
protected:
- GrGLNvprProgramBase(GrGpuGL*,
+ GrGLNvprProgramBase(GrGLGpu*,
const GrProgramDesc&,
const BuiltinUniformHandles&,
GrGLuint programID,
@@ -214,7 +214,7 @@
private:
typedef GrGLNvprProgramBuilder::SeparableVaryingInfo SeparableVaryingInfo;
typedef GrGLNvprProgramBuilder::SeparableVaryingInfoArray SeparableVaryingInfoArray;
- GrGLNvprProgram(GrGpuGL*,
+ GrGLNvprProgram(GrGLGpu*,
const GrProgramDesc&,
const BuiltinUniformHandles&,
GrGLuint programID,
@@ -245,7 +245,7 @@
virtual bool hasVertexShader() const SK_OVERRIDE { return false; }
private:
- GrGLLegacyNvprProgram(GrGpuGL* gpu,
+ GrGLLegacyNvprProgram(GrGLGpu* gpu,
const GrProgramDesc& desc,
const BuiltinUniformHandles&,
GrGLuint programID,
diff --git a/src/gpu/gl/GrGLProgramDataManager.cpp b/src/gpu/gl/GrGLProgramDataManager.cpp
index f8d996b..65bf735 100644
--- a/src/gpu/gl/GrGLProgramDataManager.cpp
+++ b/src/gpu/gl/GrGLProgramDataManager.cpp
@@ -14,7 +14,7 @@
SkASSERT(arrayCount <= uni.fArrayCount || \
(1 == arrayCount && GrGLShaderVar::kNonArray == uni.fArrayCount))
-GrGLProgramDataManager::GrGLProgramDataManager(GrGpuGL* gpu, const UniformInfoArray& uniforms)
+GrGLProgramDataManager::GrGLProgramDataManager(GrGLGpu* gpu, const UniformInfoArray& uniforms)
: fGpu(gpu) {
int count = uniforms.count();
fUniforms.push_back_n(count);
diff --git a/src/gpu/gl/GrGLProgramDataManager.h b/src/gpu/gl/GrGLProgramDataManager.h
index bbf7d42..31f7f2e 100644
--- a/src/gpu/gl/GrGLProgramDataManager.h
+++ b/src/gpu/gl/GrGLProgramDataManager.h
@@ -14,7 +14,7 @@
#include "SkTArray.h"
-class GrGpuGL;
+class GrGLGpu;
class SkMatrix;
class GrGLProgram;
class GrGLProgramBuilder;
@@ -67,7 +67,7 @@
// name strings. Otherwise, we'd have to hand out copies.
typedef GrTAllocator<UniformInfo> UniformInfoArray;
- GrGLProgramDataManager(GrGpuGL*, const UniformInfoArray&);
+ GrGLProgramDataManager(GrGLGpu*, const UniformInfoArray&);
/** Functions for uploading uniform values. The varities ending in v can be used to upload to an
* array of uniforms. arrayCount must be <= the array count of the uniform.
@@ -106,7 +106,7 @@
};
SkTArray<Uniform, true> fUniforms;
- GrGpuGL* fGpu;
+ GrGLGpu* fGpu;
typedef SkRefCnt INHERITED;
};
diff --git a/src/gpu/gl/GrGLProgramDesc.cpp b/src/gpu/gl/GrGLProgramDesc.cpp
index c5c31d3..06377c7 100644
--- a/src/gpu/gl/GrGLProgramDesc.cpp
+++ b/src/gpu/gl/GrGLProgramDesc.cpp
@@ -142,7 +142,7 @@
bool GrGLProgramDescBuilder::Build(const GrOptDrawState& optState,
const GrProgramDesc::DescInfo& descInfo,
GrGpu::DrawType drawType,
- GrGpuGL* gpu,
+ GrGLGpu* gpu,
GrProgramDesc* desc) {
// The descriptor is used as a cache key. Thus when a field of the
// descriptor will not affect program generation (because of the attribute
diff --git a/src/gpu/gl/GrGLProgramDesc.h b/src/gpu/gl/GrGLProgramDesc.h
index b53daeb..401ce22 100644
--- a/src/gpu/gl/GrGLProgramDesc.h
+++ b/src/gpu/gl/GrGLProgramDesc.h
@@ -13,7 +13,7 @@
#include "GrGpu.h"
#include "GrTypesPriv.h"
-class GrGpuGL;
+class GrGLGpu;
/**
* This class can be used to build a GrProgramDesc. It also provides helpers for accessing
@@ -52,7 +52,7 @@
* @param DescInfo A descriptor info struct, generated by the optstate, which contains a number
* of important facts about the program the built descriptor will represent
* @param DrawType
- * @param GrGpuGL A GL Gpu, the caps and Gpu object are used to output processor specific
+ * @param GrGLGpu A GL Gpu, the caps and Gpu object are used to output processor specific
* parts of the descriptor.
* @param GrDeviceCoordTexture A dstCopy texture, which may be null if frame buffer fetch is
* supported
@@ -61,7 +61,7 @@
static bool Build(const GrOptDrawState&,
const GrProgramDesc::DescInfo&,
GrGpu::DrawType,
- GrGpuGL*,
+ GrGLGpu*,
GrProgramDesc*);
static const GLKeyHeader& GetHeader(const GrProgramDesc& desc) {
diff --git a/src/gpu/gl/GrGLRenderTarget.cpp b/src/gpu/gl/GrGLRenderTarget.cpp
index 4af7be2..425764d 100644
--- a/src/gpu/gl/GrGLRenderTarget.cpp
+++ b/src/gpu/gl/GrGLRenderTarget.cpp
@@ -9,18 +9,18 @@
#include "GrGpuGL.h"
-#define GPUGL static_cast<GrGpuGL*>(this->getGpu())
+#define GPUGL static_cast<GrGLGpu*>(this->getGpu())
#define GL_CALL(X) GR_GL_CALL(GPUGL->glInterface(), X)
// Because this class is virtually derived from GrSurface we must explicitly call its constructor.
-GrGLRenderTarget::GrGLRenderTarget(GrGpuGL* gpu, const GrSurfaceDesc& desc, const IDDesc& idDesc)
+GrGLRenderTarget::GrGLRenderTarget(GrGLGpu* gpu, const GrSurfaceDesc& desc, const IDDesc& idDesc)
: GrSurface(gpu, idDesc.fIsWrapped, desc)
, INHERITED(gpu, idDesc.fIsWrapped, desc) {
this->init(desc, idDesc);
this->registerWithCache();
}
-GrGLRenderTarget::GrGLRenderTarget(GrGpuGL* gpu, const GrSurfaceDesc& desc, const IDDesc& idDesc,
+GrGLRenderTarget::GrGLRenderTarget(GrGLGpu* gpu, const GrSurfaceDesc& desc, const IDDesc& idDesc,
Derived)
: GrSurface(gpu, idDesc.fIsWrapped, desc)
, INHERITED(gpu, idDesc.fIsWrapped, desc) {
diff --git a/src/gpu/gl/GrGLRenderTarget.h b/src/gpu/gl/GrGLRenderTarget.h
index 079e9d5..adc967f 100644
--- a/src/gpu/gl/GrGLRenderTarget.h
+++ b/src/gpu/gl/GrGLRenderTarget.h
@@ -13,7 +13,7 @@
#include "GrRenderTarget.h"
#include "SkScalar.h"
-class GrGpuGL;
+class GrGLGpu;
class GrGLRenderTarget : public GrRenderTarget {
public:
@@ -28,7 +28,7 @@
bool fIsWrapped;
};
- GrGLRenderTarget(GrGpuGL*, const GrSurfaceDesc&, const IDDesc&);
+ GrGLRenderTarget(GrGLGpu*, const GrSurfaceDesc&, const IDDesc&);
void setViewport(const GrGLIRect& rect) { fViewport = rect; }
const GrGLIRect& getViewport() const { return fViewport; }
@@ -61,7 +61,7 @@
// class should register with the cache. This constructor does not do the registration and
// rather moves that burden onto the derived class.
enum Derived { kDerived };
- GrGLRenderTarget(GrGpuGL*, const GrSurfaceDesc&, const IDDesc&, Derived);
+ GrGLRenderTarget(GrGLGpu*, const GrSurfaceDesc&, const IDDesc&, Derived);
void init(const GrSurfaceDesc&, const IDDesc&);
diff --git a/src/gpu/gl/GrGLStencilBuffer.cpp b/src/gpu/gl/GrGLStencilBuffer.cpp
index 2ec06d4..1e854cf 100644
--- a/src/gpu/gl/GrGLStencilBuffer.cpp
+++ b/src/gpu/gl/GrGLStencilBuffer.cpp
@@ -19,7 +19,7 @@
void GrGLStencilBuffer::onRelease() {
if (0 != fRenderbufferID && !this->isWrapped()) {
- GrGpuGL* gpuGL = (GrGpuGL*) this->getGpu();
+ GrGLGpu* gpuGL = (GrGLGpu*) this->getGpu();
const GrGLInterface* gl = gpuGL->glInterface();
GR_GL_CALL(gl, DeleteRenderbuffers(1, &fRenderbufferID));
fRenderbufferID = 0;
diff --git a/src/gpu/gl/GrGLTexture.cpp b/src/gpu/gl/GrGLTexture.cpp
index ce892dd..d34a3c0 100644
--- a/src/gpu/gl/GrGLTexture.cpp
+++ b/src/gpu/gl/GrGLTexture.cpp
@@ -8,18 +8,18 @@
#include "GrGLTexture.h"
#include "GrGpuGL.h"
-#define GPUGL static_cast<GrGpuGL*>(this->getGpu())
+#define GPUGL static_cast<GrGLGpu*>(this->getGpu())
#define GL_CALL(X) GR_GL_CALL(GPUGL->glInterface(), X)
// Because this class is virtually derived from GrSurface we must explicitly call its constructor.
-GrGLTexture::GrGLTexture(GrGpuGL* gpu, const GrSurfaceDesc& desc, const IDDesc& idDesc)
+GrGLTexture::GrGLTexture(GrGLGpu* gpu, const GrSurfaceDesc& desc, const IDDesc& idDesc)
: GrSurface(gpu, idDesc.fIsWrapped, desc)
, INHERITED(gpu, idDesc.fIsWrapped, desc) {
this->init(desc, idDesc);
this->registerWithCache();
}
-GrGLTexture::GrGLTexture(GrGpuGL* gpu, const GrSurfaceDesc& desc, const IDDesc& idDesc, Derived)
+GrGLTexture::GrGLTexture(GrGLGpu* gpu, const GrSurfaceDesc& desc, const IDDesc& idDesc, Derived)
: GrSurface(gpu, idDesc.fIsWrapped, desc)
, INHERITED(gpu, idDesc.fIsWrapped, desc) {
this->init(desc, idDesc);
diff --git a/src/gpu/gl/GrGLTexture.h b/src/gpu/gl/GrGLTexture.h
index bfa0ec3..7c64e17 100644
--- a/src/gpu/gl/GrGLTexture.h
+++ b/src/gpu/gl/GrGLTexture.h
@@ -31,7 +31,7 @@
bool fIsWrapped;
};
- GrGLTexture(GrGpuGL*, const GrSurfaceDesc&, const IDDesc&);
+ GrGLTexture(GrGLGpu*, const GrSurfaceDesc&, const IDDesc&);
virtual GrBackendObject getTextureHandle() const SK_OVERRIDE;
@@ -56,7 +56,7 @@
// class should register with the cache. This constructor does not do the registration and
// rather moves that burden onto the derived class.
enum Derived { kDerived };
- GrGLTexture(GrGpuGL*, const GrSurfaceDesc&, const IDDesc&, Derived);
+ GrGLTexture(GrGLGpu*, const GrSurfaceDesc&, const IDDesc&, Derived);
void init(const GrSurfaceDesc&, const IDDesc&);
diff --git a/src/gpu/gl/GrGLTextureRenderTarget.h b/src/gpu/gl/GrGLTextureRenderTarget.h
index 11577b8..69f70c4 100644
--- a/src/gpu/gl/GrGLTextureRenderTarget.h
+++ b/src/gpu/gl/GrGLTextureRenderTarget.h
@@ -12,7 +12,7 @@
#include "GrGLTexture.h"
#include "GrGLRenderTarget.h"
-class GrGpuGL;
+class GrGLGpu;
#ifdef SK_BUILD_FOR_WIN
// Windows gives bogus warnings about inheriting asTexture/asRenderTarget via dominance.
@@ -24,7 +24,7 @@
public:
// We're virtually derived from GrSurface (via both GrGLTexture and GrGLRenderTarget) so its
// constructor must be explicitly called.
- GrGLTextureRenderTarget(GrGpuGL* gpu,
+ GrGLTextureRenderTarget(GrGLGpu* gpu,
const GrSurfaceDesc& desc,
const GrGLTexture::IDDesc& texIDDesc,
const GrGLRenderTarget::IDDesc& rtIDDesc)
diff --git a/src/gpu/gl/GrGLVertexArray.cpp b/src/gpu/gl/GrGLVertexArray.cpp
index 4acf292..e28a163 100644
--- a/src/gpu/gl/GrGLVertexArray.cpp
+++ b/src/gpu/gl/GrGLVertexArray.cpp
@@ -8,10 +8,10 @@
#include "GrGLVertexArray.h"
#include "GrGpuGL.h"
-#define GPUGL static_cast<GrGpuGL*>(this->getGpu())
+#define GPUGL static_cast<GrGLGpu*>(this->getGpu())
#define GL_CALL(X) GR_GL_CALL(GPUGL->glInterface(), X);
-void GrGLAttribArrayState::set(const GrGpuGL* gpu,
+void GrGLAttribArrayState::set(const GrGLGpu* gpu,
int index,
GrGLVertexBuffer* buffer,
GrGLint size,
@@ -49,7 +49,7 @@
}
}
-void GrGLAttribArrayState::disableUnusedArrays(const GrGpuGL* gpu, uint64_t usedMask) {
+void GrGLAttribArrayState::disableUnusedArrays(const GrGLGpu* gpu, uint64_t usedMask) {
int count = fAttribArrayStates.count();
for (int i = 0; i < count; ++i) {
if (!(usedMask & 0x1)) {
@@ -68,7 +68,7 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
-GrGLVertexArray::GrGLVertexArray(GrGpuGL* gpu, GrGLint id, int attribCount)
+GrGLVertexArray::GrGLVertexArray(GrGLGpu* gpu, GrGLint id, int attribCount)
: INHERITED(gpu, false)
, fID(id)
, fAttribArrays(attribCount)
diff --git a/src/gpu/gl/GrGLVertexArray.h b/src/gpu/gl/GrGLVertexArray.h
index e5032a9..792fd94 100644
--- a/src/gpu/gl/GrGLVertexArray.h
+++ b/src/gpu/gl/GrGLVertexArray.h
@@ -17,7 +17,7 @@
class GrGLVertexBuffer;
class GrGLIndexBuffer;
-class GrGpuGL;
+class GrGLGpu;
struct GrGLAttribLayout {
GrGLint fCount;
@@ -67,7 +67,7 @@
* assumed that the GrGLAttribArrayState is tracking the state of the currently bound vertex
* array object.
*/
- void set(const GrGpuGL*,
+ void set(const GrGLGpu*,
int index,
GrGLVertexBuffer*,
GrGLint size,
@@ -80,7 +80,7 @@
* This function disables vertex attribs not present in the mask. It is assumed that the
* GrGLAttribArrayState is tracking the state of the currently bound vertex array object.
*/
- void disableUnusedArrays(const GrGpuGL*, uint64_t usedAttribArrayMask);
+ void disableUnusedArrays(const GrGLGpu*, uint64_t usedAttribArrayMask);
void invalidate() {
int count = fAttribArrayStates.count();
@@ -134,7 +134,7 @@
*/
class GrGLVertexArray : public GrGpuResource {
public:
- GrGLVertexArray(GrGpuGL* gpu, GrGLint id, int attribCount);
+ GrGLVertexArray(GrGLGpu* gpu, GrGLint id, int attribCount);
/**
* Binds this vertex array. If the ID has been deleted or abandoned then NULL is returned.
diff --git a/src/gpu/gl/GrGLVertexBuffer.cpp b/src/gpu/gl/GrGLVertexBuffer.cpp
index d6b6301..1f30767 100644
--- a/src/gpu/gl/GrGLVertexBuffer.cpp
+++ b/src/gpu/gl/GrGLVertexBuffer.cpp
@@ -8,7 +8,7 @@
#include "GrGLVertexBuffer.h"
#include "GrGpuGL.h"
-GrGLVertexBuffer::GrGLVertexBuffer(GrGpuGL* gpu, const Desc& desc)
+GrGLVertexBuffer::GrGLVertexBuffer(GrGLGpu* gpu, const Desc& desc)
: INHERITED(gpu, desc.fIsWrapped, desc.fSizeInBytes, desc.fDynamic, 0 == desc.fID)
, fImpl(gpu, desc, GR_GL_ARRAY_BUFFER) {
this->registerWithCache();
diff --git a/src/gpu/gl/GrGLVertexBuffer.h b/src/gpu/gl/GrGLVertexBuffer.h
index 40f4af9..ea2e37d 100644
--- a/src/gpu/gl/GrGLVertexBuffer.h
+++ b/src/gpu/gl/GrGLVertexBuffer.h
@@ -12,14 +12,14 @@
#include "GrGLBufferImpl.h"
#include "gl/GrGLInterface.h"
-class GrGpuGL;
+class GrGLGpu;
class GrGLVertexBuffer : public GrVertexBuffer {
public:
typedef GrGLBufferImpl::Desc Desc;
- GrGLVertexBuffer(GrGpuGL* gpu, const Desc& desc);
+ GrGLVertexBuffer(GrGLGpu* gpu, const Desc& desc);
GrGLuint bufferID() const { return fImpl.bufferID(); }
size_t baseOffset() const { return fImpl.baseOffset(); }
@@ -39,9 +39,9 @@
virtual void onUnmap() SK_OVERRIDE;
virtual bool onUpdateData(const void* src, size_t srcSizeInBytes) SK_OVERRIDE;
- GrGpuGL* getGpuGL() const {
+ GrGLGpu* getGpuGL() const {
SkASSERT(!this->wasDestroyed());
- return (GrGpuGL*)(this->getGpu());
+ return (GrGLGpu*)(this->getGpu());
}
GrGLBufferImpl fImpl;
diff --git a/src/gpu/gl/GrGpuGL.cpp b/src/gpu/gl/GrGpuGL.cpp
index 0efb7eb..2965cd4 100644
--- a/src/gpu/gl/GrGpuGL.cpp
+++ b/src/gpu/gl/GrGpuGL.cpp
@@ -60,7 +60,7 @@
GR_GL_ONE_MINUS_SRC1_ALPHA,
};
-bool GrGpuGL::BlendCoeffReferencesConstant(GrBlendCoeff coeff) {
+bool GrGLGpu::BlendCoeffReferencesConstant(GrBlendCoeff coeff) {
static const bool gCoeffReferencesBlendConst[] = {
false,
false,
@@ -116,7 +116,7 @@
static bool gPrintStartupSpew;
-GrGpuGL::GrGpuGL(const GrGLContext& ctx, GrContext* context)
+GrGLGpu::GrGLGpu(const GrGLContext& ctx, GrContext* context)
: GrGpu(context)
, fGLContext(ctx) {
@@ -133,7 +133,7 @@
GL_CALL_RET(vendor, GetString(GR_GL_VENDOR));
GL_CALL_RET(renderer, GetString(GR_GL_RENDERER));
GL_CALL_RET(version, GetString(GR_GL_VERSION));
- SkDebugf("------------------------- create GrGpuGL %p --------------\n",
+ SkDebugf("------------------------- create GrGLGpu %p --------------\n",
this);
SkDebugf("------ VENDOR %s\n", vendor);
SkDebugf("------ RENDERER %s\n", renderer);
@@ -156,7 +156,7 @@
}
}
-GrGpuGL::~GrGpuGL() {
+GrGLGpu::~GrGLGpu() {
if (0 != fHWProgramID) {
// detach the current program so there is no confusion on OpenGL's part
// that we want it to be deleted
@@ -167,7 +167,7 @@
delete fProgramCache;
}
-void GrGpuGL::contextAbandoned() {
+void GrGLGpu::contextAbandoned() {
INHERITED::contextAbandoned();
fProgramCache->abandon();
fHWProgramID = 0;
@@ -177,7 +177,7 @@
}
///////////////////////////////////////////////////////////////////////////////
-GrPixelConfig GrGpuGL::preferredReadPixelsConfig(GrPixelConfig readConfig,
+GrPixelConfig GrGLGpu::preferredReadPixelsConfig(GrPixelConfig readConfig,
GrPixelConfig surfaceConfig) const {
if (GR_GL_RGBA_8888_PIXEL_OPS_SLOW && kRGBA_8888_GrPixelConfig == readConfig) {
return kBGRA_8888_GrPixelConfig;
@@ -200,7 +200,7 @@
}
}
-GrPixelConfig GrGpuGL::preferredWritePixelsConfig(GrPixelConfig writeConfig,
+GrPixelConfig GrGLGpu::preferredWritePixelsConfig(GrPixelConfig writeConfig,
GrPixelConfig surfaceConfig) const {
if (GR_GL_RGBA_8888_PIXEL_OPS_SLOW && kRGBA_8888_GrPixelConfig == writeConfig) {
return kBGRA_8888_GrPixelConfig;
@@ -209,7 +209,7 @@
}
}
-bool GrGpuGL::canWriteTexturePixels(const GrTexture* texture, GrPixelConfig srcConfig) const {
+bool GrGLGpu::canWriteTexturePixels(const GrTexture* texture, GrPixelConfig srcConfig) const {
if (kIndex_8_GrPixelConfig == srcConfig || kIndex_8_GrPixelConfig == texture->config()) {
return false;
}
@@ -232,11 +232,11 @@
}
}
-bool GrGpuGL::fullReadPixelsIsFasterThanPartial() const {
+bool GrGLGpu::fullReadPixelsIsFasterThanPartial() const {
return SkToBool(GR_GL_FULL_READPIXELS_FASTER_THAN_PARTIAL);
}
-void GrGpuGL::onResetContext(uint32_t resetBits) {
+void GrGLGpu::onResetContext(uint32_t resetBits) {
// we don't use the zb at all
if (resetBits & kMisc_GrGLBackendState) {
GL_CALL(Disable(GR_GL_DEPTH_TEST));
@@ -359,7 +359,7 @@
}
-GrTexture* GrGpuGL::onWrapBackendTexture(const GrBackendTextureDesc& desc) {
+GrTexture* GrGLGpu::onWrapBackendTexture(const GrBackendTextureDesc& desc) {
if (!this->configToGLFormats(desc.fConfig, false, NULL, NULL, NULL)) {
return NULL;
}
@@ -413,7 +413,7 @@
return texture;
}
-GrRenderTarget* GrGpuGL::onWrapBackendRenderTarget(const GrBackendRenderTargetDesc& wrapDesc) {
+GrRenderTarget* GrGLGpu::onWrapBackendRenderTarget(const GrBackendRenderTargetDesc& wrapDesc) {
GrGLRenderTarget::IDDesc idDesc;
idDesc.fRTFBOID = static_cast<GrGLuint>(wrapDesc.fRenderTargetHandle);
idDesc.fMSColorRenderbufferID = 0;
@@ -451,7 +451,7 @@
////////////////////////////////////////////////////////////////////////////////
-bool GrGpuGL::onWriteTexturePixels(GrTexture* texture,
+bool GrGLGpu::onWriteTexturePixels(GrTexture* texture,
int left, int top, int width, int height,
GrPixelConfig config, const void* buffer,
size_t rowBytes) {
@@ -465,7 +465,7 @@
bool success = false;
if (GrPixelConfigIsCompressed(glTex->desc().fConfig)) {
- // We check that config == desc.fConfig in GrGpuGL::canWriteTexturePixels()
+ // We check that config == desc.fConfig in GrGLGpu::canWriteTexturePixels()
SkASSERT(config == glTex->desc().fConfig);
success = this->uploadCompressedTexData(glTex->desc(), buffer, false, left, top, width,
height);
@@ -517,7 +517,7 @@
}
}
-bool GrGpuGL::uploadTexData(const GrSurfaceDesc& desc,
+bool GrGLGpu::uploadTexData(const GrSurfaceDesc& desc,
bool isNewTexture,
int left, int top, int width, int height,
GrPixelConfig dataConfig,
@@ -689,7 +689,7 @@
// create a CompressedTexData struct that takes a desc/ptr and figures out
// the proper upload semantics. Then users can construct this function how they
// see fit if they want to go against the "standard" way to do it.
-bool GrGpuGL::uploadCompressedTexData(const GrSurfaceDesc& desc,
+bool GrGLGpu::uploadCompressedTexData(const GrSurfaceDesc& desc,
const void* data,
bool isNewTexture,
int left, int top, int width, int height) {
@@ -795,7 +795,7 @@
return (GR_GL_NO_ERROR == CHECK_ALLOC_ERROR(ctx.interface()));;
}
-bool GrGpuGL::createRenderTargetObjects(const GrSurfaceDesc& desc, GrGLuint texID,
+bool GrGLGpu::createRenderTargetObjects(const GrSurfaceDesc& desc, GrGLuint texID,
GrGLRenderTarget::IDDesc* idDesc) {
idDesc->fMSColorRenderbufferID = 0;
idDesc->fRTFBOID = 0;
@@ -913,7 +913,7 @@
}
#endif
-GrTexture* GrGpuGL::onCreateTexture(const GrSurfaceDesc& origDesc,
+GrTexture* GrGLGpu::onCreateTexture(const GrSurfaceDesc& origDesc,
const void* srcData,
size_t rowBytes) {
@@ -1024,7 +1024,7 @@
return tex;
}
-GrTexture* GrGpuGL::onCreateCompressedTexture(const GrSurfaceDesc& origDesc, const void* srcData) {
+GrTexture* GrGLGpu::onCreateCompressedTexture(const GrSurfaceDesc& origDesc, const void* srcData) {
if(SkToBool(origDesc.fFlags & kRenderTarget_GrSurfaceFlag) || origDesc.fSampleCnt > 0) {
return return_null_texture();
@@ -1118,7 +1118,7 @@
}
}
-bool GrGpuGL::createStencilBufferForRenderTarget(GrRenderTarget* rt, int width, int height) {
+bool GrGLGpu::createStencilBufferForRenderTarget(GrRenderTarget* rt, int width, int height) {
// All internally created RTs are also textures. We don't create
// SBs for a client's standalone RT (that is a RT that isn't also a texture).
@@ -1183,7 +1183,7 @@
return false;
}
-bool GrGpuGL::attachStencilBufferToRenderTarget(GrStencilBuffer* sb, GrRenderTarget* rt) {
+bool GrGLGpu::attachStencilBufferToRenderTarget(GrStencilBuffer* sb, GrRenderTarget* rt) {
GrGLRenderTarget* glrt = static_cast<GrGLRenderTarget*>(rt);
GrGLuint fbo = glrt->renderFBOID();
@@ -1248,7 +1248,7 @@
////////////////////////////////////////////////////////////////////////////////
-GrVertexBuffer* GrGpuGL::onCreateVertexBuffer(size_t size, bool dynamic) {
+GrVertexBuffer* GrGLGpu::onCreateVertexBuffer(size_t size, bool dynamic) {
GrGLVertexBuffer::Desc desc;
desc.fDynamic = dynamic;
desc.fSizeInBytes = size;
@@ -1281,7 +1281,7 @@
}
}
-GrIndexBuffer* GrGpuGL::onCreateIndexBuffer(size_t size, bool dynamic) {
+GrIndexBuffer* GrGLGpu::onCreateIndexBuffer(size_t size, bool dynamic) {
GrGLIndexBuffer::Desc desc;
desc.fDynamic = dynamic;
desc.fSizeInBytes = size;
@@ -1314,7 +1314,7 @@
}
}
-void GrGpuGL::flushScissor(const GrClipMaskManager::ScissorState& scissorState,
+void GrGLGpu::flushScissor(const GrClipMaskManager::ScissorState& scissorState,
const GrGLIRect& rtViewport,
GrSurfaceOrigin rtOrigin) {
if (scissorState.fEnabled) {
@@ -1344,7 +1344,7 @@
this->disableScissor();
}
-bool GrGpuGL::flushGraphicsState(const GrOptDrawState& optState) {
+bool GrGLGpu::flushGraphicsState(const GrOptDrawState& optState) {
// GrGpu::setupClipAndFlushState should have already checked this and bailed if not true.
SkASSERT(optState.getRenderTarget());
@@ -1387,7 +1387,7 @@
return true;
}
-void GrGpuGL::setupGeometry(const GrOptDrawState& optState,
+void GrGLGpu::setupGeometry(const GrOptDrawState& optState,
const GrDrawTarget::DrawInfo& info,
size_t* indexOffsetInBytes) {
GrGLVertexBuffer* vbuf;
@@ -1441,7 +1441,7 @@
}
}
-void GrGpuGL::buildProgramDesc(const GrOptDrawState& optState,
+void GrGLGpu::buildProgramDesc(const GrOptDrawState& optState,
const GrProgramDesc::DescInfo& descInfo,
GrGpu::DrawType drawType,
GrProgramDesc* desc) {
@@ -1450,7 +1450,7 @@
}
}
-void GrGpuGL::disableScissor() {
+void GrGLGpu::disableScissor() {
if (kNo_TriState != fHWScissorSettings.fEnabled) {
GL_CALL(Disable(GR_GL_SCISSOR_TEST));
fHWScissorSettings.fEnabled = kNo_TriState;
@@ -1458,7 +1458,7 @@
}
}
-void GrGpuGL::onClear(GrRenderTarget* target, const SkIRect* rect, GrColor color,
+void GrGLGpu::onClear(GrRenderTarget* target, const SkIRect* rect, GrColor color,
bool canIgnoreRect) {
// parent class should never let us get here with no RT
SkASSERT(target);
@@ -1502,7 +1502,7 @@
GL_CALL(Clear(GR_GL_COLOR_BUFFER_BIT));
}
-void GrGpuGL::discard(GrRenderTarget* renderTarget) {
+void GrGLGpu::discard(GrRenderTarget* renderTarget) {
SkASSERT(renderTarget);
if (!this->caps()->discardRenderTargetSupport()) {
return;
@@ -1552,7 +1552,7 @@
}
-void GrGpuGL::clearStencil(GrRenderTarget* target) {
+void GrGLGpu::clearStencil(GrRenderTarget* target) {
if (NULL == target) {
return;
}
@@ -1567,7 +1567,7 @@
fHWStencilSettings.invalidate();
}
-void GrGpuGL::onClearStencilClip(GrRenderTarget* target, const SkIRect& rect, bool insideClip) {
+void GrGLGpu::onClearStencilClip(GrRenderTarget* target, const SkIRect& rect, bool insideClip) {
SkASSERT(target);
// this should only be called internally when we know we have a
@@ -1605,7 +1605,7 @@
fHWStencilSettings.invalidate();
}
-bool GrGpuGL::readPixelsWillPayForYFlip(GrRenderTarget* renderTarget,
+bool GrGLGpu::readPixelsWillPayForYFlip(GrRenderTarget* renderTarget,
int left, int top,
int width, int height,
GrPixelConfig config,
@@ -1636,7 +1636,7 @@
}
}
-bool GrGpuGL::onReadPixels(GrRenderTarget* target,
+bool GrGLGpu::onReadPixels(GrRenderTarget* target,
int left, int top,
int width, int height,
GrPixelConfig config,
@@ -1764,7 +1764,7 @@
return true;
}
-void GrGpuGL::flushRenderTarget(GrGLRenderTarget* target, const SkIRect* bound) {
+void GrGLGpu::flushRenderTarget(GrGLRenderTarget* target, const SkIRect* bound) {
SkASSERT(target);
@@ -1781,7 +1781,7 @@
GrGLenum status;
GL_CALL_RET(status, CheckFramebufferStatus(GR_GL_FRAMEBUFFER));
if (status != GR_GL_FRAMEBUFFER_COMPLETE) {
- SkDebugf("GrGpuGL::flushRenderTarget glCheckFramebufferStatus %x\n", status);
+ SkDebugf("GrGLGpu::flushRenderTarget glCheckFramebufferStatus %x\n", status);
}
}
#endif
@@ -1833,7 +1833,7 @@
#endif
#endif
-void GrGpuGL::onDraw(const GrOptDrawState& ds, const GrDrawTarget::DrawInfo& info) {
+void GrGLGpu::onDraw(const GrOptDrawState& ds, const GrDrawTarget::DrawInfo& info) {
size_t indexOffsetInBytes;
this->setupGeometry(ds, info, &indexOffsetInBytes);
@@ -1867,7 +1867,7 @@
#endif
}
-void GrGpuGL::onResolveRenderTarget(GrRenderTarget* target) {
+void GrGLGpu::onResolveRenderTarget(GrRenderTarget* target) {
GrGLRenderTarget* rt = static_cast<GrGLRenderTarget*>(target);
if (rt->needsResolve()) {
// Some extensions automatically resolves the texture when it is read.
@@ -1961,7 +1961,7 @@
}
}
-void GrGpuGL::flushStencil(const GrStencilSettings& stencilSettings, DrawType type) {
+void GrGLGpu::flushStencil(const GrStencilSettings& stencilSettings, DrawType type) {
// TODO figure out why we need to flush stencil settings on path draws at all
if (kStencilPath_DrawType != type && fHWStencilSettings != stencilSettings) {
if (stencilSettings.isDisabled()) {
@@ -1996,7 +1996,7 @@
}
}
-void GrGpuGL::flushAAState(const GrOptDrawState& optState) {
+void GrGLGpu::flushAAState(const GrOptDrawState& optState) {
// At least some ATI linux drivers will render GL_LINES incorrectly when MSAA state is enabled but
// the target is not multisampled. Single pixel wide lines are rendered thicker than 1 pixel wide.
#if 0
@@ -2025,7 +2025,7 @@
}
}
-void GrGpuGL::flushBlend(const GrOptDrawState& optState) {
+void GrGLGpu::flushBlend(const GrOptDrawState& optState) {
// Any optimization to disable blending should have already been applied and
// tweaked the coeffs to (1, 0).
@@ -2078,7 +2078,7 @@
return gWrapModes[tm];
}
-void GrGpuGL::bindTexture(int unitIdx, const GrTextureParams& params, GrGLTexture* texture) {
+void GrGLGpu::bindTexture(int unitIdx, const GrTextureParams& params, GrGLTexture* texture) {
SkASSERT(texture);
// If we created a rt/tex and rendered to it without using a texture and now we're texturing
@@ -2178,7 +2178,7 @@
texture->setCachedTexParams(newTexParams, this->getResetTimestamp());
}
-void GrGpuGL::flushMiscFixedFunctionState(const GrOptDrawState& optState) {
+void GrGLGpu::flushMiscFixedFunctionState(const GrOptDrawState& optState) {
if (optState.isDitherState()) {
if (kYes_TriState != fHWDitherEnabled) {
GL_CALL(Enable(GR_GL_DITHER));
@@ -2224,7 +2224,7 @@
}
}
-bool GrGpuGL::configToGLFormats(GrPixelConfig config,
+bool GrGLGpu::configToGLFormats(GrPixelConfig config,
bool getSizedInternalFormat,
GrGLenum* internalFormat,
GrGLenum* externalFormat,
@@ -2373,7 +2373,7 @@
return true;
}
-void GrGpuGL::setTextureUnit(int unit) {
+void GrGLGpu::setTextureUnit(int unit) {
SkASSERT(unit >= 0 && unit < fHWBoundTextureUniqueIDs.count());
if (unit != fHWActiveTextureUnitIdx) {
GL_CALL(ActiveTexture(GR_GL_TEXTURE0 + unit));
@@ -2381,7 +2381,7 @@
}
}
-void GrGpuGL::setScratchTextureUnit() {
+void GrGLGpu::setScratchTextureUnit() {
// Bind the last texture unit since it is the least likely to be used by GrGLProgram.
int lastUnitIdx = fHWBoundTextureUniqueIDs.count() - 1;
if (lastUnitIdx != fHWActiveTextureUnitIdx) {
@@ -2397,7 +2397,7 @@
// Determines whether glBlitFramebuffer could be used between src and dst.
inline bool can_blit_framebuffer(const GrSurface* dst,
const GrSurface* src,
- const GrGpuGL* gpu,
+ const GrGLGpu* gpu,
bool* wouldNeedTempFBO = NULL) {
if (gpu->glCaps().isConfigRenderable(dst->config(), dst->desc().fSampleCnt > 0) &&
gpu->glCaps().isConfigRenderable(src->config(), src->desc().fSampleCnt > 0) &&
@@ -2419,7 +2419,7 @@
inline bool can_copy_texsubimage(const GrSurface* dst,
const GrSurface* src,
- const GrGpuGL* gpu,
+ const GrGLGpu* gpu,
bool* wouldNeedTempFBO = NULL) {
// Table 3.9 of the ES2 spec indicates the supported formats with CopyTexSubImage
// and BGRA isn't in the spec. There doesn't appear to be any extension that adds it. Perhaps
@@ -2457,7 +2457,7 @@
// If a temporary FBO was created, its non-zero ID is returned. The viewport that the copy rect is
// relative to is output.
-GrGLuint GrGpuGL::bindSurfaceAsFBO(GrSurface* surface, GrGLenum fboTarget, GrGLIRect* viewport) {
+GrGLuint GrGLGpu::bindSurfaceAsFBO(GrSurface* surface, GrGLenum fboTarget, GrGLIRect* viewport) {
GrGLRenderTarget* rt = static_cast<GrGLRenderTarget*>(surface->asRenderTarget());
GrGLuint tempFBOID;
if (NULL == rt) {
@@ -2484,7 +2484,7 @@
return tempFBOID;
}
-bool GrGpuGL::initCopySurfaceDstDesc(const GrSurface* src, GrSurfaceDesc* desc) {
+bool GrGLGpu::initCopySurfaceDstDesc(const GrSurface* src, GrSurfaceDesc* desc) {
// In here we look for opportunities to use CopyTexSubImage, or fbo blit. If neither are
// possible and we return false to fallback to creating a render target dst for render-to-
// texture. This code prefers CopyTexSubImage to fbo blit and avoids triggering temporary fbo
@@ -2527,7 +2527,7 @@
return true;
}
-bool GrGpuGL::copySurface(GrSurface* dst,
+bool GrGLGpu::copySurface(GrSurface* dst,
GrSurface* src,
const SkIRect& srcRect,
const SkIPoint& dstPoint) {
@@ -2630,7 +2630,7 @@
return copied;
}
-bool GrGpuGL::canCopySurface(const GrSurface* dst,
+bool GrGLGpu::canCopySurface(const GrSurface* dst,
const GrSurface* src,
const SkIRect& srcRect,
const SkIPoint& dstPoint) {
@@ -2655,7 +2655,7 @@
return false;
}
-void GrGpuGL::didAddGpuTraceMarker() {
+void GrGLGpu::didAddGpuTraceMarker() {
if (this->caps()->gpuTracingSupport()) {
const GrTraceMarkerSet& markerArray = this->getActiveTraceMarkers();
SkString markerString = markerArray.toStringLast();
@@ -2663,7 +2663,7 @@
}
}
-void GrGpuGL::didRemoveGpuTraceMarker() {
+void GrGLGpu::didRemoveGpuTraceMarker() {
if (this->caps()->gpuTracingSupport()) {
GL_CALL(PopGroupMarker());
}
@@ -2671,8 +2671,8 @@
///////////////////////////////////////////////////////////////////////////////
-GrGLAttribArrayState* GrGpuGL::HWGeometryState::bindArrayAndBuffersToDraw(
- GrGpuGL* gpu,
+GrGLAttribArrayState* GrGLGpu::HWGeometryState::bindArrayAndBuffersToDraw(
+ GrGLGpu* gpu,
const GrGLVertexBuffer* vbuffer,
const GrGLIndexBuffer* ibuffer) {
SkASSERT(vbuffer);
diff --git a/src/gpu/gl/GrGpuGL.h b/src/gpu/gl/GrGpuGL.h
index 76995b9..9e892f8 100644
--- a/src/gpu/gl/GrGpuGL.h
+++ b/src/gpu/gl/GrGpuGL.h
@@ -27,10 +27,10 @@
#define PROGRAM_CACHE_STATS
#endif
-class GrGpuGL : public GrGpu {
+class GrGLGpu : public GrGpu {
public:
- GrGpuGL(const GrGLContext& ctx, GrContext* context);
- virtual ~GrGpuGL();
+ GrGLGpu(const GrGLContext& ctx, GrContext* context);
+ virtual ~GrGLGpu();
virtual void contextAbandoned() SK_OVERRIDE;
@@ -180,7 +180,7 @@
class ProgramCache : public ::SkNoncopyable {
public:
- ProgramCache(GrGpuGL* gpu);
+ ProgramCache(GrGLGpu* gpu);
~ProgramCache();
void abandon();
@@ -210,7 +210,7 @@
int fCount;
unsigned int fCurrLRUStamp;
- GrGpuGL* fGpu;
+ GrGLGpu* fGpu;
#ifdef PROGRAM_CACHE_STATS
int fTotalRequests;
int fCacheMisses;
@@ -332,7 +332,7 @@
}
}
- void setVertexArrayID(GrGpuGL* gpu, GrGLuint arrayID) {
+ void setVertexArrayID(GrGLGpu* gpu, GrGLuint arrayID) {
if (!gpu->glCaps().vertexArrayObjectSupport()) {
SkASSERT(0 == arrayID);
return;
@@ -364,7 +364,7 @@
}
}
- void setVertexBufferID(GrGpuGL* gpu, GrGLuint id) {
+ void setVertexBufferID(GrGLGpu* gpu, GrGLuint id) {
if (!fBoundVertexBufferIDIsValid || id != fBoundVertexBufferID) {
GR_GL_CALL(gpu->glInterface(), BindBuffer(GR_GL_ARRAY_BUFFER, id));
fBoundVertexBufferIDIsValid = true;
@@ -376,7 +376,7 @@
* Binds the default vertex array and binds the index buffer. This is used when binding
* an index buffer in order to update it.
*/
- void setIndexBufferIDOnDefaultVertexArray(GrGpuGL* gpu, GrGLuint id) {
+ void setIndexBufferIDOnDefaultVertexArray(GrGLGpu* gpu, GrGLuint id) {
this->setVertexArrayID(gpu, 0);
if (!fDefaultVertexArrayBoundIndexBufferIDIsValid ||
id != fDefaultVertexArrayBoundIndexBufferID) {
@@ -392,7 +392,7 @@
* buffer is bound. The index buffer (if non-NULL) is bound to the vertex array. The
* returned GrGLAttribArrayState should be used to set vertex attribute arrays.
*/
- GrGLAttribArrayState* bindArrayAndBuffersToDraw(GrGpuGL* gpu,
+ GrGLAttribArrayState* bindArrayAndBuffersToDraw(GrGLGpu* gpu,
const GrGLVertexBuffer* vbuffer,
const GrGLIndexBuffer* ibuffer);
diff --git a/src/gpu/gl/GrGpuGL_program.cpp b/src/gpu/gl/GrGpuGL_program.cpp
index f094ee9..1a04341 100644
--- a/src/gpu/gl/GrGpuGL_program.cpp
+++ b/src/gpu/gl/GrGpuGL_program.cpp
@@ -22,7 +22,7 @@
typedef GrGLProgramDataManager::UniformHandle UniformHandle;
-struct GrGpuGL::ProgramCache::Entry {
+struct GrGLGpu::ProgramCache::Entry {
SK_DECLARE_INST_COUNT_ROOT(Entry);
Entry() : fProgram(NULL), fLRUStamp(0) {}
@@ -30,7 +30,7 @@
unsigned int fLRUStamp;
};
-struct GrGpuGL::ProgramCache::ProgDescLess {
+struct GrGLGpu::ProgramCache::ProgDescLess {
bool operator() (const GrProgramDesc& desc, const Entry* entry) {
SkASSERT(entry->fProgram.get());
return GrProgramDesc::Less(desc, entry->fProgram->getDesc());
@@ -42,7 +42,7 @@
}
};
-GrGpuGL::ProgramCache::ProgramCache(GrGpuGL* gpu)
+GrGLGpu::ProgramCache::ProgramCache(GrGLGpu* gpu)
: fCount(0)
, fCurrLRUStamp(0)
, fGpu(gpu)
@@ -57,7 +57,7 @@
}
}
-GrGpuGL::ProgramCache::~ProgramCache() {
+GrGLGpu::ProgramCache::~ProgramCache() {
for (int i = 0; i < fCount; ++i){
SkDELETE(fEntries[i]);
}
@@ -77,7 +77,7 @@
#endif
}
-void GrGpuGL::ProgramCache::abandon() {
+void GrGLGpu::ProgramCache::abandon() {
for (int i = 0; i < fCount; ++i) {
SkASSERT(fEntries[i]->fProgram.get());
fEntries[i]->fProgram->abandon();
@@ -86,12 +86,12 @@
fCount = 0;
}
-int GrGpuGL::ProgramCache::search(const GrProgramDesc& desc) const {
+int GrGLGpu::ProgramCache::search(const GrProgramDesc& desc) const {
ProgDescLess less;
return SkTSearch(fEntries, fCount, desc, sizeof(Entry*), less);
}
-GrGLProgram* GrGpuGL::ProgramCache::getProgram(const GrOptDrawState& optState) {
+GrGLProgram* GrGLGpu::ProgramCache::getProgram(const GrOptDrawState& optState) {
#ifdef PROGRAM_CACHE_STATS
++fTotalRequests;
#endif
diff --git a/src/gpu/gl/builders/GrGLFragmentShaderBuilder.cpp b/src/gpu/gl/builders/GrGLFragmentShaderBuilder.cpp
index b6daca7..7f21fbd 100644
--- a/src/gpu/gl/builders/GrGLFragmentShaderBuilder.cpp
+++ b/src/gpu/gl/builders/GrGLFragmentShaderBuilder.cpp
@@ -79,7 +79,7 @@
bool GrGLFragmentShaderBuilder::enableFeature(GLSLFeature feature) {
switch (feature) {
case kStandardDerivatives_GLSLFeature: {
- GrGpuGL* gpu = fProgramBuilder->gpu();
+ GrGLGpu* gpu = fProgramBuilder->gpu();
if (!gpu->glCaps().shaderDerivativeSupport()) {
return false;
}
@@ -115,7 +115,7 @@
const char* GrGLFragmentShaderBuilder::fragmentPosition() {
fHasReadFragmentPosition = true;
- GrGpuGL* gpu = fProgramBuilder->gpu();
+ GrGLGpu* gpu = fProgramBuilder->gpu();
// We only declare "gl_FragCoord" when we're in the case where we want to use layout qualifiers
// to reverse y. Otherwise it isn't necessary and whether the "in" qualifier appears in the
// declaration varies in earlier GLSL specs. So it is simpler to omit it.
@@ -166,7 +166,7 @@
const char* GrGLFragmentShaderBuilder::dstColor() {
fHasReadDstColor = true;
- GrGpuGL* gpu = fProgramBuilder->gpu();
+ GrGLGpu* gpu = fProgramBuilder->gpu();
if (gpu->glCaps().fbFetchSupport()) {
this->addFeature(1 << (GrGLFragmentShaderBuilder::kLastGLSLPrivateFeature + 1),
gpu->glCaps().fbFetchExtensionString());
@@ -258,7 +258,7 @@
bool GrGLFragmentShaderBuilder::compileAndAttachShaders(GrGLuint programId,
SkTDArray<GrGLuint>* shaderIds) const {
- GrGpuGL* gpu = fProgramBuilder->gpu();
+ GrGLGpu* gpu = fProgramBuilder->gpu();
SkString fragShaderSrc(GrGetGLSLVersionDecl(gpu->ctxInfo()));
fragShaderSrc.append(fExtensions);
append_default_precision_qualifier(kDefault_GrSLPrecision,
diff --git a/src/gpu/gl/builders/GrGLLegacyNvprProgramBuilder.cpp b/src/gpu/gl/builders/GrGLLegacyNvprProgramBuilder.cpp
index 696c9a5..eeb9974 100644
--- a/src/gpu/gl/builders/GrGLLegacyNvprProgramBuilder.cpp
+++ b/src/gpu/gl/builders/GrGLLegacyNvprProgramBuilder.cpp
@@ -8,7 +8,7 @@
#include "GrGLLegacyNvprProgramBuilder.h"
#include "../GrGpuGL.h"
-GrGLLegacyNvprProgramBuilder::GrGLLegacyNvprProgramBuilder(GrGpuGL* gpu,
+GrGLLegacyNvprProgramBuilder::GrGLLegacyNvprProgramBuilder(GrGLGpu* gpu,
const GrOptDrawState& optState)
: INHERITED(gpu, optState)
, fTexCoordSetCnt(0) {
diff --git a/src/gpu/gl/builders/GrGLLegacyNvprProgramBuilder.h b/src/gpu/gl/builders/GrGLLegacyNvprProgramBuilder.h
index 7f7b0fc..f34f6cc 100644
--- a/src/gpu/gl/builders/GrGLLegacyNvprProgramBuilder.h
+++ b/src/gpu/gl/builders/GrGLLegacyNvprProgramBuilder.h
@@ -12,7 +12,7 @@
class GrGLLegacyNvprProgramBuilder : public GrGLProgramBuilder {
public:
- GrGLLegacyNvprProgramBuilder(GrGpuGL*, const GrOptDrawState&);
+ GrGLLegacyNvprProgramBuilder(GrGLGpu*, const GrOptDrawState&);
virtual GrGLProgram* createProgram(GrGLuint programID) SK_OVERRIDE;
diff --git a/src/gpu/gl/builders/GrGLNvprProgramBuilder.cpp b/src/gpu/gl/builders/GrGLNvprProgramBuilder.cpp
index 063526d..b835306 100644
--- a/src/gpu/gl/builders/GrGLNvprProgramBuilder.cpp
+++ b/src/gpu/gl/builders/GrGLNvprProgramBuilder.cpp
@@ -11,7 +11,7 @@
#define GL_CALL(X) GR_GL_CALL(this->gpu()->glInterface(), X)
#define GL_CALL_RET(R, X) GR_GL_CALL_RET(this->gpu()->glInterface(), R, X)
-GrGLNvprProgramBuilder::GrGLNvprProgramBuilder(GrGpuGL* gpu,
+GrGLNvprProgramBuilder::GrGLNvprProgramBuilder(GrGLGpu* gpu,
const GrOptDrawState& optState)
: INHERITED(gpu, optState)
, fSeparableVaryingInfos(kVarsPerBlock) {
diff --git a/src/gpu/gl/builders/GrGLNvprProgramBuilder.h b/src/gpu/gl/builders/GrGLNvprProgramBuilder.h
index 5f23905..cfb07fd 100644
--- a/src/gpu/gl/builders/GrGLNvprProgramBuilder.h
+++ b/src/gpu/gl/builders/GrGLNvprProgramBuilder.h
@@ -12,7 +12,7 @@
class GrGLNvprProgramBuilder : public GrGLProgramBuilder {
public:
- GrGLNvprProgramBuilder(GrGpuGL*, const GrOptDrawState&);
+ GrGLNvprProgramBuilder(GrGLGpu*, const GrOptDrawState&);
/*
* The separable varying info must be passed to GrGLProgram so this must
diff --git a/src/gpu/gl/builders/GrGLProgramBuilder.cpp b/src/gpu/gl/builders/GrGLProgramBuilder.cpp
index bbae592..6f3214f 100644
--- a/src/gpu/gl/builders/GrGLProgramBuilder.cpp
+++ b/src/gpu/gl/builders/GrGLProgramBuilder.cpp
@@ -26,7 +26,7 @@
const int GrGLProgramBuilder::kVarsPerBlock = 8;
-GrGLProgram* GrGLProgramBuilder::CreateProgram(const GrOptDrawState& optState, GrGpuGL* gpu) {
+GrGLProgram* GrGLProgramBuilder::CreateProgram(const GrOptDrawState& optState, GrGLGpu* gpu) {
// create a builder. This will be handed off to effects so they can use it to add
// uniforms, varyings, textures, etc
SkAutoTDelete<GrGLProgramBuilder> builder(CreateProgramBuilder(optState,
@@ -54,7 +54,7 @@
GrGLProgramBuilder* GrGLProgramBuilder::CreateProgramBuilder(const GrOptDrawState& optState,
bool hasGeometryProcessor,
- GrGpuGL* gpu) {
+ GrGLGpu* gpu) {
const GrProgramDesc& desc = optState.programDesc();
if (GrGLProgramDescBuilder::GetHeader(desc).fUseNvpr) {
SkASSERT(gpu->glCaps().pathRenderingSupport());
@@ -72,7 +72,7 @@
/////////////////////////////////////////////////////////////////////////////
-GrGLProgramBuilder::GrGLProgramBuilder(GrGpuGL* gpu, const GrOptDrawState& optState)
+GrGLProgramBuilder::GrGLProgramBuilder(GrGLGpu* gpu, const GrOptDrawState& optState)
: fVS(this)
, fGS(this)
, fFS(this, optState.programDesc().header().fFragPosKey)
diff --git a/src/gpu/gl/builders/GrGLProgramBuilder.h b/src/gpu/gl/builders/GrGLProgramBuilder.h
index e4c5f31..3fdccca 100644
--- a/src/gpu/gl/builders/GrGLProgramBuilder.h
+++ b/src/gpu/gl/builders/GrGLProgramBuilder.h
@@ -71,7 +71,7 @@
virtual const GrGLContextInfo& ctxInfo() const = 0;
- virtual GrGpuGL* gpu() const = 0;
+ virtual GrGLGpu* gpu() const = 0;
/*
* *NOTE* NO MEMBERS ALLOWED, MULTIPLE INHERITANCE
@@ -205,7 +205,7 @@
* to be used.
* @return true if generation was successful.
*/
- static GrGLProgram* CreateProgram(const GrOptDrawState&, GrGpuGL*);
+ static GrGLProgram* CreateProgram(const GrOptDrawState&, GrGLGpu*);
UniformHandle addUniformArray(uint32_t visibility,
GrSLType type,
@@ -224,7 +224,7 @@
const GrGLContextInfo& ctxInfo() const SK_OVERRIDE;
- GrGpuGL* gpu() const SK_OVERRIDE { return fGpu; }
+ GrGLGpu* gpu() const SK_OVERRIDE { return fGpu; }
GrGLFPFragmentBuilder* getFragmentShaderBuilder() SK_OVERRIDE { return &fFS; }
GrGLVertexBuilder* getVertexShaderBuilder() SK_OVERRIDE { return &fVS; }
@@ -259,9 +259,9 @@
static GrGLProgramBuilder* CreateProgramBuilder(const GrOptDrawState&,
bool hasGeometryProcessor,
- GrGpuGL*);
+ GrGLGpu*);
- GrGLProgramBuilder(GrGpuGL*, const GrOptDrawState&);
+ GrGLProgramBuilder(GrGLGpu*, const GrOptDrawState&);
const GrOptDrawState& optState() const { return fOptState; }
const GrProgramDesc& desc() const { return fDesc; }
@@ -377,7 +377,7 @@
const GrOptDrawState& fOptState;
const GrProgramDesc& fDesc;
- GrGpuGL* fGpu;
+ GrGLGpu* fGpu;
UniformInfoArray fUniforms;
SkSTArray<16, TransformVarying, true> fCoordVaryings;
diff --git a/src/gpu/gl/builders/GrGLShaderBuilder.cpp b/src/gpu/gl/builders/GrGLShaderBuilder.cpp
index 36d124f..d8dabae 100644
--- a/src/gpu/gl/builders/GrGLShaderBuilder.cpp
+++ b/src/gpu/gl/builders/GrGLShaderBuilder.cpp
@@ -21,7 +21,7 @@
}
}
void append_texture_lookup(SkString* out,
- GrGpuGL* gpu,
+ GrGLGpu* gpu,
const char* samplerName,
const char* coordName,
uint32_t configComponentMask,
diff --git a/src/gpu/gl/builders/GrGLVertexShaderBuilder.cpp b/src/gpu/gl/builders/GrGLVertexShaderBuilder.cpp
index 5f66420..1d97e85 100644
--- a/src/gpu/gl/builders/GrGLVertexShaderBuilder.cpp
+++ b/src/gpu/gl/builders/GrGLVertexShaderBuilder.cpp
@@ -85,7 +85,7 @@
bool GrGLVertexBuilder::compileAndAttachShaders(GrGLuint programId,
SkTDArray<GrGLuint>* shaderIds) const {
- GrGpuGL* gpu = fProgramBuilder->gpu();
+ GrGLGpu* gpu = fProgramBuilder->gpu();
const GrGLContext& glCtx = gpu->glContext();
const GrGLContextInfo& ctxInfo = gpu->ctxInfo();
SkString vertShaderSrc(GrGetGLSLVersionDecl(ctxInfo));