Remove SkEncodedInfo kUnknown_Color and kUnknown_Alpha from public API

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 "SkCodecPriv.h"
 #include "SkWebpCodec.h"
 #include "SkTemplates.h"
@@ skipping 13 matching lines @@
     // WEBP starts with the following:
     // RIFFXXXXWEBPVP
     // Where XXXX is unspecified.
     const char* bytes = static_cast<const char*>(buf);
     return bytesRead >= 14 && !memcmp(bytes, "RIFF", 4) && !memcmp(&bytes[8], "WEBPVP", 6);
 }
 
 // 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, int* width, int* height, SkEncodedInfo* info) {
+bool SkWebpCodec::ReadHeader(SkStream* stream, SkCodec** outCodec) {
     unsigned char buffer[WEBP_VP8_HEADER_SIZE];
     SkASSERT(WEBP_VP8_HEADER_SIZE <= SkCodec::MinBufferedBytesNeeded());
 
     const size_t bytesPeeked = stream->peek(buffer, WEBP_VP8_HEADER_SIZE);
     if (bytesPeeked != WEBP_VP8_HEADER_SIZE) {
         // Use read + rewind as a backup
         if (stream->read(buffer, WEBP_VP8_HEADER_SIZE) != WEBP_VP8_HEADER_SIZE
             || !stream->rewind())
         return false;
     }
 
     WebPBitstreamFeatures features;
     VP8StatusCode status = WebPGetFeatures(buffer, WEBP_VP8_HEADER_SIZE, &features);
     if (VP8_STATUS_OK != status) {
         return false; // Invalid WebP file.
     }
 
     // sanity check for image size that's about to be decoded.
     {
         const int64_t size = sk_64_mul(features.width, features.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) {
+    if (outCodec) {
         SkEncodedInfo::Color color;
         SkEncodedInfo::Alpha alpha;
         switch (features.format) {
             case 0:
                 // This indicates a "mixed" format.  We would see this for
                 // animated webps or for webps encoded in multiple fragments.
                 // I believe that this is a rare case.
                 // We could also guess kYUV here, but I think it makes more
                 // sense to guess kBGRA which is likely closer to the final
                 // output.  Otherwise, we might end up converting
@@ skipping 16 matching lines @@
                 // FIXME: Should we check the has_alpha flag here?  It looks
                 //        like the image is encoded with an alpha channel
                 //        regardless of whether or not the alpha flag is set.
                 color = SkEncodedInfo::kBGRA_Color;
                 alpha = SkEncodedInfo::kUnpremul_Alpha;
                 break;
             default:
                 return false;
         }
 
-        *width = features.width;
-        *height = features.height;
-        *info = SkEncodedInfo::Make(color, alpha, 8);
+        SkEncodedInfo info = SkEncodedInfo::Make(color, alpha, 8);
+        *outCodec = new SkWebpCodec(features.width, features.height, info, stream);
     }
     return true;
 }
 
 SkCodec* SkWebpCodec::NewFromStream(SkStream* stream) {
     SkAutoTDelete<SkStream> streamDeleter(stream);
-    int width, height;
-    SkEncodedInfo info;
-    if (webp_parse_header(stream, &width, &height, &info)) {
-        return new SkWebpCodec(width, height, info, streamDeleter.release());
+    SkCodec* outCodec;
+    if (SkWebpCodec::ReadHeader(stream, &outCodec)) {

[scroggo, 2016/04/25 15:10:43]

Since ReadHeader is used only in this method, I don't see any reason to separate
the two. I would delete this method entirely, and repurpose webp_parse_header
into NewFromStream.

[msarett, 2016/04/25 15:18:21]

Of course, that's much better :).

+        // Codec has taken ownership of the stream.
+        SkASSERT(outCodec);
+        streamDeleter.release();
+        return outCodec;
     }
     return nullptr;
 }
 
 // This version is slightly different from SkCodecPriv's version of conversion_possible. It
 // supports both byte orders for 8888.
 static bool webp_conversion_possible(const SkImageInfo& dst, const SkImageInfo& src) {
     // FIXME: skbug.com/4895
     // Currently, we ignore the SkColorProfileType on the SkImageInfo.  We
     // will treat the encoded data as linear regardless of what the client
@@ skipping 158 matching lines @@
             default:
                 return kInvalidInput;
         }
     }
 }
 
 SkWebpCodec::SkWebpCodec(int width, int height, const SkEncodedInfo& info, SkStream* stream)
     // The spec says an unmarked image is sRGB, so we return that space here.
     // TODO: Add support for parsing ICC profiles from webps.
     : INHERITED(width, height, info, stream, SkColorSpace::NewNamed(SkColorSpace::kSRGB_Named)) {}