Whitespace change.

src/core/SkBitmapProcShader.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 "SkBitmapProcShader.h"
 #include "SkBitmapProcState.h"
 #include "SkBitmapProvider.h"
@@ skipping 162 matching lines @@
         SkXfermode::Mode mode;
         if (!SkXfermode::AsMode(state->fXfer, &mode)) { return false; }
 
         // Need to ensure that our pipeline is created at a 16byte aligned address
         fBlitterPipeline = (SkLinearBitmapPipeline*)SkAlign16((intptr_t)fBlitterStorage);
         if (SkLinearBitmapPipeline::ClonePipelineForBlitting(
             fBlitterPipeline, *fShaderPipeline,
             fMatrixTypeMask,
             fXMode, fYMode,
             fFilterQuality, fSrcPixmap,
-            fAlpha, mode, dstInfo)) {
-
+            fAlpha, mode, dstInfo))
+        {
             state->fStorage[0] = fBlitterPipeline;
             state->fBlitBW = &LinearPipelineContext::ForwardToPipeline;
 
             return true;
         }
 
         // Did not successfully create a pipeline so don't destruct it.
         fBlitterPipeline = nullptr;
         return false;
     }
@@ skipping 30 matching lines @@
 static bool choose_linear_pipeline(const SkShader::ContextRec& rec, const SkImageInfo& srcInfo) {
     // These src attributes are not supported in the new 4f context (yet)
     //
     if (srcInfo.colorType() != kRGBA_8888_SkColorType
         && srcInfo.colorType() != kBGRA_8888_SkColorType
         && srcInfo.colorType() != kIndex_8_SkColorType
         && srcInfo.colorType() != kRGBA_F16_SkColorType) {
         return false;
     }
 
-#if 0   // later we may opt-in to the new code even if the client hasn't requested it...
-    // These src attributes are only supported in the new 4f context
-    //
-    if (srcInfo.isSRGB() ||
-        kUnpremul_SkAlphaType == srcInfo.alphaType() ||
-        (4 == srcInfo.bytesPerPixel() && kN32_SkColorType != srcInfo.colorType()))
-    {
-        return true;
-    }
-#endif
-
     // If we get here, we can reasonably use either context, respect the caller's preference
     //
     return SkShader::ContextRec::kPM4f_DstType == rec.fPreferredDstType;
 }
 
 size_t SkBitmapProcShader::ContextSize(const ContextRec& rec, const SkImageInfo& srcInfo) {
     size_t size0 = sizeof(BitmapProcShaderContext) + sizeof(SkBitmapProcState);
     size_t size1 = sizeof(LinearPipelineContext) + sizeof(SkBitmapProcInfo);
     return SkTMax(size0, size1);
 }
 
 SkShader::Context* SkBitmapProcShader::MakeContext(const SkShader& shader,
                                                    TileMode tmx, TileMode tmy,
                                                    const SkBitmapProvider& provider,
                                                    const ContextRec& rec, void* storage) {
     SkMatrix totalInverse;
     // Do this first, so we know the matrix can be inverted.
     if (!shader.computeTotalInverse(rec, &totalInverse)) {
         return nullptr;
     }
 
     // Decide if we can/want to use the new linear pipeline
     bool useLinearPipeline = choose_linear_pipeline(rec, provider.info());
 
-    //
-    // For now, only enable locally since we are hitting some crashers on the test bots
-    //
-    //useLinearPipeline = false;
-
     if (useLinearPipeline) {
         void* infoStorage = (char*)storage + sizeof(LinearPipelineContext);
         SkBitmapProcInfo* info = new (infoStorage) SkBitmapProcInfo(provider, tmx, tmy);
         if (!info->init(totalInverse, *rec.fPaint)) {
             info->~SkBitmapProcInfo();
             return nullptr;
         }
         if (info->fPixmap.colorType() != kRGBA_8888_SkColorType
             && info->fPixmap.colorType() != kBGRA_8888_SkColorType
             && info->fPixmap.colorType() != kIndex_8_SkColorType
@@ skipping 220 matching lines @@
         inner.reset(GrSimpleTextureEffect::Create(texture, matrix, params));
     }
 
     if (kAlpha_8_SkColorType == fRawBitmap.colorType()) {
         return GrFragmentProcessor::MulOutputByInputUnpremulColor(inner);
     }
     return GrFragmentProcessor::MulOutputByInputAlpha(inner);
 }
 
 #endif