Use the upstream version of libwebp, v0.4.3.

src/codec/SkWebpCodec.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkWebpCodec.h"
 #include "SkImageGenerator.h"
 #include "SkTemplates.h"
 
 // A WebP decoder on top of (subset of) libwebp
 // For more information on WebP image format, and libwebp library, see:
 //   https://code.google.com/speed/webp/
 //   http://www.webmproject.org/code/#libwebp-webp-image-library
 //   https://chromium.googlesource.com/webm/libwebp
 
 // If moving libwebp out of skia source tree, path for webp headers must be
 // updated accordingly. Here, we enforce using local copy in webp sub-directory.
 #include "webp/decode.h"
+#include "webp/demux.h"
 #include "webp/encode.h"
 
 bool SkWebpCodec::IsWebp(SkStream* stream) {
     // WEBP starts with the following:
     // RIFFXXXXWEBPVP
     // Where XXXX is unspecified.
     const char LENGTH = 14;
     char bytes[LENGTH];
     if (stream->read(&bytes, LENGTH) != LENGTH) {
         return false;
     }
     return !memcmp(bytes, "RIFF", 4) && !memcmp(&bytes[8], "WEBPVP", 6);
 }
 
 static const size_t WEBP_VP8_HEADER_SIZE = 30;
 
 // Parse headers of RIFF container, and check for valid Webp (VP8) content.
 // NOTE: This calls peek instead of read, since onGetPixels will need these
 // bytes again.
 static bool webp_parse_header(SkStream* stream, SkImageInfo* info) {
     unsigned char buffer[WEBP_VP8_HEADER_SIZE];
     if (!stream->peek(buffer, WEBP_VP8_HEADER_SIZE)) {
         return false;
     }
 
-    WebPBitstreamFeatures features;
-    VP8StatusCode status = WebPGetFeatures(buffer, WEBP_VP8_HEADER_SIZE, &features);
-    if (VP8_STATUS_OK != status) {
-        return false; // Invalid WebP file.
+    WebPData demuxData = { buffer, WEBP_VP8_HEADER_SIZE };
+    WebPDemuxState demuxState;
+    WebPDemuxer* demuxer = WebPDemuxPartial(&demuxData, &demuxState);
+    if (!demuxer) {
+        return false;
     }
 
+    SkAutoTCallVProc<WebPDemuxer, WebPDemuxDelete> autoDeleter(demuxer);
+    switch (demuxState) {
+        case WEBP_DEMUX_PARSE_ERROR:
+        case WEBP_DEMUX_PARSING_HEADER:
+            return false;
+        default:
+            // Header parsed.
+            break;
+    }
+
+    uint32_t width = WebPDemuxGetI(demuxer, WEBP_FF_CANVAS_WIDTH);
+    uint32_t height = WebPDemuxGetI(demuxer, WEBP_FF_CANVAS_HEIGHT);
+    uint32_t formatFlags = WebPDemuxGetI(demuxer, WEBP_FF_FORMAT_FLAGS);
+    bool hasAlpha = SkToBool(formatFlags & ALPHA_FLAG) ? 1 : 0;

[msarett, 2015/06/19 12:07:46]

Can this be simpler?
bool hasAlpha = SkToBool(formatFlags & ALPHA_FLAG);

[scroggo, 2015/06/19 18:59:58]

Lol yes. This was copied from SkImageDecoder_libwebp, where hasAlpha is an int
instead of a bool.

+
     // sanity check for image size that's about to be decoded.
     {
-        const int64_t size = sk_64_mul(features.width, features.height);
+        const int64_t size = sk_64_mul(width, height);
         if (!sk_64_isS32(size)) {
             return false;
         }
         // now check that if we are 4-bytes per pixel, we also don't overflow
         if (sk_64_asS32(size) > (0x7FFFFFFF >> 2)) {
             return false;
         }
     }
 
     if (info) {
         // FIXME: Is N32 the right type?
         // Is unpremul the right type? Clients of SkImageGenerator may assume it's the
         // best type, when Skia currently cannot draw unpremul (and raster is faster
         // with premul).
-        *info = SkImageInfo::Make(features.width, features.height, kN32_SkColorType,
-                                  SkToBool(features.has_alpha) ? kUnpremul_SkAlphaType
-                                                              : kOpaque_SkAlphaType);
+        *info = SkImageInfo::Make(width, height, kN32_SkColorType,
+                                  hasAlpha ? kUnpremul_SkAlphaType
+                                           : kOpaque_SkAlphaType);
     }
     return true;
 }
 
 SkCodec* SkWebpCodec::NewFromStream(SkStream* stream) {
     SkAutoTDelete<SkStream> streamDeleter(stream);
     SkImageInfo info;
     if (webp_parse_header(stream, &info)) {
         return SkNEW_ARGS(SkWebpCodec, (info, streamDeleter.detach()));
     }
@@ skipping 109 matching lines @@
                 // Break out of the switch statement. Continue the loop.
                 break;
             default:
                 return kInvalidInput;
         }
     }
 }
 
 SkWebpCodec::SkWebpCodec(const SkImageInfo& info, SkStream* stream)
     : INHERITED(info, stream) {}