SK_SUPPORT_LEGACY_GRTYPES to hide duplicate types from SkTypes.h

src/gpu/GrInOrderDrawBuffer.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 "GrInOrderDrawBuffer.h"
 
 #include "GrBufferAllocPool.h"
@@ skipping 44 matching lines @@
     fDstGpu->unref();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 namespace {
 void get_vertex_bounds(const void* vertices,
                        size_t vertexSize,
                        int vertexCount,
                        SkRect* bounds) {
-    SkASSERT(vertexSize >= sizeof(GrPoint));
+    SkASSERT(vertexSize >= sizeof(SkPoint));
     SkASSERT(vertexCount > 0);
-    const GrPoint* point = static_cast<const GrPoint*>(vertices);
+    const SkPoint* point = static_cast<const SkPoint*>(vertices);
     bounds->fLeft = bounds->fRight = point->fX;
     bounds->fTop = bounds->fBottom = point->fY;
     for (int i = 1; i < vertexCount; ++i) {
-        point = reinterpret_cast<GrPoint*>(reinterpret_cast<intptr_t>(point) + vertexSize);
+        point = reinterpret_cast<SkPoint*>(reinterpret_cast<intptr_t>(point) + vertexSize);
         bounds->growToInclude(point->fX, point->fY);
     }
 }
 }
 
 
 namespace {
 
 extern const GrVertexAttrib kRectPosColorUVAttribs[] = {
     {kVec2f_GrVertexAttribType,  0,               kPosition_GrVertexAttribBinding},
-    {kVec4ub_GrVertexAttribType, sizeof(GrPoint), kColor_GrVertexAttribBinding},
-    {kVec2f_GrVertexAttribType,  sizeof(GrPoint)+sizeof(GrColor),
+    {kVec4ub_GrVertexAttribType, sizeof(SkPoint), kColor_GrVertexAttribBinding},
+    {kVec2f_GrVertexAttribType,  sizeof(SkPoint)+sizeof(GrColor),
                                                   kLocalCoord_GrVertexAttribBinding},
 };
 
 extern const GrVertexAttrib kRectPosUVAttribs[] = {
     {kVec2f_GrVertexAttribType,  0,              kPosition_GrVertexAttribBinding},
-    {kVec2f_GrVertexAttribType, sizeof(GrPoint), kLocalCoord_GrVertexAttribBinding},
+    {kVec2f_GrVertexAttribType, sizeof(SkPoint), kLocalCoord_GrVertexAttribBinding},
 };
 
 static void set_vertex_attributes(GrDrawState* drawState,
                                   bool hasColor, bool hasUVs,
                                   int* colorOffset, int* localOffset) {
     *colorOffset = -1;
     *localOffset = -1;
 
     // Using per-vertex colors allows batching across colors. (A lot of rects in a row differing
     // only in color is a common occurrence in tables). However, having per-vertex colors disables
     // blending optimizations because we don't know if the color will be solid or not. These
     // optimizations help determine whether coverage and color can be blended correctly when
     // dual-source blending isn't available. This comes into play when there is coverage. If colors
     // were a stage it could take a hint that every vertex's color will be opaque.
     if (hasColor && hasUVs) {
-        *colorOffset = sizeof(GrPoint);
-        *localOffset = sizeof(GrPoint) + sizeof(GrColor);
+        *colorOffset = sizeof(SkPoint);
+        *localOffset = sizeof(SkPoint) + sizeof(GrColor);
         drawState->setVertexAttribs<kRectPosColorUVAttribs>(3);
     } else if (hasColor) {
-        *colorOffset = sizeof(GrPoint);
+        *colorOffset = sizeof(SkPoint);
         drawState->setVertexAttribs<kRectPosColorUVAttribs>(2);
     } else if (hasUVs) {
-        *localOffset = sizeof(GrPoint);
+        *localOffset = sizeof(SkPoint);
         drawState->setVertexAttribs<kRectPosUVAttribs>(2);
     } else {
         drawState->setVertexAttribs<kRectPosUVAttribs>(1);
     }
 }
 
 };
 
 enum {
     kTraceCmdBit = 0x80,
@@ skipping 62 matching lines @@
 
     geo.positions()->setRectFan(rect.fLeft, rect.fTop, rect.fRight, rect.fBottom, vsize);
     combinedMatrix.mapPointsWithStride(geo.positions(), vsize, 4);
 
     SkRect devBounds;
     // since we already computed the dev verts, set the bounds hint. This will help us avoid
     // unnecessary clipping in our onDraw().
     get_vertex_bounds(geo.vertices(), vsize, 4, &devBounds);
 
     if (localOffset >= 0) {
-        GrPoint* coords = GrTCast<GrPoint*>(GrTCast<intptr_t>(geo.vertices()) + localOffset);
+        SkPoint* coords = GrTCast<SkPoint*>(GrTCast<intptr_t>(geo.vertices()) + localOffset);
         coords->setRectFan(localRect->fLeft, localRect->fTop,
                            localRect->fRight, localRect->fBottom,
                             vsize);
         if (NULL != localMatrix) {
             localMatrix->mapPointsWithStride(coords, vsize, 4);
         }
     }
 
     if (colorOffset >= 0) {
         GrColor* vertColor = GrTCast<GrColor*>(GrTCast<intptr_t>(geo.vertices()) + colorOffset);
@@ skipping 87 matching lines @@
     int adjustedStartVertex = poolState.fPoolStartVertex + info.startVertex();
     if (draw->startVertex() + draw->vertexCount() != adjustedStartVertex) {
         return 0;
     }
 
     SkASSERT(poolState.fPoolStartVertex == draw->startVertex() + draw->vertexCount());
 
     // how many instances can be concat'ed onto draw given the size of the index buffer
     int instancesToConcat = this->indexCountInCurrentSource() / info.indicesPerInstance();
     instancesToConcat -= draw->instanceCount();
-    instancesToConcat = GrMin(instancesToConcat, info.instanceCount());
+    instancesToConcat = SkTMin(instancesToConcat, info.instanceCount());
 
     // update the amount of reserved vertex data actually referenced in draws
     size_t vertexBytes = instancesToConcat * info.verticesPerInstance() *
                          drawState.getVertexSize();
-    poolState.fUsedPoolVertexBytes = GrMax(poolState.fUsedPoolVertexBytes, vertexBytes);
+    poolState.fUsedPoolVertexBytes = SkTMax(poolState.fUsedPoolVertexBytes, vertexBytes);
 
     draw->adjustInstanceCount(instancesToConcat);
 
     // update last fGpuCmdMarkers to include any additional trace markers that have been added
     if (this->getActiveTraceMarkers().count() > 0) {
         if (cmd_has_trace_marker(fCmds.back())) {
             fGpuCmdMarkers.back().addSet(this->getActiveTraceMarkers());
         } else {
             fGpuCmdMarkers.push_back(this->getActiveTraceMarkers());
             fCmds.back() = add_trace_bit(fCmds.back());
@@ skipping 54 matching lines @@
     }
 
     switch (this->getGeomSrc().fVertexSrc) {
         case kBuffer_GeometrySrcType:
             draw->fVertexBuffer = this->getGeomSrc().fVertexBuffer;
             break;
         case kReserved_GeometrySrcType: // fallthrough
         case kArray_GeometrySrcType: {
             size_t vertexBytes = (info.vertexCount() + info.startVertex()) *
                                  drawState.getVertexSize();
-            poolState.fUsedPoolVertexBytes = GrMax(poolState.fUsedPoolVertexBytes, vertexBytes);
+            poolState.fUsedPoolVertexBytes = SkTMax(poolState.fUsedPoolVertexBytes, vertexBytes);
             draw->fVertexBuffer = poolState.fPoolVertexBuffer;
             draw->adjustStartVertex(poolState.fPoolStartVertex);
             break;
         }
         default:
             GrCrash("unknown geom src type");
     }
     draw->fVertexBuffer->ref();
 
     if (info.isIndexed()) {
         switch (this->getGeomSrc().fIndexSrc) {
             case kBuffer_GeometrySrcType:
                 draw->fIndexBuffer = this->getGeomSrc().fIndexBuffer;
                 break;
             case kReserved_GeometrySrcType: // fallthrough
             case kArray_GeometrySrcType: {
                 size_t indexBytes = (info.indexCount() + info.startIndex()) * sizeof(uint16_t);
-                poolState.fUsedPoolIndexBytes = GrMax(poolState.fUsedPoolIndexBytes, indexBytes);
+                poolState.fUsedPoolIndexBytes = SkTMax(poolState.fUsedPoolIndexBytes, indexBytes);
                 draw->fIndexBuffer = poolState.fPoolIndexBuffer;
                 draw->adjustStartIndex(poolState.fPoolStartIndex);
                 break;
             }
             default:
                 GrCrash("unknown geom src type");
         }
         draw->fIndexBuffer->ref();
     } else {
         draw->fIndexBuffer = NULL;
@@ skipping 551 matching lines @@
     this->addToCmdBuffer(kCopySurface_Cmd);
     return &fCopySurfaces.push_back();
 }
 
 
 void GrInOrderDrawBuffer::clipWillBeSet(const GrClipData* newClipData) {
     INHERITED::clipWillBeSet(newClipData);
     fClipSet = true;
     fClipProxyState = kUnknown_ClipProxyState;
 }