SK_SUPPORT_LEGACY_GRTYPES to hide duplicate types from SkTypes.h

src/gpu/gl/GrGpuGL.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "GrGpuGL.h"
 #include "GrGLStencilBuffer.h"
@@ skipping 63 matching lines @@
         true,
 
         // extended blend coeffs
         false,
         false,
         false,
         false,
     };
     return gCoeffReferencesBlendConst[coeff];
     GR_STATIC_ASSERT(kTotalGrBlendCoeffCount ==
-                     GR_ARRAY_COUNT(gCoeffReferencesBlendConst));
+                     SK_ARRAY_COUNT(gCoeffReferencesBlendConst));
 
     GR_STATIC_ASSERT(0 == kZero_GrBlendCoeff);
     GR_STATIC_ASSERT(1 == kOne_GrBlendCoeff);
     GR_STATIC_ASSERT(2 == kSC_GrBlendCoeff);
     GR_STATIC_ASSERT(3 == kISC_GrBlendCoeff);
     GR_STATIC_ASSERT(4 == kDC_GrBlendCoeff);
     GR_STATIC_ASSERT(5 == kIDC_GrBlendCoeff);
     GR_STATIC_ASSERT(6 == kSA_GrBlendCoeff);
     GR_STATIC_ASSERT(7 == kISA_GrBlendCoeff);
     GR_STATIC_ASSERT(8 == kDA_GrBlendCoeff);
     GR_STATIC_ASSERT(9 == kIDA_GrBlendCoeff);
     GR_STATIC_ASSERT(10 == kConstC_GrBlendCoeff);
     GR_STATIC_ASSERT(11 == kIConstC_GrBlendCoeff);
     GR_STATIC_ASSERT(12 == kConstA_GrBlendCoeff);
     GR_STATIC_ASSERT(13 == kIConstA_GrBlendCoeff);
 
     GR_STATIC_ASSERT(14 == kS2C_GrBlendCoeff);
     GR_STATIC_ASSERT(15 == kIS2C_GrBlendCoeff);
     GR_STATIC_ASSERT(16 == kS2A_GrBlendCoeff);
     GR_STATIC_ASSERT(17 == kIS2A_GrBlendCoeff);
 
     // assertion for gXfermodeCoeff2Blend have to be in GrGpu scope
     GR_STATIC_ASSERT(kTotalGrBlendCoeffCount ==
-                     GR_ARRAY_COUNT(gXfermodeCoeff2Blend));
+                     SK_ARRAY_COUNT(gXfermodeCoeff2Blend));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static bool gPrintStartupSpew;
 
 GrGpuGL::GrGpuGL(const GrGLContext& ctx, GrContext* context)
     : GrGpu(context)
     , fGLContext(ctx) {
 
@@ skipping 753 matching lines @@
     GrGLRenderTarget::Desc  glRTDesc;
 
     // Attempt to catch un- or wrongly initialized sample counts;
     SkASSERT(desc.fSampleCnt >= 0 && desc.fSampleCnt <= 64);
     // We fail if the MSAA was requested and is not available.
     if (GrGLCaps::kNone_MSFBOType == this->glCaps().msFBOType() && desc.fSampleCnt) {
         //GrPrintf("MSAA RT requested but not supported on this platform.");
         return return_null_texture();
     }
     // If the sample count exceeds the max then we clamp it.
-    glTexDesc.fSampleCnt = GrMin(desc.fSampleCnt, this->caps()->maxSampleCount());
+    glTexDesc.fSampleCnt = SkTMin(desc.fSampleCnt, this->caps()->maxSampleCount());
 
     glTexDesc.fFlags  = desc.fFlags;
     glTexDesc.fWidth  = desc.fWidth;
     glTexDesc.fHeight = desc.fHeight;
     glTexDesc.fConfig = desc.fConfig;
     glTexDesc.fIsWrapped = false;
 
     glRTDesc.fMSColorRenderbufferID = 0;
     glRTDesc.fRTFBOID = 0;
     glRTDesc.fTexFBOID = 0;
@@ skipping 679 matching lines @@
                 hwnd = GetNextWindow(hwnd, GW_HWNDNEXT);
             }
          }
     #endif
 #endif
 
 void GrGpuGL::onGpuDraw(const DrawInfo& info) {
     size_t indexOffsetInBytes;
     this->setupGeometry(info, &indexOffsetInBytes);
 
-    SkASSERT((size_t)info.primitiveType() < GR_ARRAY_COUNT(gPrimitiveType2GLMode));
+    SkASSERT((size_t)info.primitiveType() < SK_ARRAY_COUNT(gPrimitiveType2GLMode));
 
     if (info.isIndexed()) {
         GrGLvoid* indices =
             reinterpret_cast<GrGLvoid*>(indexOffsetInBytes + sizeof(uint16_t) * info.startIndex());
         // info.startVertex() was accounted for by setupGeometry.
         GL_CALL(DrawElements(gPrimitiveType2GLMode[info.primitiveType()],
                              info.indexCount(),
                              GR_GL_UNSIGNED_SHORT,
                              indices));
     } else {
@@ skipping 240 matching lines @@
     static const GrGLenum gTable[] = {
         GR_GL_ALWAYS,           // kAlways_StencilFunc
         GR_GL_NEVER,            // kNever_StencilFunc
         GR_GL_GREATER,          // kGreater_StencilFunc
         GR_GL_GEQUAL,           // kGEqual_StencilFunc
         GR_GL_LESS,             // kLess_StencilFunc
         GR_GL_LEQUAL,           // kLEqual_StencilFunc,
         GR_GL_EQUAL,            // kEqual_StencilFunc,
         GR_GL_NOTEQUAL,         // kNotEqual_StencilFunc,
     };
-    GR_STATIC_ASSERT(GR_ARRAY_COUNT(gTable) == kBasicStencilFuncCount);
+    GR_STATIC_ASSERT(SK_ARRAY_COUNT(gTable) == kBasicStencilFuncCount);
     GR_STATIC_ASSERT(0 == kAlways_StencilFunc);
     GR_STATIC_ASSERT(1 == kNever_StencilFunc);
     GR_STATIC_ASSERT(2 == kGreater_StencilFunc);
     GR_STATIC_ASSERT(3 == kGEqual_StencilFunc);
     GR_STATIC_ASSERT(4 == kLess_StencilFunc);
     GR_STATIC_ASSERT(5 == kLEqual_StencilFunc);
     GR_STATIC_ASSERT(6 == kEqual_StencilFunc);
     GR_STATIC_ASSERT(7 == kNotEqual_StencilFunc);
     SkASSERT((unsigned) basicFunc < kBasicStencilFuncCount);
 
     return gTable[basicFunc];
 }
 
 GrGLenum gr_to_gl_stencil_op(GrStencilOp op) {
     static const GrGLenum gTable[] = {
         GR_GL_KEEP,        // kKeep_StencilOp
         GR_GL_REPLACE,     // kReplace_StencilOp
         GR_GL_INCR_WRAP,   // kIncWrap_StencilOp
         GR_GL_INCR,        // kIncClamp_StencilOp
         GR_GL_DECR_WRAP,   // kDecWrap_StencilOp
         GR_GL_DECR,        // kDecClamp_StencilOp
         GR_GL_ZERO,        // kZero_StencilOp
         GR_GL_INVERT,      // kInvert_StencilOp
     };
-    GR_STATIC_ASSERT(GR_ARRAY_COUNT(gTable) == kStencilOpCount);
+    GR_STATIC_ASSERT(SK_ARRAY_COUNT(gTable) == kStencilOpCount);
     GR_STATIC_ASSERT(0 == kKeep_StencilOp);
     GR_STATIC_ASSERT(1 == kReplace_StencilOp);
     GR_STATIC_ASSERT(2 == kIncWrap_StencilOp);
     GR_STATIC_ASSERT(3 == kIncClamp_StencilOp);
     GR_STATIC_ASSERT(4 == kDecWrap_StencilOp);
     GR_STATIC_ASSERT(5 == kDecClamp_StencilOp);
     GR_STATIC_ASSERT(6 == kZero_StencilOp);
     GR_STATIC_ASSERT(7 == kInvert_StencilOp);
     SkASSERT((unsigned) op < kStencilOpCount);
     return gTable[op];
@@ skipping 910 matching lines @@
             this->setVertexArrayID(gpu, 0);
         }
         int attrCount = gpu->glCaps().maxVertexAttributes();
         if (fDefaultVertexArrayAttribState.count() != attrCount) {
             fDefaultVertexArrayAttribState.resize(attrCount);
         }
         attribState = &fDefaultVertexArrayAttribState;
     }
     return attribState;
 }