Teach Skia to use discardable memory

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 87 matching lines @@
     cachedImage = tryToScale(0, scaledSize, index);
     if (cachedImage)
         return cachedImage;
 
     cachedImage = tryToResumeDecodeAndScale(scaledSize, index);
     if (cachedImage)
         return cachedImage;
     return 0;
 }
 
+bool ImageFrameGenerator::decodeAndScale(const SkImageInfo& info, size_t index, void* pixels, size_t rowBytes)
+{
+    // This method is called to populate a discardable memory owned by Skia.
+    // Ideally we want the decoder to write directly to |pixels| but this
+    // simple implementation copies from a decoded bitmap.
+
+    // This implementation does not support scaling so check the requested size.
+    ASSERT(m_fullSize.width() == info.fWidth);
+    ASSERT(m_fullSize.height() == info.fHeight);
+
+    // Don't use discardable memory for decoding if Skia is providing output
+    // memory. By clearing the memory allocator decoding will use heap memory.
+    //
+    // TODO:
+    // This is not pretty because this class is used in two different code
+    // paths: discardable memory decoding on Android and discardable memory
+    // in Skia. Once the transition to caching in Skia is complete we can get
+    // rid of the logic that handles discardable memory.
+    m_allocator.clear();
+
+    const ScaledImageFragment* cachedImage = decodeAndScale(SkISize::Make(info.fWidth, info.fHeight), index);
+    if (!cachedImage)
+        return false;
+
+    ASSERT(cachedImage->bitmap().width() == info.fWidth);
+    ASSERT(cachedImage->bitmap().height() == info.fHeight);
+
+    bool copied = cachedImage->bitmap().copyPixelsTo(pixels, rowBytes * info.fHeight, rowBytes);
+    ImageDecodingStore::instance()->unlockCache(this, cachedImage);
+    return copied;
+}
+
 const ScaledImageFragment* ImageFrameGenerator::tryToLockCompleteCache(const SkISize& scaledSize, size_t index)
 {
     const ScaledImageFragment* cachedImage = 0;
     if (ImageDecodingStore::instance()->lockCache(this, scaledSize, index, &cachedImage))
         return cachedImage;
     return 0;
 }
 
 const ScaledImageFragment* ImageFrameGenerator::tryToScale(const ScaledImageFragment* fullSizeImage, const SkISize& scaledSize, size_t index)
 {
@@ skipping 140 matching lines @@
 
 bool ImageFrameGenerator::hasAlpha(size_t index)
 {
     MutexLocker lock(m_alphaMutex);
     if (index < m_hasAlpha.size())
         return m_hasAlpha[index];
     return true;
 }
 
 } // namespace