Use SkJpegEncoder in WebKit platform

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

 /*
  * Copyright (c) 2008, Google Inc. All rights reserved.
  * Copyright (C) 2009 Dirk Schulze <krit@webkit.org>
  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
@@ skipping 31 matching lines @@
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/ImageBufferClient.h"
 #include "platform/graphics/RecordingImageBufferSurface.h"
 #include "platform/graphics/StaticBitmapImage.h"
 #include "platform/graphics/UnacceleratedImageBufferSurface.h"
 #include "platform/graphics/gpu/DrawingBuffer.h"
 #include "platform/graphics/gpu/Extensions3DUtil.h"
 #include "platform/graphics/paint/PaintImage.h"
 #include "platform/graphics/paint/PaintRecord.h"
 #include "platform/graphics/skia/SkiaUtils.h"
-#include "platform/image-encoders/JPEGImageEncoder.h"
+#include "platform/image-encoders/ImageEncoder.h"
 #include "platform/image-encoders/PNGImageEncoder.h"
 #include "platform/image-encoders/WEBPImageEncoder.h"
 #include "platform/network/mime/MIMETypeRegistry.h"
 #include "platform/wtf/CheckedNumeric.h"
 #include "platform/wtf/MathExtras.h"
 #include "platform/wtf/PtrUtil.h"
 #include "platform/wtf/Vector.h"
 #include "platform/wtf/text/Base64.h"
 #include "platform/wtf/text/WTFString.h"
 #include "platform/wtf/typed_arrays/ArrayBufferContents.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebGraphicsContext3DProvider.h"
 #include "skia/ext/texture_handle.h"
 #include "third_party/skia/include/core/SkSwizzle.h"
+#include "third_party/skia/include/encode/SkJpegEncoder.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 #include "third_party/skia/include/gpu/gl/GrGLTypes.h"
 
 namespace blink {
 
 std::unique_ptr<ImageBuffer> ImageBuffer::Create(
     std::unique_ptr<ImageBufferSurface> surface) {
   if (!surface->IsValid())
     return nullptr;
   return WTF::WrapUnique(new ImageBuffer(std::move(surface)));
@@ skipping 460 matching lines @@
 
 void ImageBuffer::SetNeedsCompositingUpdate() {
   if (client_)
     client_->SetNeedsCompositingUpdate();
 }
 
 bool ImageDataBuffer::EncodeImage(const String& mime_type,
                                   const double& quality,
                                   Vector<unsigned char>* encoded_image) const {
   if (mime_type == "image/jpeg") {
-    if (!JPEGImageEncoder::Encode(*this, quality, encoded_image))
-      return false;
-  } else if (mime_type == "image/webp") {
+    SkImageInfo info =
+        SkImageInfo::Make(Width(), Height(), kRGBA_8888_SkColorType,
+                          kUnpremul_SkAlphaType, nullptr);
+    size_t rowBytes =
+        Width() * SkColorTypeBytesPerPixel(kRGBA_8888_SkColorType);
+    SkPixmap src(info, Pixels(), rowBytes);
+
+    SkJpegEncoder::Options options;
+    options.fQuality = ImageEncoder::ComputeJpegQuality(quality);
+    options.fAlphaOption = SkJpegEncoder::AlphaOption::kBlendOnBlack;
+    options.fBlendBehavior = SkTransferFunctionBehavior::kIgnore;
+    if (options.fQuality == 100) {
+      options.fDownsample = SkJpegEncoder::Downsample::k444;
+    }
+    return ImageEncoder::Encode(encoded_image, src, options);
+  }
+
+  if (mime_type == "image/webp") {
     int compression_quality = WEBPImageEncoder::kDefaultCompressionQuality;
     if (quality >= 0.0 && quality <= 1.0)
       compression_quality = static_cast<int>(quality * 100 + 0.5);
-    if (!WEBPImageEncoder::Encode(*this, compression_quality, encoded_image))
-      return false;
-  } else {
-    if (!PNGImageEncoder::Encode(*this, encoded_image))
-      return false;
-    DCHECK_EQ(mime_type, "image/png");
+    return WEBPImageEncoder::Encode(*this, compression_quality, encoded_image);
   }
 
-  return true;
+  DCHECK_EQ(mime_type, "image/png");
+  return PNGImageEncoder::Encode(*this, encoded_image);
 }
 
 String ImageDataBuffer::ToDataURL(const String& mime_type,
                                   const double& quality) const {
   DCHECK(MIMETypeRegistry::IsSupportedImageMIMETypeForEncoding(mime_type));
 
   Vector<unsigned char> result;
   if (!EncodeImage(mime_type, quality, &result))
     return "data:,";
 
   return "data:" + mime_type + ";base64," + Base64Encode(result);
 }
 
 }  // namespace blink