Work around MSAA/lines issue on Linux bot.

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 1916 matching lines @@
                                fStencilSettings,
                                GR_GL_FRONT_AND_BACK,
                                GrStencilSettings::kFront_Face);
             }
         }
         fHWStencilSettings = fStencilSettings;
     }
 }
 
 void GrGpuGL::flushAAState(DrawType type) {
+// 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.

[robertphillips, 2013/03/19 18:56:05]

I think if we leave the #if 0 code we should have some comment about why it is
there (e.g., re-enable this when ...)

[bsalomon, 2013/03/19 18:56:46]

Will add a comment

+#if 0
+    #define RT_HAS_MSAA rt->isMultisampled()
+#else
+    #define RT_HAS_MSAA (rt->isMultisampled() || kDrawLines_DrawType == type)
+#endif
+
     const GrRenderTarget* rt = this->getDrawState().getRenderTarget();
     if (kDesktop_GrGLBinding == this->glBinding()) {
         // ES doesn't support toggling GL_MULTISAMPLE and doesn't have
         // smooth lines.
         // we prefer smooth lines over multisampled lines
         bool smoothLines = false;
 
         if (kDrawLines_DrawType == type) {
             smoothLines = this->willUseHWAALines();
             if (smoothLines) {
                 if (kYes_TriState != fHWAAState.fSmoothLineEnabled) {
                     GL_CALL(Enable(GR_GL_LINE_SMOOTH));
                     fHWAAState.fSmoothLineEnabled = kYes_TriState;
                     // must disable msaa to use line smoothing
-                    if (rt->isMultisampled() &&
+                    if (RT_HAS_MSAA &&
                         kNo_TriState != fHWAAState.fMSAAEnabled) {
                         GL_CALL(Disable(GR_GL_MULTISAMPLE));
                         fHWAAState.fMSAAEnabled = kNo_TriState;
                     }
                 }
             } else {
                 if (kNo_TriState != fHWAAState.fSmoothLineEnabled) {
                     GL_CALL(Disable(GR_GL_LINE_SMOOTH));
                     fHWAAState.fSmoothLineEnabled = kNo_TriState;
                 }
             }
         }
-        if (!smoothLines && rt->isMultisampled()) {
+        if (!smoothLines && RT_HAS_MSAA) {
             // FIXME: GL_NV_pr doesn't seem to like MSAA disabled. The paths
             // convex hulls of each segment appear to get filled.
             bool enableMSAA = kStencilPath_DrawType == type ||
                               this->getDrawState().isHWAntialiasState();
             if (enableMSAA) {
                 if (kYes_TriState != fHWAAState.fMSAAEnabled) {
                     GL_CALL(Enable(GR_GL_MULTISAMPLE));
                     fHWAAState.fMSAAEnabled = kYes_TriState;
                 }
             } else {
@@ skipping 358 matching lines @@
             this->setVertexArrayID(gpu, 0);
         }
         int attrCount = gpu->glCaps().maxVertexAttributes();
         if (fDefaultVertexArrayAttribState.count() != attrCount) {
             fDefaultVertexArrayAttribState.resize(attrCount);
         }
         attribState = &fDefaultVertexArrayAttribState;
     }
     return attribState;
 }