remove U16 support, just support F16

src/core/SkBlitter_PM4f.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCoreBlitters.h"
 #include "SkColorPriv.h"
 #include "SkShader.h"
@@ skipping 345 matching lines @@
         }
         if (info.isSRGB()) {
             fFlags |= SkXfermode::kDstIsSRGB_D32Flag;
         }
         fProc1 = SkXfermode::GetD32Proc(fXfer, fFlags | SkXfermode::kSrcIsSingle_D32Flag);
         fProcN = SkXfermode::GetD32Proc(fXfer, fFlags);
     }
 
     SkXfermode::LCD32Proc getLCDProc(uint32_t oneOrManyFlag) const {
         uint32_t flags = fFlags & 1;
-        if (!(fFlags & SkXfermode::kDstIsSRGB_D32Flag)) {
-            flags |= SkXfermode::kDstIsLinearInt_LCDFlag;
+        if (fFlags & SkXfermode::kDstIsSRGB_D32Flag) {
+            flags |= SkXfermode::kDstIsSRGB_LCDFlag;
         }
         return SkXfermode::GetLCD32Proc(flags | oneOrManyFlag);
     }
 
     static DstType* WritableAddr(const SkPixmap& device, int x, int y) {
         return device.writable_addr32(x, y);
     }
 };
 
-struct State64 : State4f {
+struct StateF16 : State4f {
     typedef uint64_t    DstType;
 
-    SkXfermode::D64Proc fProc1;
-    SkXfermode::D64Proc fProcN;
+    SkXfermode::F16Proc fProc1;
+    SkXfermode::F16Proc fProcN;
 
-    State64(const SkImageInfo& info, const SkPaint& paint, const SkShader::Context* shaderContext)
+    StateF16(const SkImageInfo& info, const SkPaint& paint, const SkShader::Context* shaderContext)
         : State4f(info, paint, shaderContext)
     {
         if (is_opaque(paint, shaderContext)) {
-            fFlags |= SkXfermode::kSrcIsOpaque_D64Flag;
+            fFlags |= SkXfermode::kSrcIsOpaque_F16Flag;
         }
-        if (kRGBA_F16_SkColorType == info.colorType()) {
-            fFlags |= SkXfermode::kDstIsFloat16_D64Flag;
-        }
-        fProc1 = SkXfermode::GetD64Proc(fXfer, fFlags | SkXfermode::kSrcIsSingle_D64Flag);
-        fProcN = SkXfermode::GetD64Proc(fXfer, fFlags);
+        SkASSERT(kRGBA_F16_SkColorType == info.colorType());
+        fProc1 = SkXfermode::GetF16Proc(fXfer, fFlags | SkXfermode::kSrcIsSingle_F16Flag);
+        fProcN = SkXfermode::GetF16Proc(fXfer, fFlags);
     }
 
-    SkXfermode::LCD64Proc getLCDProc(uint32_t oneOrManyFlag) const {
+    SkXfermode::LCDF16Proc getLCDProc(uint32_t oneOrManyFlag) const {
         uint32_t flags = fFlags & 1;
-        if (!(fFlags & SkXfermode::kDstIsFloat16_D64Flag)) {
-            flags |= SkXfermode::kDstIsLinearInt_LCDFlag;
-        }
-        return SkXfermode::GetLCD64Proc(flags | oneOrManyFlag);
+        return SkXfermode::GetLCDF16Proc(flags | oneOrManyFlag);
     }
 
     static DstType* WritableAddr(const SkPixmap& device, int x, int y) {
         return device.writable_addr64(x, y);
     }
 };
 
 template <typename State> SkBlitter* create(const SkPixmap& device, const SkPaint& paint,
                                             SkShader::Context* shaderContext,
                                             SkTBlitterAllocator* allocator) {
@@ skipping 15 matching lines @@
         return allocator->createT<SkState_Blitter<State>>(device, paint);
     }
 }
 
 SkBlitter* SkBlitter_ARGB32_Create(const SkPixmap& device, const SkPaint& paint,
                                    SkShader::Context* shaderContext,
                                    SkTBlitterAllocator* allocator) {
     return create<State32>(device, paint, shaderContext, allocator);
 }
 
-SkBlitter* SkBlitter_ARGB64_Create(const SkPixmap& device, const SkPaint& paint,
-                                   SkShader::Context* shaderContext,
-                                   SkTBlitterAllocator* allocator) {
-    return create<State64>(device, paint, shaderContext, allocator);
+SkBlitter* SkBlitter_F16_Create(const SkPixmap& device, const SkPaint& paint,
+                                SkShader::Context* shaderContext,
+                                SkTBlitterAllocator* allocator) {
+    return create<StateF16>(device, paint, shaderContext, allocator);
 }