rename blitrow::proc and add (uncalled) hook for colorproc16

src/core/SkBlitter_RGB16.cpp

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkBlitRow.h"
@@ skipping 104 matching lines @@
 public:
     SkRGB16_Shader_Blitter(const SkBitmap& device, const SkPaint& paint,
                            SkShader::Context* shaderContext);
     virtual ~SkRGB16_Shader_Blitter();
     void blitH(int x, int y, int width) SK_OVERRIDE;
     virtual void blitAntiH(int x, int y, const SkAlpha* antialias,
                            const int16_t* runs) SK_OVERRIDE;
     void blitRect(int x, int y, int width, int height) SK_OVERRIDE;
 
 protected:
-    SkPMColor*      fBuffer;
-    SkBlitRow::Proc fOpaqueProc;
-    SkBlitRow::Proc fAlphaProc;
+    SkPMColor*          fBuffer;
+    SkBlitRow::Proc16   fOpaqueProc;
+    SkBlitRow::Proc16   fAlphaProc;
 
 private:
     // illegal
     SkRGB16_Shader_Blitter& operator=(const SkRGB16_Shader_Blitter&);
 
     typedef SkShaderBlitter INHERITED;
 };
 
 // used only if the shader can perform shadSpan16
 class SkRGB16_Shader16_Blitter : public SkRGB16_Shader_Blitter {
@@ skipping 691 matching lines @@
     uint32_t shaderFlags = fShaderFlags;
     // shaders take care of global alpha, so we never set it in SkBlitRow
     if (!(shaderFlags & SkShader::kOpaqueAlpha_Flag)) {
         flags |= SkBlitRow::kSrcPixelAlpha_Flag;
     }
     // don't dither if the shader is really 16bit
     if (paint.isDither() && !(shaderFlags & SkShader::kIntrinsicly16_Flag)) {
         flags |= SkBlitRow::kDither_Flag;
     }
     // used when we know our global alpha is 0xFF
-    fOpaqueProc = SkBlitRow::Factory(flags, kRGB_565_SkColorType);
+    fOpaqueProc = SkBlitRow::Factory16(flags);
     // used when we know our global alpha is < 0xFF
-    fAlphaProc  = SkBlitRow::Factory(flags | SkBlitRow::kGlobalAlpha_Flag,
-                                     kRGB_565_SkColorType);
+    fAlphaProc  = SkBlitRow::Factory16(flags | SkBlitRow::kGlobalAlpha_Flag);
 }
 
 SkRGB16_Shader_Blitter::~SkRGB16_Shader_Blitter() {
     sk_free(fBuffer);
 }
 
 void SkRGB16_Shader_Blitter::blitH(int x, int y, int width) {
     SkASSERT(x + width <= fDevice.width());
 
     fShaderContext->shadeSpan(x, y, fBuffer, width);
     // shaders take care of global alpha, so we pass 0xFF (should be ignored)
     fOpaqueProc(fDevice.getAddr16(x, y), fBuffer, width, 0xFF, x, y);
 }
 
 void SkRGB16_Shader_Blitter::blitRect(int x, int y, int width, int height) {
     SkShader::Context* shaderContext = fShaderContext;
-    SkBlitRow::Proc    proc = fOpaqueProc;
+    SkBlitRow::Proc16  proc = fOpaqueProc;
     SkPMColor*         buffer = fBuffer;
     uint16_t*          dst = fDevice.getAddr16(x, y);
     size_t             dstRB = fDevice.rowBytes();
 
     if (fShaderFlags & SkShader::kConstInY32_Flag) {
         shaderContext->shadeSpan(x, y, buffer, width);
         do {
             proc(dst, buffer, width, 0xFF, x, y);
             y += 1;
             dst = (uint16_t*)((char*)dst + dstRB);
@@ skipping 43 matching lines @@
             continue;
         }
 
         int nonZeroCount = count + count_nonzero_span(runs + count, antialias + count);
 
         SkASSERT(nonZeroCount <= fDevice.width()); // don't overrun fBuffer
         shaderContext->shadeSpan(x, y, span, nonZeroCount);
 
         SkPMColor* localSpan = span;
         for (;;) {
-            SkBlitRow::Proc proc = (aa == 0xFF) ? fOpaqueProc : fAlphaProc;
+            SkBlitRow::Proc16 proc = (aa == 0xFF) ? fOpaqueProc : fAlphaProc;
             proc(device, localSpan, count, aa, x, y);
 
             x += count;
             device += count;
             runs += count;
             antialias += count;
             nonZeroCount -= count;
             if (nonZeroCount == 0) {
                 break;
             }
@@ skipping 126 matching lines @@
 #endif
         } else if (0xFF == SkColorGetA(color)) {
             blitter = allocator->createT<SkRGB16_Opaque_Blitter>(device, paint);
         } else {
             blitter = allocator->createT<SkRGB16_Blitter>(device, paint);
         }
     }
 
     return blitter;
 }