Replace uses of legacy SkImageGenerator API

third_party/WebKit/Source/platform/graphics/DecodingImageGenerator.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 44 matching lines @@
 SkData* DecodingImageGenerator::onRefEncodedData() {
   TRACE_EVENT0("blink", "DecodingImageGenerator::refEncodedData");
 
   // getAsSkData() may require copying, but the clients of this function are
   // serializers, which want the data even if it requires copying, and even
   // if the data is incomplete. (Otherwise they would potentially need to
   // decode the partial image in order to re-encode it.)
   return data_->GetAsSkData().release();
 }
 
 static void doColorSpaceXform(const SkImageInfo& dst_info,

[msarett1, 2017/05/16 18:02:46]

Now that readPixels() has been ramped up, we should be able to replace this
entire functions with a call to readPixels().

I'd like to look at that in a separate change.

                               void* pixels,
                               size_t row_bytes,
-                              SkColorSpace* src_color_space) {
+                              SkColorSpace* src_color_space,
+                              SkTransferFunctionBehavior behavior) {
   TRACE_EVENT0("blink", "DecodingImageGenerator::getPixels - apply xform");
   std::unique_ptr<SkColorSpaceXform> xform =
       SkColorSpaceXform::New(src_color_space, dst_info.colorSpace());
 
+  const bool post_xform_premul =
+      (dst_info.alphaType() == kPremul_SkAlphaType) &&
+      (behavior == SkTransferFunctionBehavior::kIgnore);
+
   uint32_t* row = reinterpret_cast<uint32_t*>(pixels);
   for (int y = 0; y < dst_info.height(); y++) {
     SkColorSpaceXform::ColorFormat format =
         SkColorSpaceXform::kRGBA_8888_ColorFormat;
     if (kN32_SkColorType == kBGRA_8888_SkColorType) {
       format = SkColorSpaceXform::kBGRA_8888_ColorFormat;
     }
-    SkAlphaType alpha_type =
-        dst_info.isOpaque() ? kOpaque_SkAlphaType : kUnpremul_SkAlphaType;
+    SkAlphaType alpha_type = dst_info.alphaType();
+    if (post_xform_premul) {
+      alpha_type = kUnpremul_SkAlphaType;

[f(malita), 2017/05/16 18:16:45]

uber-nit: i think ternary op would fit better than conditional here.

[msarett1, 2017/05/16 18:59:16]

Done.

+    }
     bool xformed =
         xform->apply(format, row, format, row, dst_info.width(), alpha_type);
     DCHECK(xformed);
 
     // To be compatible with dst space blending, premultiply in the dst space.
-    if (kPremul_SkAlphaType == dst_info.alphaType()) {
+    if (post_xform_premul) {
       for (int x = 0; x < dst_info.width(); x++) {
         row[x] =
             SkPreMultiplyARGB(SkGetPackedA32(row[x]), SkGetPackedR32(row[x]),
                               SkGetPackedG32(row[x]), SkGetPackedB32(row[x]));
       }
     }
 
     row = reinterpret_cast<uint32_t*>(
         (reinterpret_cast<uint8_t*>(row) + row_bytes));
   }
 }
 
 bool DecodingImageGenerator::onGetPixels(const SkImageInfo& dst_info,
                                          void* pixels,
                                          size_t row_bytes,
-                                         SkPMColor*,
-                                         int*) {
+                                         const Options& options) {
   TRACE_EVENT1("blink", "DecodingImageGenerator::getPixels", "frame index",
                static_cast<int>(frame_index_));
 
   // Implementation doesn't support scaling yet, so make sure we're not given a
   // different size.
   if (dst_info.dimensions() != getInfo().dimensions()) {
     return false;
   }
 
   if (dst_info.colorType() != kN32_SkColorType) {
@@ skipping 20 matching lines @@
     decode_info = decode_info.makeAlphaType(kUnpremul_SkAlphaType);
   }
 
   PlatformInstrumentation::WillDecodeLazyPixelRef(uniqueID());
   bool decoded = frame_generator_->DecodeAndScale(
       data_.Get(), all_data_received_, frame_index_, decode_info, pixels,
       row_bytes, alpha_option);
   PlatformInstrumentation::DidDecodeLazyPixelRef();
 
   if (decoded && needs_color_xform) {
-    doColorSpaceXform(dst_info, pixels, row_bytes, decode_color_space);
+    doColorSpaceXform(dst_info, pixels, row_bytes, decode_color_space,
+                      options.fBehavior);
   }
 
   return decoded;
 }
 
 bool DecodingImageGenerator::onQueryYUV8(SkYUVSizeInfo* size_info,
                                          SkYUVColorSpace* color_space) const {
   // YUV decoding does not currently support progressive decoding. See comment
   // in ImageFrameGenerator.h.
   if (!can_yuv_decode_ || !all_data_received_)
@@ skipping 48 matching lines @@
       ImageFrameGenerator::Create(SkISize::Make(size.Width(), size.Height()),
                                   false, decoder->GetColorBehavior());
   if (!frame)
     return nullptr;
 
   return new DecodingImageGenerator(frame, info, segment_reader.Release(), true,
                                     0);
 }
 
 }  // namespace blink