Merge css3/image/ and fast/images/ to images/

third_party/WebKit/Source/platform/image-decoders/jpeg/JPEGImageDecoderTest.cpp

 /*
  * Copyright (C) 2013 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 124 matching lines @@
 TEST(JPEGImageDecoderTest, tooBig) {
   std::unique_ptr<ImageDecoder> decoder = createDecoder(100);
   EXPECT_FALSE(decoder->setSize(10000, 10000));
   EXPECT_TRUE(decoder->failed());
 }
 
 // Tests that the JPEG decoder can downsample image whose width and height are
 // multiples of 8, to ensure we compute the correct decodedSize and pass correct
 // parameters to libjpeg to output the image with the expected size.
 TEST(JPEGImageDecoderTest, downsampleImageSizeMultipleOf8) {
-  const char* jpegFile =
-      "/LayoutTests/fast/images/resources/lenna.jpg";  // 256x256
+  const char* jpegFile = "/LayoutTests/images/resources/lenna.jpg";  // 256x256
   unsigned outputWidth, outputHeight;
 
   // 1/8 downsample.
   downsample(40 * 40 * 4, &outputWidth, &outputHeight, jpegFile);
   EXPECT_EQ(32u, outputWidth);
   EXPECT_EQ(32u, outputHeight);
 
   // 2/8 downsample.
   downsample(70 * 70 * 4, &outputWidth, &outputHeight, jpegFile);
   EXPECT_EQ(64u, outputWidth);
@@ skipping 22 matching lines @@
   // 7/8 downsample.
   downsample(230 * 230 * 4, &outputWidth, &outputHeight, jpegFile);
   EXPECT_EQ(224u, outputWidth);
   EXPECT_EQ(224u, outputHeight);
 }
 
 // Tests that JPEG decoder can downsample image whose width and height are not
 // multiple of 8. Ensures that we round using the same algorithm as libjpeg.
 TEST(JPEGImageDecoderTest, downsampleImageSizeNotMultipleOf8) {
   const char* jpegFile =
-      "/LayoutTests/fast/images/resources/icc-v2-gbr.jpg";  // 275x207
+      "/LayoutTests/images/resources/icc-v2-gbr.jpg";  // 275x207
   unsigned outputWidth, outputHeight;
 
   // 1/8 downsample.
   downsample(40 * 40 * 4, &outputWidth, &outputHeight, jpegFile);
   EXPECT_EQ(35u, outputWidth);
   EXPECT_EQ(26u, outputHeight);
 
   // 2/8 downsample.
   downsample(70 * 70 * 4, &outputWidth, &outputHeight, jpegFile);
   EXPECT_EQ(69u, outputWidth);
@@ skipping 20 matching lines @@
   EXPECT_EQ(156u, outputHeight);
 
   // 7/8 downsample.
   downsample(230 * 230 * 4, &outputWidth, &outputHeight, jpegFile);
   EXPECT_EQ(241u, outputWidth);
   EXPECT_EQ(182u, outputHeight);
 }
 
 // Tests that upsampling is not allowed.
 TEST(JPEGImageDecoderTest, upsample) {
-  const char* jpegFile =
-      "/LayoutTests/fast/images/resources/lenna.jpg";  // 256x256
+  const char* jpegFile = "/LayoutTests/images/resources/lenna.jpg";  // 256x256
   unsigned outputWidth, outputHeight;
   downsample(LargeEnoughSize, &outputWidth, &outputHeight, jpegFile);
   EXPECT_EQ(256u, outputWidth);
   EXPECT_EQ(256u, outputHeight);
 }
 
 TEST(JPEGImageDecoderTest, yuv) {
   const char* jpegFile =
-      "/LayoutTests/fast/images/resources/lenna.jpg";  // 256x256, YUV 4:2:0
+      "/LayoutTests/images/resources/lenna.jpg";  // 256x256, YUV 4:2:0
   unsigned outputYWidth, outputYHeight, outputUVWidth, outputUVHeight;
   readYUV(LargeEnoughSize, &outputYWidth, &outputYHeight, &outputUVWidth,
           &outputUVHeight, jpegFile);
   EXPECT_EQ(256u, outputYWidth);
   EXPECT_EQ(256u, outputYHeight);
   EXPECT_EQ(128u, outputUVWidth);
   EXPECT_EQ(128u, outputUVHeight);
 
   const char* jpegFileImageSizeNotMultipleOf8 =
-      "/LayoutTests/fast/images/resources/cropped_mandrill.jpg";  // 439x154
+      "/LayoutTests/images/resources/cropped_mandrill.jpg";  // 439x154
   readYUV(LargeEnoughSize, &outputYWidth, &outputYHeight, &outputUVWidth,
           &outputUVHeight, jpegFileImageSizeNotMultipleOf8);
   EXPECT_EQ(439u, outputYWidth);
   EXPECT_EQ(154u, outputYHeight);
   EXPECT_EQ(220u, outputUVWidth);
   EXPECT_EQ(77u, outputUVHeight);
 
   // Make sure we revert to RGBA decoding when we're about to downscale,
   // which can occur on memory-constrained android devices.
   RefPtr<SharedBuffer> data = readFile(jpegFile);
   ASSERT_TRUE(data);
 
   std::unique_ptr<ImageDecoder> decoder = createDecoder(230 * 230 * 4);
   decoder->setData(data.get(), true);
 
   std::unique_ptr<ImagePlanes> imagePlanes = wrapUnique(new ImagePlanes());
   decoder->setImagePlanes(std::move(imagePlanes));
   ASSERT_TRUE(decoder->isSizeAvailable());
   ASSERT_FALSE(decoder->canDecodeToYUV());
 }
 
 TEST(JPEGImageDecoderTest,
      byteByByteBaselineJPEGWithColorProfileAndRestartMarkers) {
   testByteByByteDecode(&createDecoder,
-                       "/LayoutTests/fast/images/resources/"
+                       "/LayoutTests/images/resources/"
                        "small-square-with-colorspin-profile.jpg",
                        1u, cAnimationNone);
 }
 
 TEST(JPEGImageDecoderTest, byteByByteProgressiveJPEG) {
   testByteByByteDecode(&createDecoder,
-                       "/LayoutTests/fast/images/resources/bug106024.jpg", 1u,
+                       "/LayoutTests/images/resources/bug106024.jpg", 1u,
                        cAnimationNone);
 }
 
 TEST(JPEGImageDecoderTest, byteByByteRGBJPEGWithAdobeMarkers) {
   testByteByByteDecode(
       &createDecoder,
-      "/LayoutTests/fast/images/resources/rgb-jpeg-with-adobe-marker-only.jpg",
-      1u, cAnimationNone);
+      "/LayoutTests/images/resources/rgb-jpeg-with-adobe-marker-only.jpg", 1u,
+      cAnimationNone);
 }
 
 // This test verifies that calling SharedBuffer::mergeSegmentsIntoBuffer() does
 // not break JPEG decoding at a critical point: in between a call to decode the
 // size (when JPEGImageDecoder stops while it may still have input data to
 // read) and a call to do a full decode.
 TEST(JPEGImageDecoderTest, mergeBuffer) {
-  const char* jpegFile = "/LayoutTests/fast/images/resources/lenna.jpg";
+  const char* jpegFile = "/LayoutTests/images/resources/lenna.jpg";
   testMergeBuffer(&createDecoder, jpegFile);
 }
 
 // This tests decoding a JPEG with many progressive scans.  Decoding should
 // fail, but not hang (crbug.com/642462).
 TEST(JPEGImageDecoderTest, manyProgressiveScans) {
   RefPtr<SharedBuffer> testData =
       readFile(decodersTestingDir, "many-progressive-scans.jpg");
   ASSERT_TRUE(testData.get());
 
   std::unique_ptr<ImageDecoder> testDecoder = createDecoder();
   testDecoder->setData(testData.get(), true);
   EXPECT_EQ(1u, testDecoder->frameCount());
   ASSERT_TRUE(testDecoder->frameBufferAtIndex(0));
   EXPECT_TRUE(testDecoder->failed());
 }
 
 }  // namespace blink