Use SkPngEncoder in gfx jpeg_codec

ui/gfx/codec/png_codec.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/gfx/codec/png_codec.h"
+#include "ui/gfx/codec/codec_priv.h"
 
 #include <stdint.h>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/string_util.h"
 #include "third_party/libpng/png.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkColorPriv.h"
 #include "third_party/skia/include/core/SkUnPreMultiply.h"
+#include "third_party/skia/include/encode/SkPngEncoder.h"
 #include "third_party/zlib/zlib.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/skia_util.h"
 
 namespace gfx {
 
 namespace {
 
 // Converts BGRA->RGBA and RGBA->BGRA.
 void ConvertBetweenBGRAandRGBA(const unsigned char* input, int pixel_width,
@@ skipping 699 matching lines @@
       inputAddr,
       PNGCodec::FORMAT_SkBitmap,
       Size(input.width(), input.height()),
       static_cast<int>(input.rowBytes()),
       discard_transparency,
       std::vector<PNGCodec::Comment>(),
       compression_level,
       output);
 }
 
+static void AddComments(SkPngEncoder::Options& options,
+                        const std::vector<PNGCodec::Comment>& comments) {
+  std::vector<const char*> commentPointers;
+  std::vector<size_t> commentSizes;
+  for (const auto& comment : comments) {
+    commentPointers.push_back(comment.key.c_str());
+    commentPointers.push_back(comment.text.c_str());
+    commentSizes.push_back(comment.key.length() + 1);
+    commentSizes.push_back(comment.text.length() + 1);
+  }
+  options.fComments =
+      SkDataTable::MakeCopyArrays((void const* const*)commentPointers.data(),
+                                  commentSizes.data(), commentPointers.size());
+}
 
 }  // namespace
 
 // static
-bool PNGCodec::Encode(const unsigned char* input,
-                      ColorFormat format,
-                      const Size& size,
-                      int row_byte_width,
-                      bool discard_transparency,

[msarett1, 2017/06/16 21:29:56]

As we discussed in person, you'll have to find a way to handle
discard_transparency.

It's a bit of a strange option because, as it is implemented now, the encoder
may need to unpremultiply and then throw away the alpha channel.

My preference would be to keep that logic here by:
***Unpremultiply in gfx if necessary
***Lie to Skia and say that the pixels are kOpaque_SkAlphaType

--------

Might also be worth investigating if users of discard_transparency=true actually
need it.

[liyuqian, 2017/06/23 13:54:25]

Done.

+bool PNGCodec::Encode(const SkPixmap& src,
                       const std::vector<Comment>& comments,
                       std::vector<unsigned char>* output) {
-  return EncodeWithCompressionLevel(input,
-                                    format,
-                                    size,
-                                    row_byte_width,
-                                    discard_transparency,
-                                    comments,
-                                    Z_DEFAULT_COMPRESSION,
-                                    output);
+  output->clear();
+  VectorWStream dst(output);
+
+  SkPngEncoder::Options options;
+  AddComments(options, comments);
+  return SkPngEncoder::Encode(&dst, src, options);
 }
 
 // static
 bool PNGCodec::EncodeBGRASkBitmap(const SkBitmap& input,
                                   bool discard_transparency,
                                   std::vector<unsigned char>* output) {
   return InternalEncodeSkBitmap(input,
                                 discard_transparency,
                                 Z_DEFAULT_COMPRESSION,
                                 output);
@@ skipping 19 matching lines @@
 }
 
 PNGCodec::Comment::Comment(const std::string& k, const std::string& t)
     : key(k), text(t) {
 }
 
 PNGCodec::Comment::~Comment() {
 }
 
 }  // namespace gfx