remove drawtype

src/gpu/gl/GrGLGpu.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 "GrGLGpu.h"
 #include "GrGLStencilBuffer.h"
@@ skipping 1318 matching lines @@
                 fHWScissorSettings.fEnabled = kYes_TriState;
             }
             return;
         }
     }
 
     // See fall through note above
     this->disableScissor();
 }
 
-bool GrGLGpu::flushGLState(const DrawArgs& args) {
+bool GrGLGpu::flushGLState(const DrawArgs& args, bool isLineDraw) {
     GrXferProcessor::BlendInfo blendInfo;
     const GrOptDrawState& optState = *args.fOptState;
     args.fOptState->getXferProcessor()->getBlendInfo(&blendInfo);
 
     this->flushDither(optState.isDitherState());
     this->flushColorWrite(blendInfo.fWriteColor);
     this->flushDrawFace(optState.getDrawFace());
 
     fCurrentProgram.reset(fProgramCache->getProgram(args));
     if (NULL == fCurrentProgram.get()) {
@@ skipping 11 matching lines @@
 
     if (blendInfo.fWriteColor) {
         this->flushBlend(blendInfo);
     }
 
     fCurrentProgram->setData(*args.fPrimitiveProcessor, optState, *args.fBatchTracker);
 
     GrGLRenderTarget* glRT = static_cast<GrGLRenderTarget*>(optState.getRenderTarget());
     this->flushStencil(optState.getStencil());
     this->flushScissor(optState.getScissorState(), glRT->getViewport(), glRT->origin());
-    this->flushHWAAState(glRT, optState.isHWAntialiasState(),
-                         kDrawLines_DrawType == args.fDrawType);
+    this->flushHWAAState(glRT, optState.isHWAntialiasState(), isLineDraw);
 
     // This must come after textures are flushed because a texture may need
     // to be msaa-resolved (which will modify bound FBO state).
     this->flushRenderTarget(glRT, NULL);
 
     return true;
 }
 
 void GrGLGpu::setupGeometry(const GrPrimitiveProcessor& primProc,
                             const GrDrawTarget::DrawInfo& info,
@@ skipping 45 matching lines @@
             offset += attrib.fOffset;
         }
         attribState->disableUnusedArrays(this, usedAttribArraysMask);
     }
 }
 
 void GrGLGpu::buildProgramDesc(GrProgramDesc* desc,
                                const GrPrimitiveProcessor& primProc,
                                const GrOptDrawState& optState,
                                const GrProgramDesc::DescInfo& descInfo,
-                               GrGpu::DrawType drawType,
                                const GrBatchTracker& batchTracker) const {
-    if (!GrGLProgramDescBuilder::Build(desc, primProc, optState, descInfo, drawType, this,
+    if (!GrGLProgramDescBuilder::Build(desc, primProc, optState, descInfo, this,
                                        batchTracker)) {
         SkDEBUGFAIL("Failed to generate GL program descriptor");
     }
 }
 
 void GrGLGpu::disableScissor() {
     if (kNo_TriState != fHWScissorSettings.fEnabled) {
         GL_CALL(Disable(GR_GL_SCISSOR_TEST));
         fHWScissorSettings.fEnabled = kNo_TriState;
         return;
@@ skipping 369 matching lines @@
                 if(wndProcID == procID) {
                     SwapBuffers(GetDC(hwnd));
                 }
                 hwnd = GetNextWindow(hwnd, GW_HWNDNEXT);
             }
          }
     #endif
 #endif
 
 void GrGLGpu::onDraw(const DrawArgs& args, const GrDrawTarget::DrawInfo& info) {
-    if (!this->flushGLState(args)) {
+    if (!this->flushGLState(args, GrIsPrimTypeLines(info.primitiveType()))) {
         return;
     }
 
     size_t indexOffsetInBytes = 0;
     this->setupGeometry(*args.fPrimitiveProcessor, info, &indexOffsetInBytes);
 
     SkASSERT((size_t)info.primitiveType() < SK_ARRAY_COUNT(gPrimitiveType2GLMode));
 
     if (info.isIndexed()) {
         GrGLvoid* indices =
@@ skipping 32 matching lines @@
     this->glPathRendering()->setProjectionMatrix(*state.fViewMatrix, size, rt->origin());
     this->flushScissor(*state.fScissor, rt->getViewport(), rt->origin());
     this->flushHWAAState(rt, state.fUseHWAA, false);
     this->flushRenderTarget(rt, NULL);
 
     fPathRendering->stencilPath(path, *state.fStencil);
 }
 
 void GrGLGpu::onDrawPath(const DrawArgs& args, const GrPath* path,
                          const GrStencilSettings& stencil) {
-    if (!this->flushGLState(args)) {
+    if (!this->flushGLState(args, false)) {
         return;
     }
     fPathRendering->drawPath(path, stencil);
 }
 
 void GrGLGpu::onDrawPaths(const DrawArgs& args,
                           const GrPathRange* pathRange,
                           const void* indices,
                           GrDrawTarget::PathIndexType indexType,
                           const float transformValues[],
                           GrDrawTarget::PathTransformType transformType,
                            int count,
                            const GrStencilSettings& stencil) {
-    if (!this->flushGLState(args)) {
+    if (!this->flushGLState(args, false)) {
         return;
     }
     fPathRendering->drawPaths(pathRange, indices, indexType, transformValues,
                               transformType, count, stencil);
 }
 
 void GrGLGpu::onResolveRenderTarget(GrRenderTarget* target) {
     GrGLRenderTarget* rt = static_cast<GrGLRenderTarget*>(target);
     if (rt->needsResolve()) {
         // Some extensions automatically resolves the texture when it is read.
@@ skipping 837 matching lines @@
             this->setVertexArrayID(gpu, 0);
         }
         int attrCount = gpu->glCaps().maxVertexAttributes();
         if (fDefaultVertexArrayAttribState.count() != attrCount) {
             fDefaultVertexArrayAttribState.resize(attrCount);
         }
         attribState = &fDefaultVertexArrayAttribState;
     }
     return attribState;
 }