Use SkJpegEncoder in gfx jpeg_codec

ui/gfx/codec/jpeg_codec_unittest.cc

 // Copyright (c) 2011 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 <math.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/macros.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 93 matching lines @@
 TEST(JPEGCodec, EncodeDecodeRGBA) {
   int w = 20, h = 20;
 
   // create an image with known values, a must be opaque because it will be
   // lost during compression
   std::vector<unsigned char> original;
   MakeRGBAImage(w, h, &original);
 
   // encode, making sure it was compressed some
   std::vector<unsigned char> encoded;
-  EXPECT_TRUE(JPEGCodec::Encode(&original[0], JPEGCodec::FORMAT_RGBA, w, h,
-                                w * 4, jpeg_quality, &encoded));
+  SkImageInfo info =
+      SkImageInfo::Make(w, h, kRGBA_8888_SkColorType, kOpaque_SkAlphaType);
+  SkPixmap src(info, &original[0], w * 4);
+  EXPECT_TRUE(JPEGCodec::Encode(src, jpeg_quality, &encoded));
   EXPECT_GT(original.size(), encoded.size());
 
   // decode, it should have the same size as the original
   std::vector<unsigned char> decoded;
   int outw, outh;
   EXPECT_TRUE(JPEGCodec::Decode(&encoded[0], encoded.size(),
                                 JPEGCodec::FORMAT_RGBA, &decoded,
                                 &outw, &outh));
   ASSERT_EQ(w, outw);
   ASSERT_EQ(h, outh);
@@ skipping 14 matching lines @@
 
   // it should fail when given non-JPEG compressed data
   std::vector<unsigned char> output;
   int outw, outh;
   ASSERT_FALSE(JPEGCodec::Decode(&original[0], original.size(),
                                  JPEGCodec::FORMAT_RGBA, &output, &outw,
                                  &outh));
 
   // make some compressed data
   std::vector<unsigned char> compressed;
-  ASSERT_TRUE(JPEGCodec::Encode(&original[0], JPEGCodec::FORMAT_RGBA, w, h,
-                                w * 3, jpeg_quality, &compressed));
+  SkImageInfo info =
+      SkImageInfo::Make(w, h, kRGBA_8888_SkColorType, kOpaque_SkAlphaType);
+  SkPixmap src(info, &original[0], w * 4);
+  ASSERT_TRUE(JPEGCodec::Encode(src, jpeg_quality, &compressed));
 
   // try decompressing a truncated version
   ASSERT_FALSE(JPEGCodec::Decode(&compressed[0], compressed.size() / 2,
                                  JPEGCodec::FORMAT_RGBA, &output, &outw,
                                  &outh));
 
   // corrupt it and try decompressing that
   for (int i = 10; i < 30; i++)
     compressed[i] = i;
   ASSERT_FALSE(JPEGCodec::Decode(&compressed[0], compressed.size(),
                                  JPEGCodec::FORMAT_RGBA, &output, &outw,
                                  &outh));
 }
 
 // Test that we can decode JPEG images without invalid-read errors on valgrind.
 // This test decodes a 1x1 JPEG image and writes the decoded RGB (or RGBA) pixel
 // to the output buffer without OOB reads.
 TEST(JPEGCodec, InvalidRead) {
   std::vector<unsigned char> output;
   int outw, outh;
   JPEGCodec::Decode(kTopSitesMigrationTestImage,
                     arraysize(kTopSitesMigrationTestImage),
                     JPEGCodec::FORMAT_RGBA, &output,
                     &outw, &outh);
 }
 
 }  // namespace gfx