Revert "SkBitmap now really stores SkImageInfo -- config is just a ruse"

src/gpu/GrClipMaskManager.cpp

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrClipMaskManager.h"
 #include "GrAAConvexPathRenderer.h"
@@ skipping 52 matching lines @@
                                    const SkPath& origPath,
                                    const SkStrokeRec& stroke,
                                    bool doAA) {
     GrPathRendererChain::DrawType type = doAA ?
                                          GrPathRendererChain::kColorAntiAlias_DrawType :
                                          GrPathRendererChain::kColor_DrawType;
     // the gpu alpha mask will draw the inverse paths as non-inverse to a temp buffer
     SkPath::FillType fillType = SkPath::ConvertToNonInverseFillType(origPath.getFillType());
 
     // the 'false' parameter disallows use of the SW path renderer
-    GrPathRenderer::AutoClearPath acp(context->getPathRenderer(origPath, stroke, gpu,
+    GrPathRenderer::AutoClearPath acp(context->getPathRenderer(origPath, stroke, gpu, 
                                                                false, type, fillType));
     return NULL == acp.renderer();
 }
 
 /*
  * This method traverses the clip stack to see if the GrSoftwarePathRenderer
  * will be used on any element. If so, it returns true to indicate that the
  * entire clip should be rendered in SW and then uploaded en masse to the gpu.
  */
 bool GrClipMaskManager::useSWOnlyPath(const ElementList& elements) {
@@ skipping 219 matching lines @@
         default:
             SkASSERT(false);
             break;
     }
 }
 
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 bool GrClipMaskManager::drawFilledPath(GrTexture* target,
-                                       GrPathRenderer* pathRenderer,
+                                       GrPathRenderer* pathRenderer, 
                                        bool isAA) {
     GrDrawState* drawState = fGpu->drawState();
 
     drawState->setRenderTarget(target->asRenderTarget());
 
     SkStrokeRec stroke(SkStrokeRec::kFill_InitStyle);
     pathRenderer->drawPath(stroke, fGpu, isAA);
     return true;
 }
 
@@ skipping 18 matching lines @@
                 fGpu->drawSimpleRect(element->getRect(), NULL);
             }
             return true;
         case Element::kPath_Type: {
             SkStrokeRec stroke(SkStrokeRec::kFill_InitStyle);
             GrPathRendererChain::DrawType type;
             type = element->isAA() ? GrPathRendererChain::kColorAntiAlias_DrawType :
                                      GrPathRendererChain::kColor_DrawType;
             SkPath::FillType fillType = element->getPath().getFillType();
             GrPathRenderer::AutoClearPath acp(this->getContext()->getPathRenderer(
-                                                  element->getPath(),
+                                                  element->getPath(), 
                                                   stroke, fGpu, false, type,
                                                   SkPath::ConvertToNonInverseFillType(fillType)));
             if (NULL == acp.renderer()) {
                 return false;
             }
             acp->drawPath(stroke, fGpu, element->isAA());
             break;
         }
         default:
             // something is wrong if we're trying to draw an empty element.
@@ skipping 11 matching lines @@
 
     switch (element->getType()) {
         case Element::kRect_Type:
             return true;
         case Element::kPath_Type: {
             SkStrokeRec stroke(SkStrokeRec::kFill_InitStyle);
             GrPathRendererChain::DrawType type = element->isAA() ?
                 GrPathRendererChain::kStencilAndColorAntiAlias_DrawType :
                 GrPathRendererChain::kStencilAndColor_DrawType;
             SkPath::FillType fillType = element->getPath().getFillType();
-            acp->set(this->getContext()->getPathRenderer(element->getPath(),
+            acp->set(this->getContext()->getPathRenderer(element->getPath(), 
                                                    stroke, fGpu, false, type,
-                                                   SkPath::ConvertToNonInverseFillType(fillType)));
+                                                   SkPath::ConvertToNonInverseFillType(fillType)));   
             return NULL != acp->renderer();
         }
         default:
             // something is wrong if we're trying to draw an empty element.
             GrCrash("Unexpected element type");
             return false;
     }
 }
 
 void GrClipMaskManager::mergeMask(GrTexture* dstMask,
@@ skipping 687 matching lines @@
 
     // TODO: dynamically attach a stencil buffer
     int stencilBits = 0;
     GrStencilBuffer* stencilBuffer =
         drawState.getRenderTarget()->getStencilBuffer();
     if (NULL != stencilBuffer) {
         stencilBits = stencilBuffer->bits();
         this->adjustStencilParams(settings, clipMode, stencilBits);
     }
 }