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

third_party/WebKit/Source/platform/image-decoders/webp/WEBPImageDecoderTest.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 125 matching lines @@
     verifyFramesMatch(webpFile, decoderA->frameBufferAtIndex(i),
                       decoderB->frameBufferAtIndex(i));
 }
 
 }  // anonymous namespace
 
 TEST(AnimatedWebPTests, uniqueGenerationIDs) {
   std::unique_ptr<ImageDecoder> decoder = createDecoder();
 
   RefPtr<SharedBuffer> data =
-      readFile("/LayoutTests/fast/images/resources/webp-animated.webp");
+      readFile("/LayoutTests/images/resources/webp-animated.webp");
   ASSERT_TRUE(data.get());
   decoder->setData(data.get(), true);
 
   ImageFrame* frame = decoder->frameBufferAtIndex(0);
   uint32_t generationID0 = frame->bitmap().getGenerationID();
   frame = decoder->frameBufferAtIndex(1);
   uint32_t generationID1 = frame->bitmap().getGenerationID();
 
   EXPECT_TRUE(generationID0 != generationID1);
 }
 
 TEST(AnimatedWebPTests, verifyAnimationParametersTransparentImage) {
   std::unique_ptr<ImageDecoder> decoder = createDecoder();
   EXPECT_EQ(cAnimationLoopOnce, decoder->repetitionCount());
 
   RefPtr<SharedBuffer> data =
-      readFile("/LayoutTests/fast/images/resources/webp-animated.webp");
+      readFile("/LayoutTests/images/resources/webp-animated.webp");
   ASSERT_TRUE(data.get());
   decoder->setData(data.get(), true);
 
   const int canvasWidth = 11;
   const int canvasHeight = 29;
   const struct AnimParam {
     int xOffset, yOffset, width, height;
     ImageFrame::DisposalMethod disposalMethod;
     ImageFrame::AlphaBlendSource alphaBlendSource;
     unsigned duration;
@@ skipping 26 matching lines @@
   EXPECT_EQ(WTF_ARRAY_LENGTH(frameParameters), decoder->frameCount());
   EXPECT_EQ(cAnimationLoopInfinite, decoder->repetitionCount());
 }
 
 TEST(AnimatedWebPTests,
      verifyAnimationParametersOpaqueFramesTransparentBackground) {
   std::unique_ptr<ImageDecoder> decoder = createDecoder();
   EXPECT_EQ(cAnimationLoopOnce, decoder->repetitionCount());
 
   RefPtr<SharedBuffer> data =
-      readFile("/LayoutTests/fast/images/resources/webp-animated-opaque.webp");
+      readFile("/LayoutTests/images/resources/webp-animated-opaque.webp");
   ASSERT_TRUE(data.get());
   decoder->setData(data.get(), true);
 
   const int canvasWidth = 94;
   const int canvasHeight = 87;
   const struct AnimParam {
     int xOffset, yOffset, width, height;
     ImageFrame::DisposalMethod disposalMethod;
     ImageFrame::AlphaBlendSource alphaBlendSource;
     unsigned duration;
@@ skipping 26 matching lines @@
   }
 
   EXPECT_EQ(WTF_ARRAY_LENGTH(frameParameters), decoder->frameCount());
   EXPECT_EQ(cAnimationLoopInfinite, decoder->repetitionCount());
 }
 
 TEST(AnimatedWebPTests, verifyAnimationParametersBlendOverwrite) {
   std::unique_ptr<ImageDecoder> decoder = createDecoder();
   EXPECT_EQ(cAnimationLoopOnce, decoder->repetitionCount());
 
-  RefPtr<SharedBuffer> data = readFile(
-      "/LayoutTests/fast/images/resources/webp-animated-no-blend.webp");
+  RefPtr<SharedBuffer> data =
+      readFile("/LayoutTests/images/resources/webp-animated-no-blend.webp");
   ASSERT_TRUE(data.get());
   decoder->setData(data.get(), true);
 
   const int canvasWidth = 94;
   const int canvasHeight = 87;
   const struct AnimParam {
     int xOffset, yOffset, width, height;
     ImageFrame::DisposalMethod disposalMethod;
     ImageFrame::AlphaBlendSource alphaBlendSource;
     unsigned duration;
@@ skipping 24 matching lines @@
     EXPECT_EQ(frameParameters[i].duration, frame->duration());
     EXPECT_EQ(frameParameters[i].hasAlpha, frame->hasAlpha());
   }
 
   EXPECT_EQ(WTF_ARRAY_LENGTH(frameParameters), decoder->frameCount());
   EXPECT_EQ(cAnimationLoopInfinite, decoder->repetitionCount());
 }
 
 TEST(AnimatedWebPTests, parseAndDecodeByteByByte) {
   testByteByByteDecode(&createDecoder,
-                       "/LayoutTests/fast/images/resources/webp-animated.webp",
-                       3u, cAnimationLoopInfinite);
+                       "/LayoutTests/images/resources/webp-animated.webp", 3u,
+                       cAnimationLoopInfinite);
   testByteByByteDecode(
       &createDecoder,
-      "/LayoutTests/fast/images/resources/webp-animated-icc-xmp.webp", 13u,
-      32000);
+      "/LayoutTests/images/resources/webp-animated-icc-xmp.webp", 13u, 32000);
 }
 
 TEST(AnimatedWebPTests, invalidImages) {
   // ANMF chunk size is smaller than ANMF header size.
-  testInvalidImage(
-      "/LayoutTests/fast/images/resources/invalid-animated-webp.webp", true);
+  testInvalidImage("/LayoutTests/images/resources/invalid-animated-webp.webp",
+                   true);
   // One of the frame rectangles extends outside the image boundary.
-  testInvalidImage(
-      "/LayoutTests/fast/images/resources/invalid-animated-webp3.webp", true);
+  testInvalidImage("/LayoutTests/images/resources/invalid-animated-webp3.webp",
+                   true);
 }
 
 TEST(AnimatedWebPTests, truncatedLastFrame) {
   std::unique_ptr<ImageDecoder> decoder = createDecoder();
 
-  RefPtr<SharedBuffer> data = readFile(
-      "/LayoutTests/fast/images/resources/invalid-animated-webp2.webp");
+  RefPtr<SharedBuffer> data =
+      readFile("/LayoutTests/images/resources/invalid-animated-webp2.webp");
   ASSERT_TRUE(data.get());
   decoder->setData(data.get(), true);
 
   size_t frameCount = 8;
   EXPECT_EQ(frameCount, decoder->frameCount());
   ImageFrame* frame = decoder->frameBufferAtIndex(0);
   ASSERT_TRUE(frame);
   EXPECT_EQ(ImageFrame::FrameComplete, frame->getStatus());
   EXPECT_FALSE(decoder->failed());
   frame = decoder->frameBufferAtIndex(frameCount - 1);
   ASSERT_TRUE(frame);
   EXPECT_EQ(ImageFrame::FramePartial, frame->getStatus());
   EXPECT_TRUE(decoder->failed());
   frame = decoder->frameBufferAtIndex(0);
   ASSERT_TRUE(frame);
   EXPECT_EQ(ImageFrame::FrameComplete, frame->getStatus());
 }
 
 TEST(AnimatedWebPTests, truncatedInBetweenFrame) {
   std::unique_ptr<ImageDecoder> decoder = createDecoder();
 
-  RefPtr<SharedBuffer> fullData = readFile(
-      "/LayoutTests/fast/images/resources/invalid-animated-webp4.webp");
+  RefPtr<SharedBuffer> fullData =
+      readFile("/LayoutTests/images/resources/invalid-animated-webp4.webp");
   ASSERT_TRUE(fullData.get());
   RefPtr<SharedBuffer> data =
       SharedBuffer::create(fullData->data(), fullData->size() - 1);
   decoder->setData(data.get(), false);
 
   ImageFrame* frame = decoder->frameBufferAtIndex(1);
   ASSERT_TRUE(frame);
   EXPECT_EQ(ImageFrame::FrameComplete, frame->getStatus());
   frame = decoder->frameBufferAtIndex(2);
   ASSERT_TRUE(frame);
   EXPECT_EQ(ImageFrame::FramePartial, frame->getStatus());
   EXPECT_TRUE(decoder->failed());
 }
 
 // Tests for a crash that used to happen for a specific file with specific
 // sequence of method calls.
 TEST(AnimatedWebPTests, reproCrash) {
   std::unique_ptr<ImageDecoder> decoder = createDecoder();
 
   RefPtr<SharedBuffer> fullData =
-      readFile("/LayoutTests/fast/images/resources/invalid_vp8_vp8x.webp");
+      readFile("/LayoutTests/images/resources/invalid_vp8_vp8x.webp");
   ASSERT_TRUE(fullData.get());
 
   // Parse partial data up to which error in bitstream is not detected.
   const size_t partialSize = 32768;
   ASSERT_GT(fullData->size(), partialSize);
   RefPtr<SharedBuffer> data =
       SharedBuffer::create(fullData->data(), partialSize);
   decoder->setData(data.get(), false);
   EXPECT_EQ(1u, decoder->frameCount());
   ImageFrame* frame = decoder->frameBufferAtIndex(0);
   ASSERT_TRUE(frame);
   EXPECT_EQ(ImageFrame::FramePartial, frame->getStatus());
   EXPECT_FALSE(decoder->failed());
 
   // Parse full data now. The error in bitstream should now be detected.
   decoder->setData(fullData.get(), true);
   EXPECT_EQ(1u, decoder->frameCount());
   frame = decoder->frameBufferAtIndex(0);
   ASSERT_TRUE(frame);
   EXPECT_EQ(ImageFrame::FramePartial, frame->getStatus());
   EXPECT_EQ(cAnimationLoopOnce, decoder->repetitionCount());
   EXPECT_TRUE(decoder->failed());
 }
 
 TEST(AnimatedWebPTests, progressiveDecode) {
-  testProgressiveDecoding(
-      &createDecoder, "/LayoutTests/fast/images/resources/webp-animated.webp");
+  testProgressiveDecoding(&createDecoder,
+                          "/LayoutTests/images/resources/webp-animated.webp");
 }
 
 TEST(AnimatedWebPTests, frameIsCompleteAndDuration) {
   std::unique_ptr<ImageDecoder> decoder = createDecoder();
 
   RefPtr<SharedBuffer> data =
-      readFile("/LayoutTests/fast/images/resources/webp-animated.webp");
+      readFile("/LayoutTests/images/resources/webp-animated.webp");
   ASSERT_TRUE(data.get());
 
   ASSERT_GE(data->size(), 10u);
   RefPtr<SharedBuffer> tempData =
       SharedBuffer::create(data->data(), data->size() - 10);
   decoder->setData(tempData.get(), false);
 
   EXPECT_EQ(2u, decoder->frameCount());
   EXPECT_FALSE(decoder->failed());
   EXPECT_TRUE(decoder->frameIsCompleteAtIndex(0));
   EXPECT_EQ(1000, decoder->frameDurationAtIndex(0));
   EXPECT_TRUE(decoder->frameIsCompleteAtIndex(1));
   EXPECT_EQ(500, decoder->frameDurationAtIndex(1));
 
   decoder->setData(data.get(), true);
   EXPECT_EQ(3u, decoder->frameCount());
   EXPECT_TRUE(decoder->frameIsCompleteAtIndex(0));
   EXPECT_EQ(1000, decoder->frameDurationAtIndex(0));
   EXPECT_TRUE(decoder->frameIsCompleteAtIndex(1));
   EXPECT_EQ(500, decoder->frameDurationAtIndex(1));
   EXPECT_TRUE(decoder->frameIsCompleteAtIndex(2));
   EXPECT_EQ(1000.0, decoder->frameDurationAtIndex(2));
 }
 
 TEST(AnimatedWebPTests, updateRequiredPreviousFrameAfterFirstDecode) {
   std::unique_ptr<ImageDecoder> decoder = createDecoder();
 
   RefPtr<SharedBuffer> fullData =
-      readFile("/LayoutTests/fast/images/resources/webp-animated.webp");
+      readFile("/LayoutTests/images/resources/webp-animated.webp");
   ASSERT_TRUE(fullData.get());
 
   // Check the status of requiredPreviousFrameIndex before decoding, by
   // supplying data sufficient to parse but not decode.
   size_t partialSize = 1;
   do {
     RefPtr<SharedBuffer> data =
         SharedBuffer::create(fullData->data(), partialSize);
     decoder->setData(data.get(), false);
     ++partialSize;
   } while (!decoder->frameCount() ||
            decoder->frameBufferAtIndex(0)->getStatus() ==
                ImageFrame::FrameEmpty);
 
   EXPECT_EQ(kNotFound,
             decoder->frameBufferAtIndex(0)->requiredPreviousFrameIndex());
   size_t frameCount = decoder->frameCount();
   for (size_t i = 1; i < frameCount; ++i)
     EXPECT_EQ(i - 1,
               decoder->frameBufferAtIndex(i)->requiredPreviousFrameIndex());
 
   decoder->setData(fullData.get(), true);
   for (size_t i = 0; i < frameCount; ++i)
     EXPECT_EQ(kNotFound,
               decoder->frameBufferAtIndex(i)->requiredPreviousFrameIndex());
 }
 
 TEST(AnimatedWebPTests, randomFrameDecode) {
-  testRandomFrameDecode(
-      &createDecoder, "/LayoutTests/fast/images/resources/webp-animated.webp");
+  testRandomFrameDecode(&createDecoder,
+                        "/LayoutTests/images/resources/webp-animated.webp");
   testRandomFrameDecode(
       &createDecoder,
-      "/LayoutTests/fast/images/resources/webp-animated-opaque.webp");
+      "/LayoutTests/images/resources/webp-animated-opaque.webp");
+  testRandomFrameDecode(
+      &createDecoder, "/LayoutTests/images/resources/webp-animated-large.webp");
   testRandomFrameDecode(
       &createDecoder,
-      "/LayoutTests/fast/images/resources/webp-animated-large.webp");
-  testRandomFrameDecode(
-      &createDecoder,
-      "/LayoutTests/fast/images/resources/webp-animated-icc-xmp.webp");
+      "/LayoutTests/images/resources/webp-animated-icc-xmp.webp");
 }
 
 TEST(AnimatedWebPTests, randomDecodeAfterClearFrameBufferCache) {
   testRandomDecodeAfterClearFrameBufferCache(
-      &createDecoder, "/LayoutTests/fast/images/resources/webp-animated.webp");
+      &createDecoder, "/LayoutTests/images/resources/webp-animated.webp");
   testRandomDecodeAfterClearFrameBufferCache(
       &createDecoder,
-      "/LayoutTests/fast/images/resources/webp-animated-opaque.webp");
+      "/LayoutTests/images/resources/webp-animated-opaque.webp");
+  testRandomDecodeAfterClearFrameBufferCache(
+      &createDecoder, "/LayoutTests/images/resources/webp-animated-large.webp");
   testRandomDecodeAfterClearFrameBufferCache(
       &createDecoder,
-      "/LayoutTests/fast/images/resources/webp-animated-large.webp");
-  testRandomDecodeAfterClearFrameBufferCache(
-      &createDecoder,
-      "/LayoutTests/fast/images/resources/webp-animated-icc-xmp.webp");
+      "/LayoutTests/images/resources/webp-animated-icc-xmp.webp");
 }
 
 TEST(AnimatedWebPTests,
      DISABLED_resumePartialDecodeAfterClearFrameBufferCache) {
   RefPtr<SharedBuffer> fullData =
-      readFile("/LayoutTests/fast/images/resources/webp-animated-large.webp");
+      readFile("/LayoutTests/images/resources/webp-animated-large.webp");
   ASSERT_TRUE(fullData.get());
   Vector<unsigned> baselineHashes;
   createDecodingBaseline(&createDecoder, fullData.get(), &baselineHashes);
   size_t frameCount = baselineHashes.size();
 
   std::unique_ptr<ImageDecoder> decoder = createDecoder();
 
   // Let frame 0 be partially decoded.
   size_t partialSize = 1;
   do {
@@ skipping 13 matching lines @@
   decoder->clearCacheExceptFrame(kNotFound);
 
   // Resume decoding of the first frame.
   ImageFrame* firstFrame = decoder->frameBufferAtIndex(0);
   EXPECT_EQ(ImageFrame::FrameComplete, firstFrame->getStatus());
   EXPECT_EQ(baselineHashes[0], hashBitmap(firstFrame->bitmap()));
 }
 
 TEST(AnimatedWebPTests, decodeAfterReallocatingData) {
   testDecodeAfterReallocatingData(
-      &createDecoder, "/LayoutTests/fast/images/resources/webp-animated.webp");
+      &createDecoder, "/LayoutTests/images/resources/webp-animated.webp");
   testDecodeAfterReallocatingData(
       &createDecoder,
-      "/LayoutTests/fast/images/resources/webp-animated-icc-xmp.webp");
+      "/LayoutTests/images/resources/webp-animated-icc-xmp.webp");
 }
 
 TEST(AnimatedWebPTests, alphaBlending) {
-  testAlphaBlending("/LayoutTests/fast/images/resources/webp-animated.webp");
+  testAlphaBlending("/LayoutTests/images/resources/webp-animated.webp");
   testAlphaBlending(
-      "/LayoutTests/fast/images/resources/webp-animated-semitransparent1.webp");
+      "/LayoutTests/images/resources/webp-animated-semitransparent1.webp");
   testAlphaBlending(
-      "/LayoutTests/fast/images/resources/webp-animated-semitransparent2.webp");
+      "/LayoutTests/images/resources/webp-animated-semitransparent2.webp");
   testAlphaBlending(
-      "/LayoutTests/fast/images/resources/webp-animated-semitransparent3.webp");
+      "/LayoutTests/images/resources/webp-animated-semitransparent3.webp");
   testAlphaBlending(
-      "/LayoutTests/fast/images/resources/webp-animated-semitransparent4.webp");
+      "/LayoutTests/images/resources/webp-animated-semitransparent4.webp");
 }
 
 TEST(AnimatedWebPTests, isSizeAvailable) {
   testByteByByteSizeAvailable(
-      &createDecoder, "/LayoutTests/fast/images/resources/webp-animated.webp",
-      142u, false, cAnimationLoopInfinite);
+      &createDecoder, "/LayoutTests/images/resources/webp-animated.webp", 142u,
+      false, cAnimationLoopInfinite);
   // FIXME: Add color profile support for animated webp images.
   testByteByByteSizeAvailable(
       &createDecoder,
-      "/LayoutTests/fast/images/resources/webp-animated-icc-xmp.webp", 1404u,
-      false, 32000);
+      "/LayoutTests/images/resources/webp-animated-icc-xmp.webp", 1404u, false,
+      32000);
 }
 
 TEST(StaticWebPTests, truncatedImage) {
   // VP8 data is truncated.
-  testInvalidImage("/LayoutTests/fast/images/resources/truncated.webp", false);
+  testInvalidImage("/LayoutTests/images/resources/truncated.webp", false);
   // Chunk size in RIFF header doesn't match the file size.
-  testInvalidImage("/LayoutTests/fast/images/resources/truncated2.webp", true);
+  testInvalidImage("/LayoutTests/images/resources/truncated2.webp", true);
 }
 
 // Regression test for a bug where some valid images were failing to decode
 // incrementally.
 TEST(StaticWebPTests, incrementalDecode) {
   testByteByByteDecode(&createDecoder,
-                       "/LayoutTests/fast/images/resources/crbug.364830.webp",
-                       1u, cAnimationNone);
+                       "/LayoutTests/images/resources/crbug.364830.webp", 1u,
+                       cAnimationNone);
 }
 
 TEST(StaticWebPTests, isSizeAvailable) {
   testByteByByteSizeAvailable(
       &createDecoder,
-      "/LayoutTests/fast/images/resources/webp-color-profile-lossy.webp", 520u,
-      true, cAnimationNone);
+      "/LayoutTests/images/resources/webp-color-profile-lossy.webp", 520u, true,
+      cAnimationNone);
   testByteByByteSizeAvailable(&createDecoder,
-                              "/LayoutTests/fast/images/resources/test.webp",
-                              30u, false, cAnimationNone);
+                              "/LayoutTests/images/resources/test.webp", 30u,
+                              false, cAnimationNone);
 }
 
 TEST(StaticWebPTests, notAnimated) {
   std::unique_ptr<ImageDecoder> decoder = createDecoder();
-  RefPtr<SharedBuffer> data = readFile(
-      "/LayoutTests/fast/images/resources/webp-color-profile-lossy.webp");
+  RefPtr<SharedBuffer> data =
+      readFile("/LayoutTests/images/resources/webp-color-profile-lossy.webp");
   ASSERT_TRUE(data.get());
   decoder->setData(data.get(), true);
   EXPECT_EQ(1u, decoder->frameCount());
   EXPECT_EQ(cAnimationNone, decoder->repetitionCount());
 }
 
 }  // namespace blink