Modify YUV codecs to match Skia's API change

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

 /*
  * Copyright (C) 2012 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 66 matching lines @@
         dst->lockPixels();
         return true;
     }
 
 private:
     SkImageInfo m_info;
     void* m_pixels;
     size_t m_rowBytes;
 };
 
-static bool updateYUVComponentSizes(ImageDecoder* decoder, SkISize componentSizes[3], ImageDecoder::SizeType sizeType)
+static bool updateYUVComponentSizes(ImageDecoder* decoder, SkISize componentSizes[3], size_t componentWidthBytes[3])
 {
     if (!decoder->canDecodeToYUV())
         return false;
 
-    IntSize size = decoder->decodedYUVSize(0, sizeType);
+    IntSize size = decoder->decodedYUVSize(0);
     componentSizes[0].set(size.width(), size.height());
-    size = decoder->decodedYUVSize(1, sizeType);
+    componentWidthBytes[0] = decoder->decodedYUVWidthBytes(0);
+    size = decoder->decodedYUVSize(1);
     componentSizes[1].set(size.width(), size.height());
-    size = decoder->decodedYUVSize(2, sizeType);
+    componentWidthBytes[1] = decoder->decodedYUVWidthBytes(1);
+    size = decoder->decodedYUVSize(2);
     componentSizes[2].set(size.width(), size.height());
+    componentWidthBytes[2] = decoder->decodedYUVWidthBytes(2);
     return true;
 }
 
 ImageFrameGenerator::ImageFrameGenerator(const SkISize& fullSize, PassRefPtr<SharedBuffer> data, bool allDataReceived, bool isMultiFrame)
     : m_fullSize(fullSize)
     , m_data(adoptRef(new ThreadSafeDataTransport()))
     , m_isMultiFrame(isMultiFrame)
     , m_decodeFailed(false)
     , m_frameCount(0)
     , m_encodedData(nullptr)
@@ skipping 91 matching lines @@
     // Check to see if the decoder has written directly to the pixel memory
     // provided. If not, make a copy.
     ASSERT(bitmap.width() == scaledSize.width());
     ASSERT(bitmap.height() == scaledSize.height());
     SkAutoLockPixels bitmapLock(bitmap);
     if (bitmap.getPixels() != pixels)
         return bitmap.copyPixelsTo(pixels, rowBytes * info.height(), rowBytes);
     return true;
 }
 
-bool ImageFrameGenerator::decodeToYUV(size_t index, SkISize componentSizes[3], void* planes[3], size_t rowBytes[3])
+bool ImageFrameGenerator::decodeToYUV(size_t index, const SkISize componentSizes[3], void* planes[3], const size_t rowBytes[3])
 {
     // Prevent concurrent decode or scale operations on the same image data.
     MutexLocker lock(m_decodeMutex);
 
     if (m_decodeFailed)
         return false;
 
     TRACE_EVENT1("blink", "ImageFrameGenerator::decodeToYUV", "frame index", static_cast<int>(index));
 
     if (!planes || !planes[0] || !planes[1] || !planes[2]
@@ skipping 10 matching lines @@
 
     OwnPtr<ImageDecoder> decoder = ImageDecoder::create(*data, ImageDecoder::AlphaPremultiplied, ImageDecoder::GammaAndColorProfileApplied);
     if (!decoder)
         return false;
 
     decoder->setData(data, allDataReceived);
 
     OwnPtr<ImagePlanes> imagePlanes = adoptPtr(new ImagePlanes(planes, rowBytes));
     decoder->setImagePlanes(imagePlanes.release());
 
-    bool sizeUpdated = updateYUVComponentSizes(decoder.get(), componentSizes, ImageDecoder::ActualSize);
-    RELEASE_ASSERT(sizeUpdated);
+    ASSERT(decoder->canDecodeToYUV());
 
     if (decoder->decodeToYUV()) {
         setHasAlpha(0, false); // YUV is always opaque
         return true;
     }
 
     ASSERT(decoder->failed());
     m_decodeFailed = true;
     return false;
 }
@@ skipping 130 matching lines @@
 }
 
 bool ImageFrameGenerator::hasAlpha(size_t index)
 {
     MutexLocker lock(m_alphaMutex);
     if (index < m_hasAlpha.size())
         return m_hasAlpha[index];
     return true;
 }
 
-bool ImageFrameGenerator::getYUVComponentSizes(SkISize componentSizes[3])
+bool ImageFrameGenerator::getYUVComponentSizes(SkYUVSizeInfo* sizeInfo)
 {
     TRACE_EVENT2("blink", "ImageFrameGenerator::getYUVComponentSizes", "width", m_fullSize.width(), "height", m_fullSize.height());
 
     SharedBuffer* data = 0;
     bool allDataReceived = false;
     m_data->data(&data, &allDataReceived);
 
     // FIXME: YUV decoding does not currently support progressive decoding.
     if (!allDataReceived)
         return false;
 
     OwnPtr<ImageDecoder> decoder = ImageDecoder::create(*data, ImageDecoder::AlphaPremultiplied, ImageDecoder::GammaAndColorProfileApplied);
     if (!decoder)
         return false;
 
     // Setting a dummy ImagePlanes object signals to the decoder that we want to do YUV decoding.
     decoder->setData(data, allDataReceived);
     OwnPtr<ImagePlanes> dummyImagePlanes = adoptPtr(new ImagePlanes);
     decoder->setImagePlanes(dummyImagePlanes.release());
 
-    ASSERT(componentSizes);
-    return updateYUVComponentSizes(decoder.get(), componentSizes, ImageDecoder::SizeForMemoryAllocation);
+    return updateYUVComponentSizes(decoder.get(), sizeInfo->fSizes, sizeInfo->fWidthBytes);
 }
 
 } // namespace blink